题目列表

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];}
};