题目列表

2824. 统计和小于目标的下标对数目

2825. 循环增长使字符串子序列等于另一个字符串

2826. 将三个组排序

2827. 范围中美丽整数的数目

一、统计和小于目标的下标对数目

 这题直接暴力求解，时间复杂度是O(n^2)，代码如下

class Solution {
public:int countPairs(vector<int>& nums, int target) {int n=nums.size(),ans=0;for(int i=0;i<n;i++){for(int j=i+1;j<n;j++){if(nums[i]+nums[j]<target)ans++;}}return ans;}
};

 那么时间复杂度能不能优化呢？

我们再仔细阅读一下题目，就会发现其实i<j这个条件是没必要的，因为只要我们找到符合要求的数字对，将它们的下标排个序，就可以算作答案，即数据的顺序可以改变，而两数之和相关的题目很容易让我们想到排序+双指针/二分，这里当然是选择双指针，因为更快，总的时间复杂度是O(nlogn+n)，代码如下

class Solution {
public:int countPairs(vector<int>& nums, int target) {int n=nums.size(),ans=0;sort(nums.begin(),nums.end());int left=0,right=n-1;while(left<right){int sum=nums[left]+nums[right];if(sum<target){ans+=right-left;left++;}else{right--;}}return ans;}
};

 二、循环增长使字符串子序列等于另一个字符串

 这题关键是把题目意思弄明白，即我们可以选择str1中若干个下标，让这些字符循环递增一次，使得str2成为str1的子序列。代码如下

class Solution {
public:bool canMakeSubsequence(string str1, string str2) {for(int i=0,j=0;i<str1.size();i++){char x=(str1[i]-'a'+1)%26+'a';//得到循环递增之后的字符if(str1[i]==str2[j]||str2[j]==x)j++;if(j==str2.size())return true;}return false;}
};

三、将三个组排序

 这题其实也有点绕，题目说是让你将0~n-1个数分配到三个组中进行排序，本质还是要你通过改变nums数组中的元素，将nums数组中的1，2，3按照非递减顺序排好

我们要找的最小步数其实可以转化成为n - 最长非递减子序列的长度，因为非递减子序列的元素是不用变化的，只要改变不在非递减子序列里的元素即可，很显然问题从找最小步数转换成了找最长非递减子序列的长度，代码如下

class Solution {
public://f[i]代表以i为结尾的最长非递减子序列长度//f[i]=max(f[j]+1) (nums[i]>=nums[j])int minimumOperations(vector<int>& nums) {int n=nums.size();int f[n],len=1;for(int i=0;i<n;i++){f[i]=1;for(int j=i-1;j>=0;j--){if(nums[i]>=nums[j]){f[i]=max(f[j]+1,f[i]);}}len=max(len,f[i]);}return n-len;}
};//时间复杂度更优的做法
class Solution {
public:int minimumOperations(vector<int>& nums) {int n=nums.size();vector<int> g;for(auto&x:nums){auto it=upper_bound(g.begin(),g.end(),x);//二分查找，找到大于x的第一个数if(it==g.end())g.push_back(x);else *it=x;}return n-g.size();}
};

但是这个问题的转化不是那么容易想到的，那么还有什么做法？遇到对数组元素进行修改，我们还可以用递归来想一想，为了方便转成递推，我们依旧从后往前思考

1.确定递归的参数和返回值，我们需要后面的元素值来判断该位置的元素是否需要修改，所以需要两个参数，dfs(i,j)，i表示当前元素下标，j表示后一个元素值，返回值为前i个元素中的最小步数

2.确定递归的表达式

当nums[i]==j时，dfs(i，j)=dfs(i-1，j)

当nums[i]>j时，dfs(i，j)=dfs(i+1，j)+1

当nums[i]<j时，dfs(i，j)=max(dfs(i-1，nums[i])，dfs(i-1，j)+1)

3.确定递归的边界和入口

边界：当i<0时，返回0，即没有元素需要修改了

入口：dfs(n-1,3)

代码如下

//递归---不记忆化也能过
class Solution {
public:int minimumOperations(vector<int>& nums) {int n=nums.size();function<int(int,int)> dfs=[&](int i,int j){if(i<0)return 0;if(j==nums[i])return dfs(i-1,j);if(j<nums[i])return dfs(i-1,j)+1;elsereturn min(dfs(i-1,j)+1,dfs(i-1,nums[i]));};return dfs(n-1,3);}
};//转成递推
class Solution {
public:int minimumOperations(vector<int>& nums) {int n=nums.size();int f[n+1][4];memset(f,0,sizeof(f));for(int i=0;i<n;i++){for(int j=1;j<=3;j++){if(j==nums[i])f[i+1][j]=f[i][j];else if(j<nums[i]) f[i+1][j]=f[i][j]+1;else f[i+1][j]=min(f[i][j]+1,f[i][nums[i]]);}}return f[n][3];}
};//优化空间
class Solution {
public:int minimumOperations(vector<int>& nums) {int n=nums.size();int f[4];//用几个常量代替也可以，空间复杂度为O(1)memset(f,0,sizeof(f));for(int i=0;i<n;i++){for(int j=1;j<=3;j++){if(j==nums[i])f[j]=f[j];else if(j<nums[i]) f[j]=f[j]+1;else f[j]=min(f[j]+1,f[nums[i]]);}}return f[3];}
};

四、范围中美丽整数的数目

 这题是个很典型的数位dp，主要看你有没有写过这个类型的题目，这种题的套路基本上很固定，就是dfs每一位上填哪个数字，即我们来构造数字，具体细节看代码实现，如下

//dfs
class Solution {
public:int calc(int high,int k){string s=to_string(high);int n=s.size();function<int(int,int,int,bool,bool)>dfs;//这里解释一下函数参数含义//i代表第i位，val代表奇偶数字出现的次数（奇数--val,偶数++val）下面对val的计算可以看看，挺巧妙的，作用一样//mod代表%k之后的数，下面关于mod的计算运用了取模运算符的性质，不清楚的可以去百度一下//islimit代表这个位置之前的数字是否和high的前几位相同，用来判断该位置能取的最大值//isnum代表它前面的位上有没有选数字，即这个数字有没有开始构造dfs=[&](int i,int val,int mod,bool islimit,bool isnum)->int{if(i==n)return isnum&&val==0&&mod==0;//是一个数并且奇偶数目相同并且是k的倍数int res=0;if(!isnum)res=dfs(i+1,val,mod,false,false);int up=islimit?s[i]-'0':9;//看当前位置的值最大为几for(int j=1-isnum;j<=up;j++)res+=dfs(i+1,val+j%2*2-1,(mod*10+j)%k,islimit&&up==j,true);return res;};return dfs(0,0,0,true,false);}int numberOfBeautifulIntegers(int low, int high, int k) {return calc(high,k)-calc(low-1,k);}
};//dfs+记忆化搜索
class Solution {
public:int calc(int high,int k){string s=to_string(high);int n=s.size();int memo[n][2*n+1][k];memset(memo,-1,sizeof(memo));//为了避免mod为负数，就将mod的初始值变成了n，方便记忆化搜索function<int(int,int,int,bool,bool)>dfs;dfs=[&](int i,int val,int mod,bool islimit,bool isnum)->int{if(i==n)return isnum&&val==n&&mod==0;//是一个数并且奇偶数目相同并且是k的倍数if(isnum&&!islimit&&memo[i][val][mod]!=-1)return memo[i][val][mod];int res=0;if(!isnum)res=dfs(i+1,val,mod,false,false);int up=islimit?s[i]-'0':9;//看当前位置的值最大为几for(int j=1-isnum;j<=up;j++)res+=dfs(i+1,val+j%2*2-1,(mod*10+j)%k,islimit&&up==j,true);if(isnum&&!islimit) //只有符合这两个条件的时候，才需要记忆化，因为其他情况只会出现一次，没必要记忆化memo[i][val][mod]=res;return res;};return dfs(0,n,0,true,false);}int numberOfBeautifulIntegers(int low, int high, int k) {return calc(high,k)-calc(low-1,k);}
};