第 203 场周赛

圆形赛道上经过次数最多的扇区（模拟）

数据范围只有100，直接模拟。（还有一种方法是直接数学判断起点和终点，但判断逻辑复杂，不如模拟来得快）

class Solution {
public:
    vector<int> mostVisited(int n, vector<int>& rounds) {
        vector<int> s(n + 1); // 下标从1开始

        for(int i=0;i + 1 < rounds.size(); i++)
        {
            int a = rounds[i], b = rounds[i + 1];
            while(a != b) // 算头不算尾
            {
                s[a] ++;
                a ++ ;
                if(a > n) a -= n; // 直接 - 就循环了
            }
        }
        s[rounds.back()] ++; // 最后一个尾别忘了+

        int c = 0;
        for(auto x : s) c = max(c,x);

        vector<int> res;
        for(int i=1;i<=n;i++) 
            if(s[i] == c) res.push_back(i);
        return res;
    }
};

你可以获得的最大硬币数目（贪心）

贪心。观察到取倒数第二堆，倒数第四堆，…，依次减2得到最优答案。（贪心一般和排序联系）

class Solution {
public:
    int maxCoins(vector<int>& a) {
        sort(a.begin(),a.end());
        int m = a.size() / 3;
        int res = 0;
        int j = a.size() - 2;
        while(m--)
        {
            res += a[j];
            j -= 2;
        }
        return res;
    }
};

1562. 查找大小为 M 的最新分组（分类讨论，维护区间）

分类讨论，分四种情况，维护区间。有点像操作系统里的连续内存分配
类似题目：352. 将数据流变为多个不相交区间 ---------------------------- 题解

class Solution {
public:
    
    vector<int> l,r;

    int get(int x){ // 计算以左端点得到连续区间长度
        return r[x] - x + 1;
    }

    int findLatestStep(vector<int>& arr, int m) {
        int n = arr.size();
        l.resize(n + 2), r.resize(n + 2); // 下标从1开始，要用到n+1，所以多开一个区间
        int cnt = 0, res = -1; // cnt:长度为m区间的数量
        for(int i=0;i<arr.size(); i ++ )
        {
            int x = arr[i];
            if(l[x-1] && r[x + 1]) // 左右都有连续区间
            {
                if(get(l[x-1]) == m) cnt --;
                if(get(x + 1) == m) cnt --;
                // 维护区间
                r[l[x - 1]] = r[x + 1];
                l[r[x + 1]] = l[x - 1];
                if(get(l[x - 1]) == m) cnt ++;
            }
            else if(l[x - 1]) // 只有左边有连续区间
            {
                if(get(l[x - 1]) == m) cnt --;
                r[l[x - 1]] = x,l[x] = l[x - 1];
                if(get(l[x - 1]) == m) cnt ++;
            }
            else if(r[x + 1]) // 只有右边有连续区间
            {
                if(get(x + 1) == m) cnt -- ;
                r[x] = r[x + 1];
                l[r[x + 1]] = x;
                if(get(x) == m) cnt ++;
            }
            else // 孤立点
            {
                l[x] = r[x] = x;
                if(m == 1) cnt ++;
            }

            if(cnt) res = i + 1;
        }

        return res;
    }

};

1563. 石子游戏 V(区间DP)

区间DP，时间复杂度O(n ^ 3) – 题解地址
类似题 ： 282. 石子合并

循环写法(超时)

class Solution {
public:

    vector<int> s;

    int get(int l,int r){
        return s[r] - s[l-1]; 
    }

    int stoneGameV(vector<int>& w) {
        int n = w.size();
        s.resize(n + 1);
        for(int i=1;i<=n;i++) s[i] = s[i - 1] + w[i-1]; // 前缀和下标从1开始

        // 区间DP的经典写法
        vector<vector<int>> f(n + 1,vector<int>(n + 1));
        for(int len = 2;len<=n;len++) // 1.枚举区间长度
            for(int i=1; i + len - 1 <= n ;i ++) //2. 确定左右端点  // 右端点：i + len - 1;
            {
                int j = i + len - 1;
                int &v = f[i][j];
                for(int k = i; k < j ;k ++) // 3.枚举分界点
                {
                    int left = get(i,k), right = get(k + 1,j);
                    if(left < right){
                        if(v < left + f[i][k]) v = left + f[i][k];
                    }else if(left > right){
                        if(v < right + f[k + 1][j]) v = right + f[k + 1][j];
                    }else{
                        if(v < left + max(f[i][k],f[k + 1][j])) 
                            v = left + max(f[i][k],f[k + 1][j]);
                    }
                }
            }
        
        return f[1][n];
    }
};

优化常数写法，增量方式

const int N = 510;

int s[N];

class Solution {
public:

    //vector<int> s;

    int get(int l,int r){
        return s[r] - s[l-1]; 
    }

    int stoneGameV(vector<int>& w) {
        int n = w.size();
       // s.resize(n + 1);
        memset(s,0,sizeof s);
        for(int i=1;i<=n;i++) s[i] = s[i - 1] + w[i-1]; // 前缀和下标从1开始

        // 区间DP的经典写法
        vector<vector<int>> f(n + 1,vector<int>(n + 1));
        for(int len = 2;len<=n;len++) // 1.枚举区间长度
            for(int i=1; i + len - 1 <= n ;i ++) //2. 确定左右端点  // 右端点：i + len - 1;
            {
                int j = i + len - 1,sum = get(i,j), k = i, p = w[i - 1];
                int t = 0;
                while(p < sum - p){ // 等价于 left < right
                    if(t < p + f[i][k])  t = p + f[i][k];
                    p += w[k ++ ];
                }
                if(p == sum - p){// 等价于 left ==  right
                    if(t < p + max(f[i][k],f[k + 1][j])) t = p + max(f[i][k],f[k + 1][j]);
                    p += w[k ++ ];
                }
                while(k < j){// 等价于 left >  right
                    if(t < sum - p + f[k + 1][j]) t = sum - p + f[k + 1][j];
                    p += w[k ++ ];
                }
                f[i][j] = t;
            }
        
        return f[1][n];
    }
};

递归写法

#define max(x, y) ((x) > (y) ? (x) : (y))

class Solution {
private:
    vector<vector<int>> f;
    vector<int> sum;

    int solve(int l, int r) {
        if (l == r) return 0;
        if (f[l][r] > 0) return f[l][r];

        for (int m = l; m < r; m++) {
            int lsum = sum[m] - sum[l-1], rsum = sum[r] - sum[m];
            if (lsum < rsum)
                f[l][r] = max(f[l][r], solve(l, m) + lsum);
            else if (lsum == rsum)
                f[l][r] = max(f[l][r], max(solve(l, m), solve(m+1, r)) + lsum);
            else
                f[l][r] = max(f[l][r], solve(m+1, r) + rsum);
        }

        return f[l][r];
    }

public:
    int stoneGameV(vector<int>& stoneValue) {
        const int n = stoneValue.size();
        sum.resize(n+1, 0);
        f.resize(n+1, vector<int>(n+1, 0));

        for (int i = 1; i <= n; i++)
            sum[i] = sum[i-1] + stoneValue[i-1];

        return solve(1, n);
    }
};

---

学习视频地址y总