[Leetcode Weekly Contest]301

链接：LeetCode

[Leetcode]2335. 装满杯子需要的最短总时长

现有一台饮水机，可以制备冷水、温水和热水。每秒钟，可以装满 2 杯 不同 类型的水或者 1 杯任意类型的水。
给你一个下标从 0 开始、长度为 3 的整数数组 amount ，其中 amount[0]、amount[1] 和 amount[2] 分别表示需要装满冷水、温水和热水的杯子数量。返回装满所有杯子所需的 最少 秒数。

简单贪心。
肯定是最好每次都选两个。分两种情况，一种是有一种水特别多，那么答案就是这种水的数量。否则，一定可以匹配到只剩一杯，或匹配完。

class Solution {
    public int fillCups(int[] amount) {
        Arrays.sort(amount);
        if(amount[2] == 0) return 0;
        if(amount[2] > amount[0] + amount[1]) return amount[2];
        else return 1+fillCups(new int[]{amount[0], amount[1]-1, amount[2]-1});
    }
}

[Leetcode]2336. 无限集中的最小数字

现有一个包含所有正整数的集合 [1, 2, 3, 4, 5, ...] 。
实现 SmallestInfiniteSet 类：

• SmallestInfiniteSet() 初始化 SmallestInfiniteSet 对象以包含 所有 正整数。
• int popSmallest() 移除 并返回该无限集中的最小整数。
• void addBack(int num) 如果正整数 num 不 存在于无限集中，则将一个 num 添加 到该无限集中。

逆向思维，既然原来的集合是无限的，那我就构造一个有限的。 收集被无限集踢掉的元素、踢掉被无限集收录的元素。

class SmallestInfiniteSet {
    HashSet<Integer> removeSet = new HashSet<>();
    int cur = 1;

    public SmallestInfiniteSet() {
    }

    public int popSmallest() {
        int res = cur;
        while(removeSet.contains(res)) {
            res++;
        }
        removeSet.add(res);
        cur = res+1;
        return res;
    }

    public void addBack(int num) {
        cur = Math.min(cur, num);
        if(removeSet.contains(num)) removeSet.remove(num);
    }
}

/**
 * Your SmallestInfiniteSet object will be instantiated and called as such:
 * SmallestInfiniteSet obj = new SmallestInfiniteSet();
 * int param_1 = obj.popSmallest();
 * obj.addBack(num);
 */

[Leetcode]2337. 移动片段得到字符串

给你两个字符串 start 和 target ，长度均为 n 。每个字符串 仅 由字符 'L'、'R' 和 '_' 组成，其中：

• 字符 'L' 和 'R' 表示片段，其中片段 'L' 只有在其左侧直接存在一个 空位 时才能向 左 移动，而片段 'R' 只有在其右侧直接存在一个 空位 时才能向 右 移动。
• 字符 '_' 表示可以被 任意 'L' 或 'R' 片段占据的空位。

如果在移动字符串 start 中的片段任意次之后可以得到字符串 target ，返回 true ；否则，返回 false 。

双指针 + 字符串模拟。

class Solution {
    public boolean canChange(String start, String target) {
        int n = start.length();
        int l = 0;
        for(int r=0;r<n;++r) {
            if(target.charAt(r) == '_') continue;
            else {
                char ch = target.charAt(r);
                while(l<n && start.charAt(l) == '_') {
                    ++l;
                }
                if(l>=n) return false;
                if(start.charAt(l)!=target.charAt(r))return false;
                if(target.charAt(r)=='L' && r>l)return false;
                if(target.charAt(r)=='R' && r<l)return false;
                ++l;
            }
        }
        while(l<n) {
            if(start.charAt(l) != '_') return false;
            l++;
        }
        return true;
    }
}

[Leetcode]2338. 统计理想数组的数目

给你两个整数 n 和 maxValue ，用于描述一个 理想数组 。
对于下标从 0 开始、长度为 n 的整数数组 arr ，如果满足以下条件，则认为该数组是一个 理想数组 ：

• 每个 arr[i] 都是从 1 到 maxValue 范围内的一个值，其中 0 <= i < n 。
• 每个 arr[i] 都可以被 arr[i - 1] 整除，其中 0 < i < n 。

返回长度为 n 的 不同 理想数组的数目。由于答案可能很大，返回对 \(10^9 + 7\) 取余的结果。

组合数。分别考虑以x结尾长度为n的理想数组有多少个，数组结尾可以是1 ~ maxValue，因此把这些情况累加，就是最终结果。
以结尾为4、长度为5进行分析：
4的前面可以是4、2、1， 2的前面可以是2、1， 1的前面只能是1。例如：
[1, 2, 2, 4, 4]
[1, 1, 1, 4, 4]
[2, 2, 2, 4, 4]
[4, 4, 4, 4, 4]
以[1, 2, 2, 4, 4]为例，可以记为 \([\_, *2, \_, *2, \_]\)，只需记录在哪些位置的元素发生了改变(倍增)，
从当前倍增的位置开始 ~ 下一次倍增的位置之前(或数组结尾)，将会一直维持这个值。
可假设每个数组的开头前面有一个值1，若数组中的第一个元素为1，则没有发生倍增；若第一个元素不是1，则发生了倍增。
例如：[2, 2, 2, 4, 4] 可表示为 \([*2, \_, \_, *2, \_]\)；
在同一个位置可以发生多次倍增，例如：[1, 1, 1, 4, 4] 可表示为 \([\_, \_, \_, *2*2, \_]\)；[4, 4, 4, 4, 4] 可表示为 \([*2*2, \_, \_, \_, \_]\)。
由于固定了结尾为4，而4的质因子为2、2，即 4 = (1) * 2 * 2
所有结尾为4、长度为5的理想数组，问题可转化为 结尾数字(4)的质因子可以放在哪些位置，当前有5个不同的位置，2个质因子2，
从5个位置中选择一个(将2个2放在一个位置)或两个(将2个2放在不同位置)，因为2个2是相同的，谁先谁后，结果都是一样的。所以这是个组合问题。
问题进一步转化为隔板法：把k个相同的小球放进n个不同的盒子中，允许有些盒子为空，也允许一个盒子中放入多个小球，有多少种不同的放法？
该问题可用隔板法来求解，把n个盒子当做n-1个隔板，然后加上k个小球，相当于总共有 n-1 + k 个位置，从中选出n-1个位置放隔板，
即方案数为：C(n-1+k)(n-1)
由于maxValue <= 10^{4，质因子最小为2，2}13 = 8192 < 10^4 < 16384 = 2^14，质因子越大，质因子的个数将会越小，
所以质因子为2时，质因子的个数k才能达到最大值13，即 k <= 13。所以上面的 C(n-1+k)(n-1) 可写为 C(n-1+k)(k) ，k 显然远小于n-1.
若结尾数字由多个不同的质因子组成，例如：k1个2、k2个3、k3个5，则可将问题分解为：
1、从n-1 + k1个位置中选出k1个位置放质因子2，得到 C(n-1+k1)(k1)
2、从n-1 + k2个位置中选出k2个位置放质因子3，得到 C(n-1+k2)(k2)
3、从n-1 + k3个位置中选出k3个位置放质因子5，得到 C(n-1+k3)(k3)
这3种情况之间互不影响：放质因子5的时候，不用关心这个位置之前放没放过2、3，以及放了多少个2、多少个3。
所以可采用乘法原理来计算最终结果：C(n-1+k1)(k1) * C(n-1+k2)(k2) * C(n-1+k3)(k3)

综上，原问题最终转化为：质因数分解出所有的质因子及其个数(其实只关注个数k) + 计算组合数问题
计算组合数问题 可用动态规划进行计算，假设dp[i][j] 表示从i个位置中选择j个，即 C(i)(j)。该问题可分为两种情况：
1、选择了位置i，则只需再从i-1个位置中选择j-1个，即 C(i-1)(j-1)
2、未选择位置i，则需要从i-1个位置中选择j个，即 C(i-1)(j)
所以，dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

class Solution {
    static final int MOD = (int) 1e9 + 7, MX = (int) 1e4 + 1, MX_K = 13; // 至多 13 个质因数
    static List[] ks = new List[MX]; // ks[x] 为 x 分解质因数后，每个质因数的个数列表
    static int[][] c = new int[MX + MX_K][MX_K + 1]; // 组合数

    static {
        for (var i = 1; i < MX; i++) {
            ks[i] = new ArrayList<Integer>();
            var x = i;
            for (var p = 2; p * p <= x; ++p) {
                if (x % p == 0) {
                    var k = 1;
                    for (x /= p; x % p == 0; x /= p) ++k;
                    ks[i].add(k);
                }
            }
            if (x > 1) ks[i].add(1);
        }

        c[0][0] = 1;
        for (var i = 1; i < MX + MX_K; ++i) {
            c[i][0] = 1;
            for (var j = 1; j <= Math.min(i, MX_K); ++j)
                c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
        }
    }

    public int idealArrays(int n, int maxValue) {
        var ans = 0L;
        for (var x = 1; x <= maxValue; ++x) {
            var mul = 1L;
            for (var k : ks[x]) mul = mul * c[n + (int) k - 1][(int) k] % MOD;
            ans += mul;
        }
        return (int) (ans % MOD);
    }
}

参考：LeetCode