Welcome to Subscribe On Youtube
2826. Sorting Three Groups
Description
You are given a 0indexed 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, changenums[x]
to any number from1
to3
.
A new array res
is constructed using the following procedure:
 Sort the numbers in each group independently.
 Append the elements of groups
1
,2
, and3
tores
in this order.
Array nums
is called a beautiful array if the constructed array res
is sorted in nondecreasing 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 nondecreasing 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 nondecreasing 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 nondecreasing order.
Constraints:
1 <= nums.length <= 100
1 <= 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)$.

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])); } }

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]}); } };

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)

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])) }

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); }