Leetcode---111双周赛
题目列表
2824. 统计和小于目标的下标对数目
2825. 循环增长使字符串子序列等于另一个字符串
2826. 将三个组排序
2827. 范围中美丽整数的数目
一、统计和小于目标的下标对数目
这题直接暴力求解，时间复杂度是O(n^2)，代码如下
class Solution {
public:
int countPairs(vector& nums, int target) {
int n=nums.size(),ans=0;
for(int i=0;i 那么时间复杂度能不能优化呢？
我们再仔细阅读一下题目，就会发现其实i
class Solution {
public:
int countPairs(vector& nums, int target) {
int n=nums.size(),ans=0;
sort(nums.begin(),nums.end());
int left=0,right=n-1;
while(left 二、循环增长使字符串子序列等于另一个字符串
这题关键是把题目意思弄明白，即我们可以选择str1中若干个下标，让这些字符循环递增一次，使得str2成为str1的子序列。代码如下
class Solution {
public:
bool canMakeSubsequence(string str1, string str2) {
for(int i=0,j=0;i三、将三个组排序
这题其实也有点绕，题目说是让你将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& nums) {
int n=nums.size();
int f[n],len=1;
for(int i=0;i=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& nums) {
int n=nums.size();
vector 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]
3.确定递归的边界和入口
边界：当i<0时，返回0，即没有元素需要修改了
入口：dfs(n-1,3)
代码如下
//递归---不记忆化也能过
class Solution {
public:
int minimumOperations(vector& nums) {
int n=nums.size();
function dfs=[&](int i,int j){
if(i<0)
return 0;
if(j==nums[i])
return dfs(i-1,j);
if(j& nums) {
int n=nums.size();
int f[n+1][4];
memset(f,0,sizeof(f));
for(int i=0;i& nums) {
int n=nums.size();
int f[4];//用几个常量代替也可以，空间复杂度为O(1)
memset(f,0,sizeof(f));
for(int i=0;i 四、范围中美丽整数的数目
这题是个很典型的数位dp，主要看你有没有写过这个类型的题目，这种题的套路基本上很固定，就是dfs每一位上填哪个数字，即我们来构造数字，具体细节看代码实现，如下
//dfs
class Solution {
public:
int calc(int high,int k){
string s=to_string(high);
int n=s.size();
functiondfs;
//这里解释一下函数参数含义
//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，方便记忆化搜索
functiondfs;
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);
}
};