【Leetcode】1363. Largest Multiple of Three

题目地址：

https://leetcode.com/problems/largest-multiple-of-three/

给定一个长$n$数组$A$，每个数都是$0\sim 9$，可以将其中的数进行拼接，得出一个数，问能拼接出的最大的$3$的倍数是多少，以字符串形式返回。不允许有前导$0$。如果无解，则返回空串。

一个数能被$3$整除当且仅当其各个位之和是$3$的倍数。先算一下$A$中所有数字之和$s$，如果其是$3$的倍数，那我们全要。否则我们肯定希望删除的数越少越好（这样拼起来的数的位数尽量多）。如果$s\equiv 1(\mathrm{mod}3)$，那么我们只需要删掉$A$中最小的一个模$3$余$1$的数即可，如果这样的数不存在，我们需要删掉最小的两个模$3$余$2$的数；同理，如果$s\equiv 2(\mathrm{mod}3)$，那我们只需要删最小的一个模$3$余$2$的数，如果没有，则删最小的两个模$3$余$1$的数。所以我们还需要开一个数组记录模$3$余$0,1,2$的数字个数分别是多少。然后根据$s$模$3$的情况决定删几个模$3$余几的数。代码如下：

public class Solution {
    public String largestMultipleOfThree(int[] digits) {
        int[] count = new int[10], mod3 = new int[3];
        int sum = 0;
        for (int i = 0; i < digits.length; i++) {
            sum += digits[i];
            mod3[digits[i] % 3]++;
            count[digits[i]]++;
        }
        
        // delCount记录我们要删多少个，mod记录删的数是模3余几的
        int delCount = 0, mod = 0;
        if (sum % 3 == 1) {
            if (mod3[1] >= 1) {
                delCount = 1;
                mod = 1;
            } else {
                delCount = 2;
                mod = 2;
            }
        } else if (sum % 3 == 2) {
            if (mod3[2] >= 1) {
                delCount = 1;
                mod = 2;
            } else {
                delCount = 2;
                mod = 1;
            }
        }
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < count[i]; j++) {
                if (delCount > 0 && i % 3 == mod) {
                    delCount--;
                } else {
                    sb.append(i);
                }
            }
        }
        
        sb.reverse();
        int i = 0;
        while (i < sb.length() - 1 && sb.charAt(i) == '0') {
            i++;
        }
        
        return sb.substring(i);
    }
}

时空复杂度$O(n)$。

也可以用背包思想来做。设$f[i][j]$是只从前$i$个数里选，且总和模$3$的余数是$j$的情况下，可以选最多多少个数。那么，如果第$i$个数不选，则最多可以选$f[i-1][j]$个数；如果第$i$个数$x$被选，如果$3|x$，则最多选$f[i-1][0]+1$个数，否则选$f[i-1][3-x\mathrm{mod}3]+1$个数。为了求方案，我们先将数组从小到大排序，递推出$f[n][0]$之后，倒着求方案即可。按字典序最大的方案来选。代码如下：

class Solution {
 public:
  string largestMultipleOfThree(vector<int>& A) {
    int n = A.size();
    sort(A.begin(), A.end());
    int f[n + 1][3];
    memset(f, -0x3f, sizeof f);
    f[0][0] = 0;
    for (int i = 1; i <= n; i++)
      for (int j = 0; j < 3; j++)
        f[i][j] = max(f[i - 1][j], f[i - 1][(j - A[i - 1] + 9) % 3] + 1);
    if (f[n][0] < 0) return "";

    string s;
    for (int i = n, j = 0; i; i--)
      // 如果能选A[i - 1]，则必选，这样字典序最大
      if (f[i][j] == f[i - 1][(j - A[i - 1] + 9) % 3] + 1) {
        s += to_string(A[i - 1]);
        j = (j - A[i - 1] + 9) % 3;
      }

    return s[0] == '0' ? "0" : s;
  }
};

时间复杂度$O(n\log n)$，空间$O(n)$。