LeetCode3.24-3.27

3.24 每日一题 面试题 17.16. 按摩师

题目：
一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。

示例 1：

输入： [1,2,3,1]
输出： 4
解释： 选择 1 号预约和 3 号预约，总时长 = 1 + 3 = 4。

示例 2：

输入： [2,7,9,3,1]
输出： 12
解释： 选择 1 号预约、 3 号预约和 5 号预约，总时长 = 2 + 9 + 1 = 12。

示例 3：

输入： [2,1,4,5,3,1,1,3]
输出： 12
解释： 选择 1 号预约、 3 号预约、 5 号预约和 8 号预约，总时长 = 2 + 4 + 3 + 3 = 12。

解法：
动态规划，dp[i]为轮到第i个客户时的最大时长，dp[i] = max(dp[i-1],dp[i-2]+nums[i])

public int massage(int[] nums) {
	//动态规划 dp[i]为第i个客人时的最大时长
		if(nums.length == 0 || nums == null) return 0;
		if(nums.length == 1) return nums[0];
		if(nums.length == 2) return Math.max(nums[0], nums[1]);
		
		int[] dp = new int[nums.length];
		int n = dp.length;
		dp[0] = nums[0];
		dp[1] = Math.max(nums[0], nums[1]);
		for(int i = 2; i < n; i++) {
			dp[i] = Math.max(dp[i-1], dp[i-2]+nums[i]);
		}
		return dp[n-1];
	}

3.25 每日一题 892. 三维形体的表面积

题目：
在 N * N 的网格上，我们放置一些 1 * 1 * 1 的立方体。

每个值 v = grid[i][j] 表示 v 个正方体叠放在对应单元格 (i, j) 上。

请你返回最终形体的表面积。

示例 1：

输入：[[2]]
输出：10

示例 2：

输入：[[1,2],[3,4]]
输出：34

示例 3：

输入：[[1,0],[0,2]]
输出：16

示例 4：

输入：[[1,1,1],[1,0,1],[1,1,1]]
输出：32

示例 5：

输入：[[2,2,2],[2,1,2],[2,2,2]]
输出：46

提示：

1 <= N <= 50
0 <= grid[i][j] <= 50

解法：
对于一个空格，如果有n个立方体叠加，贡献的表面积为上下两个面+每个立方体的4个面，即2+n*4。对于旁边的空格，如果立方体个数m小于n，表面积-m；如果m大于等于n，表面积-n。遍历每个空格。

public int surfaceArea(int[][] grid) {
		int ans = 0;
		for (int i = 0; i < grid.length; i++) {
			for (int j = 0; j < grid[i].length; j++) {
				if (grid[i][j] == 0) {
					continue;
				} else {
					ans += surfaceArea(grid, i, j);
				}
			}
		}
		return ans;
	}

	public int surfaceArea(int[][] grid, int i, int j) {
		int v = grid[i][j];
		int ans = 0;
		if (v == 1)
			ans = 6;
		if (v > 1)
			ans = 10 + (v - 2) * 4;
		// 上
		if (i - 1 >= 0) {
			int vUp = grid[i - 1][j];
			if (vUp >= v) {
				ans -= v;
			} else {
				ans -= vUp;
			}
		}
		// 下
		if (i + 1 < grid.length) {
			int vDown = grid[i + 1][j];
			if (vDown >= v) {
				ans -= v;
			} else {
				ans -= vDown;
			}
		}
		// 左
		if (j - 1 >= 0) {
			int vLeft = grid[i][j-1];
			if (vLeft >= v) {
				ans -= v;
			} else {
				ans -= vLeft;
			}
		}
		// 右
		if (j + 1 < grid[i].length) {
			int vRight = grid[i][j+1];
			if (vRight >= v) {
				ans -= v;
			} else {
				ans -= vRight;
			}
		}
		return ans;

	}

3.26每日一题 999. 可以被一步捕获的棋子数

题目：
在一个 8 x 8 的棋盘上，有一个白色的车（Rook），用字符 ‘R’ 表示。棋盘上还可能存在空方块，白色的象（Bishop）以及黑色的卒（pawn），分别用字符 ‘.’，‘B’ 和 ‘p’ 表示。不难看出，大写字符表示的是白棋，小写字符表示的是黑棋。

车按国际象棋中的规则移动。东，西，南，北四个基本方向任选其一，然后一直向选定的方向移动，直到满足下列四个条件之一：

棋手选择主动停下来。
棋子因到达棋盘的边缘而停下。
棋子移动到某一方格来捕获位于该方格上敌方（黑色）的卒，停在该方格内。
车不能进入/越过已经放有其他友方棋子（白色的象）的方格，停在友方棋子前。
你现在可以控制车移动一次，请你统计有多少敌方的卒处于你的捕获范围内（即，可以被一步捕获的棋子数）。

解法：找到车后遍历四个方向即可。

public int numRookCaptures(char[][] board) {
		int ans = 0;
		for(int i = 0; i < board.length; i++) {
			for(int j = 0; j < board[i].length; j++) {
				if(board[i][j] == 'R') {
					ans = numRookCaptures(board, i, j);
				}
			}
		}
		return ans;
	}

	private int numRookCaptures(char[][] board, int i, int j) {
		int ans = 0;
		//左
		for(int m = j-1; m >= 0; m--) {
			if(board[i][m] == 'p') {
				ans += 1;
				break;
			}
			if(board[i][m] == 'B') {
				break;
			}
		}
		//右
		for(int m = j+1; m < board.length; m++) {
			if(board[i][m] == 'p') {
				ans += 1;
				break;
			}
			if(board[i][m] == 'B') {
				break;
			}
		}
		//上
		for(int n = i-1; n >= 0; n--) {
			if(board[n][j] == 'p') {
				ans += 1;
				break;
			}
			if(board[n][j] == 'B') {
				break;
			}
		}
		//下
		for(int n = i+1; n <= 7; n++) {
			if(board[n][j] == 'p') {
				ans += 1;
				break;
			}
			if(board[n][j] == 'B') {
				break;
			}
		}
		return ans;
	}

3.27每日一题 914. 卡牌分组

给定一副牌，每张牌上都写着一个整数。

此时，你需要选定一个数字 X，使我们可以将整副牌按下述规则分成 1 组或更多组：

每组都有 X 张牌。
组内所有的牌上都写着相同的整数。
仅当你可选的 X >= 2 时返回 true。

示例 1：

输入：[1,2,3,4,4,3,2,1]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[3,3]，[4,4]

示例 2：

输入：[1,1,1,2,2,2,3,3]
输出：false
解释：没有满足要求的分组。

示例 3：

输入：[1]
输出：false
解释：没有满足要求的分组。

示例 4：

输入：[1,1]
输出：true
解释：可行的分组是 [1,1]

示例 5：

输入：[1,1,2,2,2,2]
输出：true
解释：可行的分组是 [1,1]，[2,2]，[2,2]

提示：

1 <= deck.length <= 10000
0 <= deck[i] < 10000

解法：
由于数组的值小于10000，可以使用长度为10000的数组记录每个数字出现的次数，使用变量max记录数组中的最大值优化。问题可以转换为每个数字出现的次数是否有大于1的公约数。

  public boolean hasGroupsSizeX(int[] deck) {
		if(deck.length == 1) return false;
		int[] count = new int[10001];
		int max = -1;
		
		//记录每个数字出现的次数和数组的最大值
		for(int i = 0; i < deck.length; i++) {
			count[deck[i]]++;
			max = Math.max(max, deck[i]);
		}

		int g = 0;
		for(int i = 0; i <= max; i++) {
			if(count[i] > 0) {
				if(g == 1) return false;
				if(g == -1) {
					g = count[i];
				}else {
					g = gcd(count[i], g);
				}
			}
		}
		return g >= 2;
	}
	
	public int gcd(int a, int b) {
		if(b == 0) return a;
		return gcd(b,a%b);
	}