【Leetcode】第136场周赛 (前三题）

5055. 困于环中的机器人

在无限的平面上，机器人最初位于 $(0, 0)$ 处，面朝北方。机器人可以接受下列三条指令之一：

$"G"$ ：直走 $1$ 个单位
$"L"$ ：左转 $90$ 度
$"R"$ ：右转 $90$ 度
机器人按顺序执行指令 $instructions$ ，并一直重复它们。

只有在平面中存在环使得机器人永远无法离开时，返回 $true$ 。否则，返回 $false$ 。

示例 $1$ ：

输入："GGLLGG"
输出：true
解释：
机器人从 (0,0) 移动到 (0,2)，转 180 度，然后回到 (0,0)。
重复这些指令，机器人将保持在以原点为中心，2 为半径的环中进行移动。

示例 $2$ ：

输入："GG"
输出：false
解释：
机器人无限向北移动。

示例 $3$ ：

输入："GL"
输出：true
解释：
机器人按 (0, 0) -> (0, 1) -> (-1, 1) -> (-1, 0) -> (0, 0) -> ... 进行移动。

提示：

1. 1 <= instructions.length <= 100
2. instructions[i] 在 {'G', 'L', 'R'} 中

思路：如果机器人无法离开环，根据题意，机器人最多重复四次指令必然会回到原点。

class Solution {
public:
	//上、左、下、右
    int dx[4] = {0, -1, 0, 1};
    int dy[4] = {1, 0, -1, 0};
    bool isRobotBounded(string instructions) {
        int x = 0, y = 0, d = 0;
        for (int i = 0; i < 4; ++i) {
            for (auto c : instructions) {
            	//前行一个单位
                if (c == 'G') {
                    x += dx[d];
                    y += dy[d];
                }
                //左转
                if (c == 'L') 
                    d = (d + 1) % 4;
                //右转
                if (c == 'R')
                    d = (d + 3) % 4;
            }
        }
        return x == 0 && y == 0;
    }
};

5056. 不邻接植花

有 $N$ 个花园，按从 $1$ 到 $N$ 标记。在每个花园中，你打算种下四种花之一。

$paths[i] = [x, y]$ 描述了花园 $x$ 到花园 $y$ 的双向路径。

另外，没有花园有 $3$ 条以上的路径可以进入或者离开。

你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。

以数组形式返回选择的方案作为答案 $answer$ ，其中 $answer[i]$ 为在第 $(i+1)$ 个花园中种植的花的种类。花的种类用 $1, 2, 3, 4$ 表示。保证存在答案。

示例 $1$ ：

输入：N = 3, paths = [[1,2],[2,3],[3,1]]
输出：[1,2,3]

示例 $2$ ：

输入：N = 4, paths = [[1,2],[3,4]]
输出：[1,2,1,2]

示例 $3$ ：

输入：N = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
输出：[1,2,3,4]

提示：

1. 1 <= N <= 10000
2. 0 <= paths.size <= 20000
3. 不存在花园有 4 条或者更多路径可以进入或离开。
4. 保证存在答案。

思路：理解题意才是解这道题的关键。因为没有花园有 $3$ 条以上的路径可以进入或者离开，所以我们可以存储每个花园到其余花园的路；当求某个花园应该种哪种花时，由于最多只有三条路径、四种花色，可以循环判断与其相连的花园的花色，排除掉这些花园的花色，选择另外的一种作为当前花园的花色

class Solution {
public:
    vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
        vector<vector<int> > vec(N, vector<int>());
        //存储每个花园到其余花园的路径
        for (auto path : paths) {
            vec[path[0] - 1].push_back(path[1] - 1);
            vec[path[1] - 1].push_back(path[0] - 1);
        }
        vector<int> ans(N);
        for (int i = 0; i < N; ++i) {
            vector<bool> flag(4, true);
            //判断与其相连的花园的花色
            for (auto elem : vec[i]) {
            	//这里是顺序判断，所以序号大于当前花园序号i的花园一律不考虑
                if (elem < i)
                	//标记与其相连的花园的花色
                    flag[ans[elem] - 1] = false;
            }
            //排除已使用的花园花色，选择另外的花色
            for (int j = 0; j < 4; ++j) {
                if (flag[j]) {
                    ans[i] = j + 1;
                    break;
                }
            }
        }
        return ans;
    }
};

5057. 分隔数组以得到最大和

给出整数数组 $A$ ，将该数组分隔为长度最多为 $K$ 的几个（连续）子数组。分隔完成后，每个子数组的中的值都会变为该子数组中的最大值。

返回给定数组完成分隔后的最大和。

示例：

输入：A = [1,15,7,9,2,5,10], K = 3
输出：84
解释：A 变为 [15,15,15,9,10,10,10]

提示：

1. 1 <= K <= A.length <= 500
2. 0 <= A[i] <= 10^6

思路：典型的动态规划题。

$dp[i]$ 表示到第i位分隔数组所得最大值
由于限定长度 $K$ ，所以有 $dp[i] = max(dp[i], maxi * (i - j + 1) + dp[j - 1])$ ， $maxi$ 表示 $j$ 到 $i$ 中的最大值， $i - j + 1$ 为长度， $dp[j - 1]$ 为到 $j-1$ 的最大值

class Solution {
public:
    int dp[505];
    int maxSumAfterPartitioning(vector<int>& A, int K) {
        memset(dp, 0, sizeof(dp));
        int n = A.size();
        for (int i = 1; i <= n; ++i) {
            int maxi = A[i - 1];
            for (int j = i; i - j < K && j > 0; --j) {
            	//获得j到i范围内的最大值
                maxi = max(maxi, A[j - 1]);
                //以j到i作为替换区间
                dp[i] = max(dp[i], maxi * (i - j + 1) + dp[j - 1]);
            }
        }
        return dp[n];
    }
};