目录
一，3190. 使所有元素都可以被 3 整除的最少操作数
二，3191. 使二进制数组全部等于 1 的最少操作次数 I
三，3192. 使二进制数组全部等于 1 的最少操作次数 II
四，3193. 统计逆序对的数目
一，3190. 使所有元素都可以被 3 整除的最少操作数
本题可以直接模拟，如果使用减法操作，那么需要操作 x % 3 次；如果使用加法操作，那么需要操作 3 - x % 3 次。问最少的操作次数，直接取两者的最小值就行。
代码如下：
class Solution {
public int minimumOperations(int[] nums) {
int ans = 0;
for(int x : nums){
ans += Math.min(Math.abs(3-x%3), x%3);
}
return ans;
}
}二，3191. 使二进制数组全部等于 1 的最少操作次数 I
本题直接从左往右遍历，注 i < nums.length-2 ：
- 遇到0，将nums[i]，nums[i+1]，nums[i+2] 反转（即 ^1），ans++
- 遇到1，什么都不做
- 循环结束判断后两个数是否全为1，如果是，返回ans；否则返回-1
代码如下：
class Solution {
public int minOperations(int[] nums) {
int ans = 0;
int i = 0;
for(; i<nums.length-2; i++){
if(nums[i]==0){
nums[i] ^= 1;
nums[i+1] ^= 1;
nums[i+2] ^= 1;
ans++;
}
}
return nums[i]==1 && nums[i+1]==1 ? ans : -1;
}
}三，3192. 使二进制数组全部等于 1 的最少操作次数 II
本题也可以采用上述做法，代码如下：
class Solution {
public int minOperations(int[] nums) {
int n = nums.length;
int ans = 0;
for(int i=0; i<n; i++){
if(nums[i] == 0){
for(int j=i; j<n; j++)
nums[j] ^= 1;
ans++;
}
}
return ans;
}
}但是该做法是O(n^2)的时间复杂度，会超时，那么上述做法还有哪里可以优化？可以发现如果一个数执行 ^1操作偶数次，它就会变回原来的值，所以我们可以统计后续元素需要执行反转操作的次数cnt，在枚举到x时，如果cnt为奇数，x ^=1，再判断 x 是否为 0，如果为0，cnt++。依次类推，最终得到的cnt就是答案。
代码如下：
class Solution {
public int minOperations(int[] nums) {
int ans = 0;
for(int i=0; i<nums.length; i++){
if(ans%2==1)
nums[i] ^= 1;
if(nums[i] == 0){
ans++;
}
}
return ans;
}
}四，3193. 统计逆序对的数目
本题可以从后先前考虑，假设有3个数，构造逆序对为2的排序:
- 如果最后一个数是2，那么该数与[0，i-1]能组成0个逆序对，就需要[0，i-1]有2个逆序对
- 如果最后一个数是1，那么该数与[0，i-1]能组成1个逆序对，就需要[0，i-1]有1个逆序对
- 如果最后一个数是0，那么该数与[0，i-1]能组成2个逆序对，就需要[0，i-1]有0个逆序对
依次类推，上述问题就化成了与原问题相同的子问题。可以定义dfs(i，j)：前 i 个数有 j 个逆序对时的排序个数。
- 没有requirements束缚，假设 k 为 perm[i] 小于[0，i-1]元素的个数，即 perm[i] 能产生 k 个逆序对，那么问题就转换成了前 i-1个数有 j - k 个逆序对的排序个数。（注：k <= Math.min(i，j)）
- 有requirements束缚，该问题就只能转换成前 i-1个数有 req[i-1] 个逆序对的排序个数。（注：req[i-1] <= j && req[i-1] >= j - i，这两个条件就表示req[i-1]的范围必须在[ j - i，j]，可以这样理解，当前perm[i]能与前i-1个数组成[0，i]个逆序对，那么前i-1个数需要有[j - i，j]个逆序对）
代码如下：
class Solution {
public int numberOfPermutations(int n, int[][] requirements) {
int[] req = new int[n];
Arrays.fill(req, -1);
req[0] = 0;
for(int[] x : requirements){
req[x[0]] = x[1];
}
if(req[0]>0) return 0;
for(int[] r : memo)
Arrays.fill(r, -1);
return dfs(n-1, req[n-1], req);
}
int[][] memo = new int[301][401];
int dfs(int i, int j, int[] req){
if(i == 0) return 1;
if(memo[i][j] != -1) return memo[i][j];
int res = 0;
int cnt = req[i-1];
if(cnt >= 0){
if(cnt <= j && cnt >= j-i)
res = dfs(i-1, cnt, req);
}else{
for(int k=0; k<=Math.min(i, j); k++){
res = (res + dfs(i-1, j-k, req))%1_000_000_007;
}
}
return memo[i][j] = res;
}
}
