题目列表
3074. 重新分装苹果
3075. 幸福值最大化的选择方案
3076. 数组中的最短非公共子字符串
3077. K 个不相交子数组的最大能量值
一、重新分装苹果
注意题目中说同一个包裹中的苹果可以分装，那么我们只要关心苹果的总量即可，在根据贪心，优先选择容量大的箱子，代码如下
class Solution {
public:
int minimumBoxes(vector<int>& apple, vector<int>& capacity) {
int sum = accumulate(apple.begin(),apple.end(),0);
ranges::sort(capacity);
int n = capacity.size(), cnt = 1;
for(int i = n - 1; i >= 0; i--){
sum-=capacity[i];
if(sum<=0) break;
cnt++;
}
return cnt;
}
};二、幸福值最大化的选择方案
由于每选一个孩子，未被选择的孩子的幸福值会减一，并且幸福值减为0后就无法在减少，所以我们肯定优先选幸福值大的孩子，因为他们的幸福值能被减少的上限更高， 即在减去一定的幸福值之后，幸福值小的，可能已经为0无法减少，但是幸福值大的还能再减，所以优先选幸福值大的孩子
class Solution {
public:
long long maximumHappinessSum(vector<int>& happiness, int k) {
long long ans = 0;
ranges::sort(happiness);
int n = happiness.size();
for(int i = 0, j = n - 1; i < k; i++, j--){
ans += max(0,happiness[j]-i);
}
return ans;
}
};三、数组中的最短非公共子字符串
这题看着很复杂，但是我们看一眼数据范围，很小，可以直接模拟，代码如下
class Solution {
public:
vector<string> shortestSubstrings(vector<string>& arr) {
int n = arr.size();
vector<string> ans(n);
for(int i = 0; i < n; i++){
string& s = arr[i];
int m = s.size();
for(int sub = 1; sub <= m; sub++){
vector<string> v;
for(int start = 0; start + sub - 1 < m; start++){
string tmp = s.substr(start,sub);
bool flag = true;
for(int j = 0; j < n; j++){
if(i == j) continue;
if(arr[j].find(tmp)!=-1){
flag = false;
break;
}
}
if(flag) v.push_back(tmp);
}
if(v.size()){
sort(v.begin(),v.end());
ans[i] = v[0];
break;
}
}
}
return ans;
}
};四、K个不相交子数组的最大能量值
这题是个很经典的划分型dp，一般这种题的状态定义都是f[i][j]表示前i个数字分为j段的...，
这题也是同理
状态定义：f[i][j]表示前i个数字分为j段的最大能量和
转移方程：
1、如果不选择第i个数，f[ i ][ j ] = f[ i-1 ][ j ]
2、如果选择第i个数，f[ i ][ j ] = max(f[x][j-1]+(___)) ，表示 MAX( 前x个数字分为j-1段的最大能量+[x+1，i]的能量值 ) 其中 ___ = (pre[i] - pre[x])*(k-j+1)*(-1)^j
3、初始化：i<j的状态都是不合理的，因为i个数字无法被分为j组，可以设置为无穷小，f[x][0]=0
代码如下
class Solution {
//f[i][j]表示前i个分成j段的最大能量值
//f[i][j]=max(dp[x][j-1]+(...),dp[i-1][j])
// 选择[x+1,i]为第j段 不选第i个数
// j-1<=x<i
// ... = (pre[i] - pre[x])*(k-j+1)*(-1)^j
public:
long long maximumStrength(vector<int>& nums, int k) {
int n=nums.size();
long long pre[n+1];pre[0]=0;
for(int i=0;i<n;i++) pre[i+1]=pre[i]+nums[i];
vector<vector<long long>> f(n+1,vector<long long>(k+1));
for(int i=1;i<=k;i++) f[i-1][i]=LLONG_MIN;// 状态转移时只会用到(i-1,i)这些非法状态，其他可以不管
for(int i=1;i<=n;i++){
for(int j=1;j<=min(k,i);j++){
int w=(j&1?1:-1)*(k-j+1);
f[i][j]=f[i-1][j];//不选
for(int x=j-1;x<i;x++){//以[x+1,i]为第j段
f[i][j]=max(f[i][j],f[x][j-1]+(pre[i]-pre[x])*w);
}
}
}
return f[n][k];
}
};但是这样写的时间复杂度显然太高了，需要优化， 如何优化？？？(数学推导)
设w=(k-j+1)*(-1)^j，则___ = w*(pre[i] - pre[x]) = w*pre[i] - w*pre[x]
则f[ i ][ j ] = max(f[x][j-1]+w*pre[i] - w*pre[x]) = w*pre[i] + max(f[x][j-1] - w*pre[x])
我们会发现max(表达式)只与x和j有关，并且x是从前往后遍历的，也就是说我们只要保持j不变，那么max(表达式)就是求该表达式的前缀最大值，不需要每次循环都来算，那么关键在于如何保持j不变，这个其实也很简单，只要交换i和j的循环顺序即可，即外层循环为j，内层循环为i，代码如下
class Solution {
//f[i][j]表示前i个分成j段的最大能量值
//f[i][j]=max(dp[x][j-1]+(...),dp[i-1][j])
// 选择[x+1,i]为第j段 不选第i个数
// j-1<=x<=i
// ... = (pre[i+1] - pre[x])*(k-j+1)*(-1)^j
public:
long long maximumStrength(vector<int>& nums, int k) {
int n=nums.size();
long long pre[n+1];pre[0]=0;
for(int i=0;i<n;i++) pre[i+1]=pre[i]+nums[i];
vector<vector<long long>> f(n+1,vector<long long>(k+1));
for(int j=1;j<=k;j++){
f[j-1][j]=LLONG_MIN;
int w=(j&1?1:-1)*(k-j+1);
long long mx = LLONG_MIN;
for(int i=j;i<=n;i++){
mx = max(mx,f[i-1][j-1]-w*pre[i-1]);
f[i][j]=max(f[i-1][j],pre[i]*w+mx);
}
}
return f[n][k];
}
};
