Leetcode第136场周赛学习

1041.困于环中的机器人

题目描述

在无限的平面上，机器人最初位于 (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'} 中

参考思路

如果按照指令走完一次后机器人回到原点，则说明机器人无法离开，此时返回true。
当按照指令走完一次后机器人未返回原点，如果朝向不与初始时一致，即向北，则说明它在绕圈，如此也会成环，返回true。

参考代码

class Solution
{
	int dx[4]={0,1,0,-1};
	int dy[4]={1,0,-1,0};
public:
	bool isRobotBounded(string instructions)
	{
		int x=0,y=0,z=0,i,n=instructions.size();
		for(i=0;i<n;i++)
			if(instructions[i]=='G')
			{
				x+=dx[z];
				y+=dy[z];
			}
			else if(instructions[i]=='L')
				z=z+3&3;
			else
				z=z+1&3;
		if(!x&&!y)
			return 1;
		return !!z;
	}
};

上述代码中，用dx，dy表示每个朝向的单位向量。向右转表示顺时针转1次，并将结果与3求与以保证有意义，向右转表示顺时针转3次，将结果与3求与以保证有意义。

1042.不邻接植花

题目描述

有 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 <= N <= 10000
• 0 <= paths.size <= 20000
• 不存在花园有 4 条或者更多路径可以进入或离开。
• 保证存在答案。

参考思路

首先建立邻接矩阵。
随后从第一个花园开始进行遍历：
如果当前花园有花，则进入下一个花园的处理；如果当前花园没种花，则将其种上第1种花，随后BFS其邻接的花园，对于每一个邻接的花园，如果其没种花，则查看当前邻接花园所邻接的花园，如果有某个花园与当前要种的花种类相同，则当前花园不能种这种，找到合适的花后，将当前花园压入队列，去种它的邻接花园的花。

参考代码

class Solution {
public:
    vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
        vector<int> v[N];
        for (auto e : paths)//邻接矩阵
        {
            v[e[0]-1].push_back(e[1]-1);
            v[e[1]-1].push_back(e[0]-1);
        }
        vector<int> u(N);
        for (int i = 0; i < N; ++ i)
        {
            if (u[i]) continue;//种过了
            queue<int> Q;
            Q.push(i);
            u[i] = 1;
            while (!Q.empty())
            {
                int x = Q.front();
                Q.pop();
                for (auto y : v[x])
                {
                    if (u[y]) continue;
                    for (int c = 1; c <= 4; ++ c)
                    {
                        int flag = 0;
                        for (auto z : v[y])//有重复
                            if (u[z] == c) flag = 1;
                        if (!flag)
                        {
                            u[y] = c;
                            break;
                        }
                    }
                    Q.push(y);
                }
            }
        }
        return u;
    }
};

1043.分给数组以得到最大和

题目描述

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

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

提示：

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

参考思路

采用动态规划的思路：首先求出每个子数组A[i:j]中的最大值，对于示例，如下所示：

随后，对于每一个终点i，从起点开始，和的最大值在上次计算出的最大值和新的A[j:i]之间的最大值的j倍。

参考代码

class Solution {
public:
    int maxSumAfterPartitioning(vector<int>& A, int K) 
    {
        int m[505][505],n=A.size(),i,j,f[505];
        for(i=0;i<n;i++)//求A[i:j]的最大值
        	for(m[i+1][i+1]=A[i],j=i+1;j<n;j++)
        		m[i+1][j+1]=max(m[i+1][j],A[j]);
        memset(f,0,sizeof(f));      	
        for(i=1;i<=n;i++)
        	for(j=1;j<=i && j<=K;j++)
        		f[i]=max(f[i],f[i-j]+m[i-j+1][i]*j);
        return f[n];
    }
};