1262、可被三整除的最大和（扩展、可被k整除的最大和）

LeetCode 1262

可被三整除的最大和

---

给你一个整数数组 nums，请你找出并返回能被三整除的元素最大和。

示例 1：

输入：nums = [3,6,5,1,8]
输出：18
解释：选出数字 3, 6, 1 和 8，它们的和是 18（可被 3 整除的最大和）。

示例 2：

输入：nums = [4]
输出：0
解释：4 不能被 3 整除，所以无法选出数字，返回 0。

示例 3：

输入：nums = [1,2,3,4,4]
输出：12
解释：选出数字 1, 3, 4 以及 4，它们的和是 12（可被 3 整除的最大和）。

提示：

• 1 <= nums.length <= 4 * 10^4
• 1 <= nums[i] <= 10^4

解法：动态规划

解题思路：

求最大和的思路就是找到一个最大的序列，那要如何找到该序列呢？我们知道，一个数对三取余后只有三个值(0,1,2),那么我们就用一个二维数组

dp[i][3]表示[0,i]的各序列和中对三取余分别为0,1,2的整数和大小

那么dp[i][3]就能根据dp[i-1][3]求得，具体看下面代码

代码如下：

class Solution {
    public int maxSumDivThree(int[] nums) {
        int n = nums.length;

        int[][] dp = new int[n+1][3];
        dp[0][0] = 0;
        dp[0][1] = Integer.MIN_VALUE;
        dp[0][2] = Integer.MIN_VALUE;

        for (int i = 1; i <= n; i++) {
            if (nums[i-1] % 3 == 0) {
                dp[i][0] = Math.max(dp[i-1][0], dp[i-1][0] + nums[i-1]);
                dp[i][1] = Math.max(dp[i-1][1], dp[i-1][1] + nums[i-1]);
                dp[i][2] = Math.max(dp[i-1][2], dp[i-1][2] + nums[i-1]);
            } else if (nums[i-1] % 3 == 1) {
                dp[i][0] = Math.max(dp[i-1][0], dp[i-1][2] + nums[i-1]);
                dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] + nums[i-1]);
                dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1] + nums[i-1]);
            } else if (nums[i-1] % 3 == 2) {
                dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + nums[i-1]);
                dp[i][1] = Math.max(dp[i-1][1], dp[i-1][2] + nums[i-1]);
                dp[i][2] = Math.max(dp[i-1][2], dp[i-1][0] + nums[i-1]);
            }
        }
        return dp[n][0];
    }
}

该题的解题思想就是状态转移，比如说我们求一个数组和就是求一个被1整除的数组和，因为只有1，所以不需要状态转移

当我们求一个被k整除的数组和时，我们需要保存数组模k为0~k-1的最大和,因此dp[i][j]就能通过dp[i-1][j]计算得到，最后的结果就是dp[i][0]

因此我们把题目扩展成求能被k整除的最大和

求能被k整除的最大和

class Solution {
    private int maxSumDivN(int[] nums, int k) {
        int n = nums.length;
        int[][] dp = new int[n + 1][k]; //表示从[0,n]的对k取余为[0,k-1]的最大和
        for (int j = 0; j < k; ++j) 
        {
            dp[0][j] = 0;
        }
        boolean[] flag = new boolean[k]; //标记下一个最大状态和是否更新
        for (int i = 0; i < n; ++i) 
        {
            int num = nums[i];
            for(int j = 0; j < k; ++j) //从i位置的每一个状态最大和求下一个位置的状态最大和
            {
                int sum = dp[i][j] + num; 
                flag[sum % k] = true; //dp[i+1][sum%k]状态和已求出
                dp[i + 1][sum % k] = Math.max(sum, Math.max(dp[i + 1][sum % k], dp[i][sum % k]));
                //因为相同的状态和可能会有多个，所以要取最大 Math.max(dp[i+1][sum%k],dp[i][sum%k])
            }
            for(int j = 0; j < k; ++j) 
            {
                if(flag[j]) //恢复初始状态
                    flag[j] = false;
                else 
                // 状态和没有更新，所以继承上一个的状态和，
                //不进行这一步的话dp[i+1][j]的状态和为0就会影响到下一个状态和的求取
                    dp[i + 1][j] = dp[i][j];
            }
        }
        return dp[n][0]; //返回结果
    } 
}