LeetCode周赛276场，Amazon赞助，你能做出几题？

class Solution {
public:
    vector<string> divideString(string s, int k, char fill) {
        vector<string> ret;
        int n = s.length();
        for (int i = 0; i < n; i += k) {
            if (i+k < n) 
                // 如果还能拆分，则取出s[i, i+k]子串
                ret.push_back(s.substr(i, k));
            else {
                // 不能拆分
                string cur = "";
                // 下标超过范围则选fill，否则选s[j]
                for (int j = i; j < i+k; j++) {
                    if (j < n) cur.push_back(s[j]);
                    else cur.push_back(fill);
                }
                ret.push_back(cur);
            }
        }
        
        return ret;
    }
};

class Solution {
public:
    int minMoves(int target, int maxDoubles) {
        int ret = 0;
        while (target > 1) {
            // 如果为奇数，之前一位操作一定是+1
            if (target % 2) {
                ret++;
                target--;
                continue;
            }
            // 如果为偶数，且翻倍操作还没用完，则之前一位操作为翻倍
            if (maxDoubles > 0) {
                maxDoubles--;
                target /= 2;
                ret++;
            // 如果用完了所有翻倍次数，只能通过+1得到
            }else {
                ret += (target-1);
                break;
            }
        }
        return ret;
    }
};

class Solution {
public:
    long long arr[2000050];
    
    long long mostPoints(vector<vector<int>>& questions) {
        long long ret = 0;
        int n = questions.size();
        
        for (int i = 0; i < n; i++) {
            // 滚动维护状态i的最大值
            if (i > 0) arr[i] = max(arr[i], arr[i-1]);
            // 当前问题回答之后能够达到的收益
            long long c = arr[i] + questions[i][0];
            ret = max(ret, c);
            int next = i + questions[i][1] + 1;
            // 更新状态next，对于next之后的位置可以通过arr[i] = max(arr[i], arr[i-1]);维护
            if (next < n) arr[next] = max(arr[next], c);
        }
        
        return ret;
    }
};

class Solution {
public:
    long long maxRunTime(int n, vector<int>& batteries) {
        int k = batteries.size();
        if (k < n) return 0;
        // 按电池电量倒叙排列
        sort(batteries.begin(), batteries.end(), greater<int>());
        
        long long ret = batteries[n-1];
        long long left = 0;
        // 求出充电组的电量总和
        for (int i = n; i < k; i++) left += batteries[i];
        
        int s = n-1;
        // 从电量最低的电池开始充电
        while (left > 0 && s > 0) {
            // 充电的量为要充电的电池数*和前一位的电量差距
            long long req = (n-s) * (batteries[s-1] - batteries[s]);
            if (left >= req) {
                left -= req;
                ret += batteries[s-1] - batteries[s];
            }else {
                ret += left / (n-s);
                left = 0;
                break;
            }
            s--;
        }
        // 如果所有电池电量相等之后还有剩余，就平均分配
        if (left > 0) ret += left / n;
        return ret;
    }
};