目录
一，3074. 重新分装苹果
二，3075. 幸福值最大化的选择方案
三，3076. 数组中的最短非公共子字符串
四，3077. K 个不相交子数组的最大能量值
一，3074. 重新分装苹果
本题是一道阅读理解题，就是将数组apple中的所有苹果全部放入capacity中，问最少需要多少个箱子。先算出总的苹果树，再将箱子从小到大排序，然后将苹果放入箱子（从大到小放），代码如下：
class Solution {public int minimumBoxes(int[] apple, int[] capacity) {int sum = 0;for(int x : apple)sum += x;Arrays.sort(capacity);int n = capacity.length;for(int i=n-1; i>=0; i--){sum -= capacity[i];if(sum <= 0)return n-i;}return -1;}
}二，3075. 幸福值最大化的选择方案
本题也是阅读理解题，本质就是贪心，从大到小选择，每选择一个孩子，那么剩下的孩子的幸福值全部减一且幸福值不会小于零(即幸福值>=0)。代码如下：
class Solution {public long maximumHappinessSum(int[] happiness, int k) {Arrays.sort(happiness);int j = 0;int n = happiness.length;long ans = 0;for(int i=n-1; i>=0&&j<k; i--){if(happiness[i] > j){ans += happiness[i]-j;j++;}elsereturn ans;}return ans;}
}三，3076. 数组中的最短非公共子字符串
本题数据范围较小，可以直接暴力求解，代码如下：
class Solution {public String[] shortestSubstrings(String[] arr) {int n = arr.length;String[] ans = new String[n];for (int i = 0; i < n; i++) {int m = arr[i].length();String res = "";for (int size = 1; size <= m && res.isEmpty(); size++) {for (int j = size; j <= m; j++) {String t = arr[i].substring(j - size, j);if ((res.isEmpty() || t.compareTo(res) < 0) && check(arr, i, t)) {res = t;}}}ans[i] = res;}return ans;}private boolean check(String[] arr, int i, String sub) {for (int j = 0; j < arr.length; j++) {if (j != i && arr[j].contains(sub)) {return false;}}return true;}
}四，3077. K 个不相交子数组的最大能量值
划分dp
定义 f [ i ][ j ] 表示将前 j 个数分成 i 段所得到的最大值
根据题目要求，f [ i ] [ j ] 的转移来源有两个：
- 不选择当前数，那么f[ i ][ j ]可以等价于将前 j - 1 个数分成 i 段所得到的最大值， 即 f [ i ][ j-1 ]
- 选择当前数，设选择的子数组的范围是[L，j）该子数组的和为 pre[ j ] - pre[ L ]，那么当前的转移方程是 f [i - 1][ L ] + (k-i+1) * (-1)^(i+1) * (pre[ j ]- pre[ L ] )
可以得到如下的递推方程：
f [ i ][ j ] = Math.max( f [ i ][ j - 1]，f [i - 1][ L ] + (k-i+1) * (-1)^(i+1) * (pre[ j ]- pre[ L ] ) )
可以看出来，如果要计算上述 f [ i ][ j ]，需要遍历三个未知数 i ，j，L，这样的话就会超时，所以还要优化。可以将上述的方程因式分解：
设 w = (-1)^(i+1)
f [ i ][ j ] = Math.max( f [ i ][ j - 1]，f [i - 1][ L ] + w * (pre[ j ] - pre[ L ] ) )
= Math.max( f [ i ][ j - 1]，f [i - 1][ L ] - w * pre[ L ] + w * pre[ j ] )
可以看出只有 mx = f [i - 1][ L ] - w * pre[ L ] 与 L 有关系，能否将 L 这层循环省略：
当 j = i 时，计算 L = { i - 1 }
当 j = i+1时，计算 L = { i - 1，i }
当 j = i+2时，计算 L = { i - 1，i，i + 1 }
.....
可以看出 L 除了等于 j-1时没有重复计算，其他情况一直在重复计算，通过这一特点，就可以将L这层循环给省略掉了。
注：i <= j，因为要将 j 个数分成 i 段，那么至少也要有 i 个数
代码如下：
class Solution {public long maximumStrength(int[] nums, int k) {//f[i][j]:前j个数分成i段//f[i][j] = Max(f[i][j-1], f[i][L]+(k-i+1)*(-1)^k*(pre[j]-pre[l]))int n = nums.length;long[][] f = new long[k+1][n+1];long[] pre = new long[n+1];for(int i=0; i<n; i++)pre[i+1] = pre[i] + nums[i];for(int i=1; i<k+1; i++){f[i][i-1] = Long.MIN_VALUE/2;long mx = Long.MIN_VALUE/2;int w = (k-i+1)*(i%2==1?1:-1);for(int j=i; j<=n-k+i; j++){mx = Math.max(mx, f[i-1][j-1]-w*pre[j-1]);f[i][j] = Math.max(f[i][j-1], mx + w*pre[j]);}}return f[k][n];}
}
