一、机器人移动
假设有排成一行的N个位置记为1~N,N一定大于或等于2
开始时机器人在其中的start位置上(start一定是1~N中的一个)
如果机器人来到1位置,那么下一步只能往右来到2位置;
如果机器人来到N位置,那么下一步只能往左来到N-1位置;
如果机器人来到中间位置,那么下一步可以往左走或者往右走;
规定机器人必须走K步,最终能来到aim位置(P也是1~N中的一个)的方法有多少种
给定四个参数 N,start,aim,K 返回能走到的方法数
思路
代码实现
public class Code01_RobotWalk {
public static int ways1(int N, int start, int aim, int K) {
if (N < 2 || start < 1 || start > N || aim < 1 || aim > N || K < 1) {
return -1;
}
return process1(start, K, aim, N);
}
// 机器人当前来到的位置是cur,
// 机器人还有rest步需要去走,
// 最终的目标是aim,
// 有哪些位置?1~N
// 返回:机器人从cur出发,走过rest步之后,最终停在aim的方法数,是多少?
public static int process1(int cur, int rest, int aim, int N) {
// 当前可走步数为0,表明走完了
if (rest == 0) {
// 如果当前走到的位置为aim, 说明路径正确,返回1,否则返回0
return cur == aim ? 1 : 0;
}
// rest > 0,还可以走
// 如果cur为1,只能向左走
if (cur == 1) {
return process1(2, rest - 1, aim, N);
}
// 如果cur为N,只能向右走
if (cur == N) {
return process1(N - 1, rest - 1, aim, N);
}
// 如果在中间,则既可以左走也可以右走
return process1(cur + 1, rest - 1, aim, N) + process1(cur - 1, rest - 1, aim, N);
}
public static int ways2(int N, int start, int aim, int K) {
if (N < 2 || start < 1 || start > N || aim < 1 || aim > N || K < 1) {
return -1;
}
int[][] dp = new int[N+1][K+1];
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= K; j++) {
dp[i][j] = -1;
}
}
return process2(start, K, aim, N, dp);
}
public static int process2(int cur, int rest, int aim, int N, int[][] dp) {
if (dp[cur][rest] != -1) {
return dp[cur][rest];
}
int ans = 0;
if (rest == 0) {
ans = cur == aim ? 1 : 0;
} else if (cur == 1){
ans = process2(2, rest - 1, aim, N, dp);
} else if (cur == N) {
ans = process2(N - 1, rest - 1, aim, N, dp);
} else {
ans = process2(cur + 1, rest - 1, aim, N, dp) + process2(cur - 1, rest - 1, aim, N, dp);
}
dp[cur][rest] = ans;
return ans;
}
public static int ways3(int N, int start, int aim, int K) {
if (N < 2 || start < 1 || start > N || aim < 1 || aim > N || K < 1) {
return -1;
}
int[][] dp = new int[N + 1][K + 1];
dp[aim][0] = 1;
for(int rest = 1; rest <= K; rest++) {
// 第二行初始化
dp[1][rest] = dp[2][rest - 1];
for(int cur = 2; cur < N; cur++) {
dp[cur][rest] = dp[cur + 1][rest - 1] + dp[cur - 1][rest - 1];
}
// 最后一行初始化
dp[N][rest] = dp[N - 1][rest - 1];
}
return dp[start][K];
}
public static void main(String[] args) {
System.out.println(ways1(5, 2, 4, 6));
System.out.println(ways2(5, 2, 4, 6));
System.out.println(ways3(5, 2, 4, 6));
}
}
二、纸牌博弈
给定一个整型数组arr,代表数值不同的纸牌排成一条线
玩家A和玩家B依次拿走每张纸牌
规定玩家A先拿,玩家B后拿
但是每个玩家每次只能拿走最左或最右的纸牌
玩家A和玩家B都绝顶聪明
请返回最后获胜者的分数
思路
代码实现
public class Code02_CardsInLine {
public static int win1(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int first = f1(arr, 0, arr.length - 1);
int second = g1(arr, 0, arr.length - 1);
return Math.max(first, second);
}
// 先手获取的最好分数
public static int f1(int[] arr, int L, int R) {
if (L == R) {
return arr[L];
}
int p1 = arr[L] + g1(arr, L + 1, R); // 先手获取L位置的牌
int p2 = arr[R] + g1(arr, L, R - 1); // 先手获取R位置的牌
return Math.max(p1, p2);
}
// 后手获取的最好分数
public static int g1(int[] arr, int L, int R) {
if (L == R) {
return 0;
}
int p1 = f1(arr, L + 1, R); // 后手,在先手拿到L位置的牌之后
int p2 = f1(arr, L, R - 1); // 后手,在先手拿到R位置的牌之后
return Math.min(p1, p2);
}
// 傻缓存 动归
public static int win2(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int N = arr.length;
// 创建先手和后手的缓存
int[][] fmap = new int[N][N];
int[][] gmap = new int[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
fmap[i][j] = -1;
gmap[i][j] = -1;
}
}
int first = f2(arr, 0, arr.length - 1, fmap, gmap);
int second = g2(arr, 0, arr.length - 1, fmap, gmap);
return Math.max(first, second);
}
// 先手获取的最好分数
public static int f2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
if (fmap[L][R] != -1) {
return fmap[L][R];
}
int ans = 0;
if (L == R) {
ans = arr[L];
} else {
int p1 = arr[L] + g2(arr, L + 1, R, fmap, gmap); // 先手获取L位置的牌
int p2 = arr[R] + g2(arr, L, R - 1, fmap, gmap); // 先手获取R位置的牌
ans = Math.max(p1, p2);
}
fmap[L][R] = ans;
return ans;
}
// 后手获取的最好分数
public static int g2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
if (gmap[L][R] != -1) {
return gmap[L][R];
}
int ans = 0;
if (L == R) {
ans = 0;
} else {
int p1 = f2(arr, L + 1, R, fmap, gmap); // 后手,在先手拿到L位置的牌之后
int p2 = f2(arr, L, R - 1, fmap, gmap); // 后手,在先手拿到R位置的牌之后
ans = Math.min(p1, p2);
}
gmap[L][R] = ans;
return ans;
}
// 傻缓存 动归
public static int win3(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int N = arr.length;
// 创建先手和后手的缓存
int[][] fmap = new int[N][N];
int[][] gmap = new int[N][N];
for (int i = 0; i < N; i++) {
fmap[i][i] = arr[i];
}
// 从第二列开始
for (int startCol = 1; startCol < N; startCol++) {
int L = 0;
int R = startCol;
while (R < N) {
/*int p1 = arr[L] + g1(arr, L + 1, R); // 先手获取L位置的牌
int p2 = arr[R] + g1(arr, L, R - 1); // 先手获取R位置的牌
return Math.max(p1, p2);*/
fmap[L][R] = Math.max(arr[L] + gmap[L+1][R], arr[R] + gmap[L][R-1]);
/*int p1 = f1(arr, L + 1, R); // 后手,在先手拿到L位置的牌之后
int p2 = f1(arr, L, R - 1); // 后手,在先手拿到R位置的牌之后
return Math.min(p1, p2);*/
gmap[L][R] = Math.min(fmap[L+1][R], fmap[L][R-1]);
L++;
R++;
}
}
return Math.max(fmap[0][N - 1], gmap[0][N - 1]);
}
public static void main(String[] args) {
int[] arr = { 5, 7, 4, 5, 8, 1, 6, 0, 3, 4, 6, 1, 7 };
System.out.println(win1(arr));
System.out.println(win2(arr));
System.out.println(win3(arr));
}
}