题目列表
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;
else
return 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);
}
};
