题目列表
3079. 求出加密整数的和
3080. 执行操作标记数组中的元素
3081. 替换字符串中的问号使分数最小
3082. 求出所有子序列的能量和
一、求出加密整数的和
按照题目要求，直接模拟即可，代码如下
class Solution {
public:
int sumOfEncryptedInt(vector<int>& nums) {
int n=nums.size(),res=0;
for(auto x:nums){
int s = 0, mx = 0;
while(x){
mx=max(mx,x%10);
s=s*10+1;
x/=10;
}
res+=mx*s;
}
return res;
}
};二、执行操作标记数组中的元素
题目不难，依旧还是只需要模拟，但是代码量不少，要细心，思路如下：
对于每次查询的操作1：只要判断垓下标是否被标记，然后处理即可
对于每次查询的操作2：要把没有标记过的最小的k个数字标记，如果数字相同则下标小的先标记，很显然要排序(两个维度的排序---首先比较数值，其次比较下标)，这里讲一个技巧：我们没必要将数值和下标打包在一起(即用pair)排序，我们可以直接对下标进行排序，具体看代码
如何表示一个数是否被标记？可以额外开一个数组，也可以直接在原数组上修改，将标记过的数记为-1
代码如下
class Solution {
public:
vector<long long> unmarkedSumArray(vector<int>& nums, vector<vector<int>>& queries) {
int n = nums.size(), m = queries.size();
vector<long long> ans(m);
vector<int>idx(n);
long long s = 0;
for(int i=0;i<n;i++) {
idx[i]=i;
s+=nums[i];
}
sort(idx.begin(),idx.end(),[&](int x,int y){
return nums[x]!=nums[y]?nums[x]<nums[y]:x<y;
});
for(int i=0,j=0;i<m;i++){
const auto& v = queries[i];
int index = v[0], k = v[1];
if(nums[index]>=0){
s -= nums[index];
nums[index] = -1;
}
while(k&&j<n){
if(nums[idx[j]]<0){
j++;
continue;
}
s -= nums[idx[j]];
nums[idx[j]]=-1;
j++,k--;
}
ans[i]=s;
}
return ans;
}
};三、替换字符串中的问号使分数最小
这题是思维题：
首先我们要明白字母出现的顺序并不会影响它们对总分数的贡献(因为字母对分数的贡献仅仅只和该字母出现的次数有关，字母与其他字母之间是相互独立的)，也就是说我们只要考虑每个 '?' 填哪个字母即可，根据cost的定义，我们优先考虑之前出现次数少的字母对 '?' 进行填充，当出现次数一样少时，我们优先考虑字典序小的字母，然后对选出的字母进行排序，最后按照 '?' 的位置进行替换即可。
代码如下
class Solution {
public:
string minimizeStringValue(string s) {
int n = s.size();
string tmp;
int cnt[26] = { 0 },c = 0;
for(const auto& e:s){
if(e!='?') cnt[e-'a']++;
else c++;
}
auto cmp=[](const pair<int,int>& x,const pair<int,int>& y)->bool{
return x.first!=y.first ? x.first > y.first : x.second > y.second;
};
priority_queue<pair<int,int>,vector<pair<int,int>>,decltype(cmp)> pq(cmp); //小堆
for(int i=0;i<26;i++)
pq.push({cnt[i],i});
while(c--){
auto [x,ch] = pq.top();
pq.pop();
pq.push({x+1,ch});
tmp += 'a'+ch;
}
sort(tmp.begin(),tmp.end());
for(int i=0,j=0;i<n;i++){
if(s[i]=='?')
s[i]=tmp[j++];
}
return s;
}
};四、求出所有子序列的能量和
这题找子序列中的子序列，看着很绕，其实就是找和为k的子序列能出现在多少个子序列中，即和为k的子序列做出的贡献，拿示例一举例：和为3的子序列有[1,2]和[3]，其中[1,2]在2个子序列中出现，[3]在4个子序列中出现，所以答案为2+4=6。很显然每个和为3的子序列的贡献为2^(n-L)，其中n为整个数组的长度，L为子序列的长度。
故答案的表达式为 sum(2^(n-L) * num_K_L) 1<=L<=n，num_K_L表示长为L，和为K的子序列个数
如何求长为L，和为K的子序列的个数？
这是一个背包问题，限制条件有两个：1、长为L 2、和为K
设f[i][L][c]表示前i个数中，长为L，和为c的子序列的个数
1、如果当前的数不在和为c的子序列中，则f[i][L][c]=f[i-1][L][c]
2、如果当前的数在和为c的子序列中，则f[i][L][c]=f[i-1][L-1][c-nums[i]]
所以f[i][L][c]=f[i-1][L][c]+f[i-1][L-1][c-nums[i-1]]
初始化：f[i][0][0]=1，因为长为0，和为0的子序列只能是空，只有一个
代码如下
class Solution {
public:
int sumOfPower(vector<int>& nums, int k) {
int n=nums.size();
const int MOD = 1e9+7;
int f[n+1][n+1][k+1];
memset(f,0,sizeof(f));
//f[i][L][j] = f[i-1][L][j] + f[i-1][L-1][j-nums[i]]
for(int i=0;i<=n;i++)
f[i][0][0]=1;
for(int i=0;i<n;i++){
for(int j=1;j<=k;j++){
for(int L=1;L<=i+1;L++){
f[i+1][L][j] = (f[i][L][j] + (j>=nums[i]?f[i][L-1][j-nums[i]]:0))%MOD;
}
}
}
long long ans = 0, pow2 = 1;
for(int i=n;i>0;i--){
ans = (ans + f[n][i][k]*pow2)%MOD;
pow2 = pow2*2%MOD;
}
return ans%MOD;
}
};
// 优化空间
class Solution {
public:
int sumOfPower(vector<int>& nums, int k) {
int n=nums.size();
const int MOD = 1e9+7;
int f[n+1][k+1];
memset(f,0,sizeof(f));
f[0][0]=1;
for(int i=0;i<n;i++){
for(int j=k;j>=nums[i];j--){
for(int L=1+i;L>0;L--){
f[L][j] = (f[L][j] + f[L-1][j-nums[i]])%MOD;
}
}
}
long long ans = 0, pow2 = 1;
for(int i=n;i>0;i--){
ans = (ans + f[i][k]*pow2)%MOD;
pow2 = pow2*2%MOD;
}
return ans%MOD;
}
};当然我们也可以根据题目直接定义状态：f[i][j]表示前i个数为数组的，元素和为k的能量值
1、如果nums[i]不在子序列和为k的序列中，那么它有选和不选两种可能，f[i+1][j]=f[i][j]*2
2、如果nums[i]在子序列和为k的序列中，那么它只能被选，f[i+1][j]=f[i][j-nums[i]]
举个例子[1,2,3]，要求和为3，假设遍历到 i = 2 ，如果nums[i]=3不在我们想要的子序列中，那么它可以选，也可以不选，即f[i][j] * 2，如果nums[i]=3在我们想要的子序列中，那么它只能被选，即f[i][j-nums[i]]
所以状态转移方程为 f[i+1][j]=f[i][j] * 2+ f[i][j-nums[i]]
代码如下
class Solution {
public:
int sumOfPower(vector<int>& nums, int k) {
const int MOD=1e9+7;
int n=nums.size();
vector<vector<long long>>f(n+1,vector<long long>(k+1));
f[0][0]=1;
for(int i=0;i<n;i++){
for(int j=0;j<=k;j++){
f[i+1][j]=(f[i][j]*2+(j>=nums[i]?f[i][j-nums[i]]:0))%MOD;
}
}
return f[n][k];
}
};
//优化空间
class Solution {
public:
int sumOfPower(vector<int>& nums, int k) {
const int MOD=1e9+7;
int n=nums.size();
vector<long long>f(k+1);
f[0]=1;
for(int i=0;i<n;i++){
for(int j=k;j>=0;j--){
f[j]=(f[j]*2+(j>=nums[i]?f[j-nums[i]]:0))%MOD;
}
}
return f[k];
}
};
