第 242 场周赛

第 242 场周赛

5763. 哪种连续子字符串更长

题目链接

• 模拟

模拟

分别记录最长的连续 1 的个数和最长连续 0 的个数

class Solution {
public:
    bool checkZeroOnes(string s) {
        int max_one = 0, max_zero = 0;
        int s0 = 0, s1 = 0;
        for (size_t i = 0; i < s.size(); ++i) {
            if (s[i] == '0') s0++, s1 = 0;
            else s1++, s0 = 0;
            max_one = max(max_one, s1);
            max_zero = max(max_zero, s0);
        }
        
        return max_one > max_zero;
    }
};

---

5764. 准时到达的列车最小时速

题目链接

• 二分查找

二分查找

最小速度是 1，最大可能需要的速度是 max(最大距离，最后站距离 / 最后一站需要的最少时间)，然后直接二分判断即可

class Solution {
public:
    bool is_arrived(int v, const vector<int>& dist, double hour) {
        double sum_ti = 0.0;
        for (size_t i = 0; i < dist.size() - 1; ++i) {
            // dist[i] / v 向上取整
            int ti = (dist[i] + v - 1) / v;
            sum_ti += ti;
        }
        sum_ti += (dist.back() * 1.0 / v);
        return sum_ti <= hour;
    }
    
    int minSpeedOnTime(vector<int>& dist, double hour) {
        if (dist.size() - 1 >= hour) return -1;
        
        int max_v = -1;
        for (size_t i = 0; i < dist.size(); ++i) max_v = max(max_v, dist[i]);
        if (hour - (int)hour > 0) {
            max_v = max(max_v, (int)(dist.back() / (hour - (int)hour)) + 5);
        }
        int min_v = 1;

        while (min_v < max_v) {
            int mid_v = (min_v + max_v) / 2;
            if (is_arrived(mid_v, dist, hour)) {
                max_v = mid_v;
            } else {
                min_v = mid_v + 1;
            }
        }
        return min_v;
    }
};

• 整数除以整数向上取整的技巧：
  $$\lceil \frac{a}{b}\rceil =\lfloor \frac{a+b-1}{b}\rfloor$$

---

5765. 跳跃游戏 VII

• 队列
• 动态规划

队列

首先如果序列的最后一个元素是 1，则表示一定不能到达，否则：

• 首先将第一个元素 0，所能跳跃的区间范围加入队列
• 依次遍历序列中的元素，如果遇到零元素，判断该元素与队首区间的位置关系：
  • 如过队列为空，表示该元素不可到达，且后续元素也均不可到达，直接返回 false
  • 如果该元素的位置在队首区间的左边，表示该元素不可到达，但是后续可到达区间中可能还存在零元素
  • 如果该元素在队首区间的右边，将队首区间出队，该元素继续和剩下的区间比较
  • 如果该元素在队首区间范围内，表示该元素可到达，直接将该元素可到达的区间范围加入队列（注意：加入的区间不可以超出序列的范围）
• 如果整个过程中出现队列为空，则返回false，否则最后返回 true

class Solution {
public:
    bool canReach(string s, int minJump, int maxJump) {
        if (s.back() == '1') return false;
        
        queue<pair<int, int> > que;
        while (!que.empty()) que.pop();
        
        que.push(make_pair(minJump, maxJump));
        for (size_t i = 1; i < s.size(); ++i) {
            if (s[i] == '0') {
                while (!que.empty()) {
                    pair<int, int> front = que.front();
                    if (front.first > i) break;
                    else if (front.second < i) {
                        que.pop();
                    } else {
                        if (i + minJump < s.size())
                            que.push(make_pair(i + minJump, min(i + maxJump, s.size())));
                        break;
                    }
                }
                if (que.empty()) return false;
            }
        }
        return true;
    }
};

动态规划

首先还是如果序列的最后一个元素是 1 表示一定不能到达。

否则令 $f[i]$ 表示是否可以到达位置 $i$，$f[i]=1$ 表示可以到达：

• $f[i]=1$ 当且仅当序列 $s[i]=0andf[i-maxJump,i-minJump]$ 中存在元素为 1

• 判断 $f[i-maxJump,i-minJump]$ 范围内是否存在元素 1 可以使用前缀和实现

class Solution {
public:
    bool canReach(string s, int minJump, int maxJump) {
        if (s.back() == '1') return false;
        
        int len = s.size();
        int f[len + 5], sm[len + 5];
        memset(f, 0, sizeof f);
        memset(sm, 0, sizeof sm);

        f[1] = sm[1] = 1;
        for (int i = 2; i <= len; ++i) {
            if (s[i - 1] == '0' && i - minJump > 0) {
                int r = i - minJump;
                int l = max(1, i - maxJump);
                f[i] = (sm[r] - sm[l - 1] > 0);
            }
            sm[i] = sm[i - 1] + f[i];
        }
        return f[len];
    }
};

---

1872. 石子游戏 VIII

题目链接

• 博弈类型的动态规划

博弈类型的动态规划

在任意一名玩家进行操作之后，剩余的所有石子的价值总和不会发生变化。

对于每一步操作，玩家可以把最左侧的枚石子进行价值合并，并获得与价值等价的分数。因此，最左侧的石子的价值一定是 stones 的某一个前缀和，即玩家在每一轮获得的分数一定是初始数组 stones 的某一个前缀和。

设 $f[i]$ 表示当前选手可以选择的下标 $u$ 在 $[i,n)$ 时，与对手分数的最大差值。

最大差值 = 当前选手的分数 - 对手的分数，而不是 （当前选手的分数 - 对手分数）的绝对值

那么现在考虑当前选手是否选择第 $i$ 个元素：

• 选择：$f[i]=pre[i]-f[i+1]$

  • pre[i] 表示当前选手选择了第 $i$ 号位置的元素之后可以获得的分数
  • $f[i+1]$ 表示，对手从 $[i+1,n)$ 可以获得的最大分数差。

  假设当前从 $[i,n)$ 进行选择的选手为 A，下一次 B 将从$[i+1,n)$ 进行选择，而 B 是足够聪明的，为了缩小与 A 之前选择的分差，一定会尽可能拉大之后选择的分差，而 $f[i+1]$ 此时可以看作是 B 作为先手的情况，$f[i+1]=Scor{e}_B-Scor{e}_A$ 的最大值，则：
  $$f[i]=\mathrm{pre}[i](\text{ 当前选择获得的分数 })+Scor{e}_A(A\text{之后选择获得的分数 })-Scor{e}_B(B\text{ 之后选择获得的分数 }).$$

• 不选择：$f[i]=f[i+1]$，即当前选手不选择位置为 $i$ 的元素，那么最大差值就为从 $i+1$ 开始选择可以获得的最大差值。

综上：$f[i]=max(f[i+1],pre[i]-f[i+1])$

class Solution {
public:
    int stoneGameVIII(vector<int>& stones) {
        int n = stones.size();
        for (int i = 1; i < n; ++i) stones[i] += stones[i - 1];

        int dp[n + 5];
        memset(dp, 0, sizeof dp);
        dp[n - 1] = stones[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            dp[i] = max(dp[i + 1], stones[i] - dp[i + 1]);
        }
        return dp[1];
    }
};