5055. 困于环中的机器人
在无限的平面上,机器人最初位于 ( 0 , 0 ) (0, 0) (0,0) 处,面朝北方。机器人可以接受下列三条指令之一:
"
G
"
"G"
"G":直走
1
1
1 个单位
"
L
"
"L"
"L":左转
90
90
90 度
"
R
"
"R"
"R":右转
90
90
90 度
机器人按顺序执行指令
i
n
s
t
r
u
c
t
i
o
n
s
instructions
instructions,并一直重复它们。
只有在平面中存在环使得机器人永远无法离开时,返回 t r u e true true。否则,返回 f a l s e false false。
示例 1 1 1:
输入:"GGLLGG"
输出:true
解释:
机器人从 (0,0) 移动到 (0,2),转 180 度,然后回到 (0,0)。
重复这些指令,机器人将保持在以原点为中心,2 为半径的环中进行移动。
示例 2 2 2:
输入:"GG"
输出:false
解释:
机器人无限向北移动。
示例 3 3 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 N N 个花园,按从 1 1 1 到 N N N 标记。在每个花园中,你打算种下四种花之一。
p a t h s [ i ] = [ x , y ] paths[i] = [x, y] paths[i]=[x,y] 描述了花园 x x x 到花园 y y y 的双向路径。
另外,没有花园有 3 3 3 条以上的路径可以进入或者离开。
你需要为每个花园选择一种花,使得通过路径相连的任何两个花园中的花的种类互不相同。
以数组形式返回选择的方案作为答案 a n s w e r answer answer,其中 a n s w e r [ i ] answer[i] answer[i] 为在第 ( i + 1 ) (i+1) (i+1) 个花园中种植的花的种类。花的种类用 1 , 2 , 3 , 4 1, 2, 3, 4 1,2,3,4 表示。保证存在答案。
示例 1 1 1:
输入:N = 3, paths = [[1,2],[2,3],[3,1]]
输出:[1,2,3]
示例 2 2 2:
输入:N = 4, paths = [[1,2],[3,4]]
输出:[1,2,1,2]
示例 3 3 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 3 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 A A,将该数组分隔为长度最多为 K K 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
思路:典型的动态规划题。
- d p [ i ] dp[i] dp[i]表示到第i位分隔数组所得最大值
- 由于限定长度 K K K,所以有 d p [ i ] = m a x ( d p [ i ] , m a x i ∗ ( i − j + 1 ) + d p [ j − 1 ] ) dp[i] = max(dp[i], maxi * (i - j + 1) + dp[j - 1]) dp[i]=max(dp[i],maxi∗(i−j+1)+dp[j−1]), m a x i maxi maxi表示 j j j到 i i i中的最大值, i − j + 1 i - j + 1 i−j+1为长度, d p [ j − 1 ] dp[j - 1] dp[j−1]为到 j − 1 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];
}
};