LeetCode---388周赛

题目列表

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