力扣第301场周赛补题

第一题：装满杯子需要的最短总时长

示例

输入：amount = [1,4,2]
输出：4
解释：下面给出一种方案：
第 1 秒：装满一杯冷水和一杯温水。
第 2 秒：装满一杯温水和一杯热水。
第 3 秒：装满一杯温水和一杯热水。
第 4 秒：装满一杯温水。
可以证明最少需要 4 秒才能装满所有杯子。

思路

首先两种操作

1.  装两杯不同的水
2. 装一杯任意类型的水

这样要想使用最少次数装完，肯定尽可能多的使用操作1，每次对较大的两个进行操作完成后都排序，然后继续对较大的两个操作。

还有另一种想法：先排序，a[0]、a[1]、a[2]分别用a、b、c表示，若c>a+b，则无论你怎么使用操作1，c都是最大的，所以c分别与b和a做操作1，然后对自己剩余杯数进行操作2，这种情况答案就是c。若c<=a+b，若总和为偶数，则答案为sum/2，若为奇数，最后一次操作需要使用操作2，答案为(sum+1)/2即sum/2向上取整。

代码

class Solution {
public:
    int fillCups(vector<int>& amount) {
        int res=0;
        while(amount[0]+amount[1]+amount[2]){//只要有杯子没装水就循环
            sort(amount.begin(),amount.end());//排序
            amount[2]--;//只要满足循环条件最大的就一定不为0
            if(amount[1]) amount[1]--;//如果第二大的不为0也减1 
            res++;
        }
        return res;
    }
};

规律写法

class Solution {
public:
    int fillCups(vector<int>& amount) {
        sort(amount.begin(),amount.end());
        if(amount[2]>amount[1]+amount[0]) return amount[2];
        else return (amount[0]+amount[1]+amount[2]+1)/2;
    }
};

第二题：无限集中的最小数字

 示例

输入
["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", "popSmallest", "addBack", "popSmallest", "popSmallest", "popSmallest"]
[[], [2], [], [], [], [1], [], [], []]
输出
[null, null, 1, 2, 3, null, 1, 4, 5]

解释
SmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();
smallestInfiniteSet.addBack(2);    // 2 已经在集合中，所以不做任何变更。
smallestInfiniteSet.popSmallest(); // 返回 1 ，因为 1 是最小的整数，并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 2 ，并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 3 ，并将其从集合中移除。
smallestInfiniteSet.addBack(1);    // 将 1 添加到该集合中。
smallestInfiniteSet.popSmallest(); // 返回 1 ，因为 1 在上一步中被添加到集合中，
                                   // 且 1 是最小的整数，并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 4 ，并将其从集合中移除。
smallestInfiniteSet.popSmallest(); // 返回 5 ，并将其从集合中移除。

思路

因为数据只有一千，直接把1000个数放入set当作初始化操作，set有序且可以去重。

代码

class SmallestInfiniteSet {
public:
    set<int> s;
    SmallestInfiniteSet() {
        for(int i=1;i<=1000;i++){
            s.insert(i);
        }
    }
    
    int popSmallest() {
        int t=*s.begin();
        s.erase(s.begin());//若要取最后一个元素用*s.rbegin()
        return t;
    }
    
    void addBack(int num) {
        s.insert(num);
    }
};

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

第三题： 移动片段得到字符串

示例

输入：start = "_L__R__R_", target = "L______RR"
输出：true
解释：可以从字符串 start 获得 target ，需要进行下面的移动：
- 将第一个片段向左移动一步，字符串现在变为 "L___R__R_" 。
- 将最后一个片段向右移动一步，字符串现在变为 "L___R___R" 。
- 将第二个片段向右移动散步，字符串现在变为 "L______RR" 。
可以从字符串 start 得到 target ，所以返回 true 。

思路

根据题目L只能左移，R只能右移，且出现R在L左的情况，两者都无法越过对方，综上可看出若start串能变成target串，不仅两串中L和R的数量要相等，他们的相对位置也要相等且，且start的L要在target的右侧，start的R要在target的左侧。

代码

class Solution {
public:
    bool canChange(string start, string target) {
        int n = start.size();
        for(int i = 0,j = 0;i < n;i++)
        {
            while(i < n && start[i] == '_')i++;//每次直接找到下一个字母的位置
            while(j < n && target[j] == '_')j++;
            if(start[i] != target[j]) return false;//保证相对位置正确
            if(start[i] == 'R' && i>j) return false;//start的R要在target的R的左侧 不满足则false
            if(start[i] == 'L' && i<j) return false;//start的L要在target的L的右侧 不满足则false
            j++;
        }
        return true;
    }
};

第四题： 统计理想数组的数目

示例

输入：n = 2, maxValue = 5
输出：10
解释：存在以下理想数组：
- 以 1 开头的数组（5 个）：[1,1]、[1,2]、[1,3]、[1,4]、[1,5]
- 以 2 开头的数组（2 个）：[2,2]、[2,4]
- 以 3 开头的数组（1 个）：[3,3]
- 以 4 开头的数组（1 个）：[4,4]
- 以 5 开头的数组（1 个）：[5,5]
共计 5 + 2 + 1 + 1 + 1 = 10 个不同理想数组

思路

比赛的时候想到用f(i,j)表示以i为结尾长度为j的数组，但硬是没搞出状态转移方程，发现最近几次周赛的dp好像都是这样状态表示的。(先算没有相同元素的数组方案数，再用隔板法算有重复元素的数组方案数)

 然后用f(i,j)*C(n-1,j-1)就可以得到长度为n的以i为结尾的有j种元素的数组方案数

代码

class Solution {
public:
    int idealArrays(int n, int m) {
        const int MOD=1e9+7;
        vector<vector<int>> f(m+1,vector<int>(15));
        for(int i=1;i<=m;i++) f[i][1]=1;
        //计算无相同元素的以i结尾长度为j的数组的方案数
        //若无相同元素，数组以最小倍数2自增(1的话就重复了所以最小倍数为2) 2的14次方大于maxValue的上限
        //则数组最长不超过14
        for(int j=1;j<14;j++)
            for(int i=1;i<=m;i++)
                for(int k=2;k*i<=m;k++)//枚举i的倍数
                    f[k*i][j+1]=(f[k*i][j+1]+f[i][j])%MOD;//状态转移在i后面添加k*i 
        
        vector<vector<int>> c(n,vector<int>(15));//求组合数
        for(int i=0;i<n;i++)
            for(int j=0;j<=i&&j<14;j++)
                if(!j) c[i][j]=1;
                else c[i][j]=(c[i-1][j]+c[i-1][j-1])%MOD;

        int res=0;
        for(int i=1;i<=m;i++)
            for(int j=1;j<=14&&j<=n;j++)
                res=(res+(long long)f[i][j]*c[n-1][j-1])%MOD;
                //f[i][j]表示以i结尾长度为j的无重复元素的数组方案
                //c[n-1][j-1]用重复元素把长度从j填充到n的方案
                //相互独立则乘积即为以i结尾的长度为n的数组方案数
        return res;
    }
};