Description#
You are given a 0-indexed integer array nums of length n.
The numbers from 0 to n - 1 are divided into three groups numbered from 1 to 3, where number i belongs to group nums[i]. Notice that some groups may be empty.
You are allowed to perform this operation any number of times:
- Pick number
x and change its group. More formally, change nums[x] to any number from 1 to 3.
A new array res is constructed using the following procedure:
- Sort the numbers in each group independently.
- Append the elements of groups
1, 2, and 3 to res in this order.
Array nums is called a beautiful array if the constructed array res is sorted in non-decreasing order.
Return the minimum number of operations to make nums a beautiful array.
Example 1:
Input: nums = [2,1,3,2,1]
Output: 3
Explanation: It's optimal to perform three operations:
1. change nums[0] to 1.
2. change nums[2] to 1.
3. change nums[3] to 1.
After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3,4] and group 2 and group 3 become empty. Hence, res is equal to [0,1,2,3,4] which is sorted in non-decreasing order.
It can be proven that there is no valid sequence of less than three operations.
Example 2:
Input: nums = [1,3,2,1,3,3]
Output: 2
Explanation: It's optimal to perform two operations:
1. change nums[1] to 1.
2. change nums[2] to 1.
After performing the operations and sorting the numbers in each group, group 1 becomes equal to [0,1,2,3], group 2 becomes empty, and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order.
It can be proven that there is no valid sequence of less than two operations.
Example 3:
Input: nums = [2,2,2,2,3,3]
Output: 0
Explanation: It's optimal to not perform operations.
After sorting the numbers in each group, group 1 becomes empty, group 2 becomes equal to [0,1,2,3] and group 3 becomes equal to [4,5]. Hence, res is equal to [0,1,2,3,4,5] which is sorted in non-decreasing order.
Constraints:
1 <= nums.length <= 1001 <= nums[i] <= 3
Solutions#
Solution 1: Dynamic Programming#
We define $f[i][j]$ as the minimum number of operations to turn the first $i$ numbers into a beautiful array, and the $i$th number is changed to $j+1$. The answer is $\min(f[n][0], f[n][1], f[n][2])$.
We can enumerate all cases where the $i$th number is changed to $j+1$, and then take the minimum value. Here, we can use a rolling array to optimize the space complexity.
The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Solution:
def minimumOperations(self, nums: List[int]) -> int:
f = g = h = 0
for x in nums:
ff = gg = hh = 0
if x == 1:
ff = f
gg = min(f, g) + 1
hh = min(f, g, h) + 1
elif x == 2:
ff = f + 1
gg = min(f, g)
hh = min(f, g, h) + 1
else:
ff = f + 1
gg = min(f, g) + 1
hh = min(f, g, h)
f, g, h = ff, gg, hh
return min(f, g, h)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| class Solution {
public int minimumOperations(List<Integer> nums) {
int[] f = new int[3];
for (int x : nums) {
int[] g = new int[3];
if (x == 1) {
g[0] = f[0];
g[1] = Math.min(f[0], f[1]) + 1;
g[2] = Math.min(f[0], Math.min(f[1], f[2])) + 1;
} else if (x == 2) {
g[0] = f[0] + 1;
g[1] = Math.min(f[0], f[1]);
g[2] = Math.min(f[0], Math.min(f[1], f[2])) + 1;
} else {
g[0] = f[0] + 1;
g[1] = Math.min(f[0], f[1]) + 1;
g[2] = Math.min(f[0], Math.min(f[1], f[2]));
}
f = g;
}
return Math.min(f[0], Math.min(f[1], f[2]));
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| class Solution {
public:
int minimumOperations(vector<int>& nums) {
vector<int> f(3);
for (int x : nums) {
vector<int> g(3);
if (x == 1) {
g[0] = f[0];
g[1] = min(f[0], f[1]) + 1;
g[2] = min({f[0], f[1], f[2]}) + 1;
} else if (x == 2) {
g[0] = f[0] + 1;
g[1] = min(f[0], f[1]);
g[2] = min(f[0], min(f[1], f[2])) + 1;
} else {
g[0] = f[0] + 1;
g[1] = min(f[0], f[1]) + 1;
g[2] = min(f[0], min(f[1], f[2]));
}
f = move(g);
}
return min({f[0], f[1], f[2]});
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| func minimumOperations(nums []int) int {
f := make([]int, 3)
for _, x := range nums {
g := make([]int, 3)
if x == 1 {
g[0] = f[0]
g[1] = min(f[0], f[1]) + 1
g[2] = min(f[0], min(f[1], f[2])) + 1
} else if x == 2 {
g[0] = f[0] + 1
g[1] = min(f[0], f[1])
g[2] = min(f[0], min(f[1], f[2])) + 1
} else {
g[0] = f[0] + 1
g[1] = min(f[0], f[1]) + 1
g[2] = min(f[0], min(f[1], f[2]))
}
f = g
}
return min(f[0], min(f[1], f[2]))
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| function minimumOperations(nums: number[]): number {
let f: number[] = new Array(3).fill(0);
for (const x of nums) {
const g: number[] = new Array(3).fill(0);
if (x === 1) {
g[0] = f[0];
g[1] = Math.min(f[0], f[1]) + 1;
g[2] = Math.min(f[0], Math.min(f[1], f[2])) + 1;
} else if (x === 2) {
g[0] = f[0] + 1;
g[1] = Math.min(f[0], f[1]);
g[2] = Math.min(f[0], Math.min(f[1], f[2])) + 1;
} else {
g[0] = f[0] + 1;
g[1] = Math.min(f[0], f[1]) + 1;
g[2] = Math.min(f[0], Math.min(f[1], f[2]));
}
f = g;
}
return Math.min(...f);
}
|
Solution 2#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Solution:
def minimumOperations(self, nums: List[int]) -> int:
f = [0] * 3
for x in nums:
g = [0] * 3
if x == 1:
g[0] = f[0]
g[1] = min(f[:2]) + 1
g[2] = min(f) + 1
elif x == 2:
g[0] = f[0] + 1
g[1] = min(f[:2])
g[2] = min(f) + 1
else:
g[0] = f[0] + 1
g[1] = min(f[:2]) + 1
g[2] = min(f)
f = g
return min(f)
|
