1266. 访问所有点的最小时间
平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。
你可以按照下面的规则在平面上移动：
- 每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
- 必须按照数组中出现的顺序来访问这些点。
示例 1
输入：points = [[1,1],[3,4],[-1,0]]
输出：7
解释：一条最佳的访问路径是： [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]
从 [1,1] 到 [3,4] 需要 3 秒
从 [3,4] 到 [-1,0] 需要 4 秒
一共需要 7 秒
示例 2
输入：points = [[3,2],[-2,2]]
输出：5
提示
points.length == n1 <= n <= 100points[i].length == 2-1000 <= points[i][0], points[i][1] <= 1000
解题思路
[1,1] -> [2,2] 移动两步，耗时 1 秒
坐标之间移动所需时间：两坐标 x 和 y 差值的最大值
这题 Java 解法都是 100%，100% ♪(^∇^*)
题解 JAVA 实现
public int minTimeToVisitAllPoints(int[][] points) {
int result = 0;
for (int i = 1; i < points.length; i++) {
int x = Math.abs(points[i][0] - points[i - 1][0]);
int y = Math.abs(points[i][1] - points[i - 1][1]);
result += Math.max(x, y);
}
return result;
}
1267. 统计参与通信的服务器
这里有一幅服务器分布图，服务器的位置标识在 m * n 的整数矩阵网格 grid 中，1 表示单元格上有服务器，0 表示没有。
如果两台服务器位于同一行或者同一列，我们就认为它们之间可以进行通信。
请你统计并返回能够与至少一台其他服务器进行通信的服务器的数量。
示例 1
输入：grid = [[1,0],[0,1]]
输出：0
解释：没有一台服务器能与其他服务器进行通信。
示例 2
输入：grid = [[1,0],[1,1]]
输出：3
解释：所有这些服务器都至少可以与一台别的服务器进行通信。
示例 3
输入：grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
输出：4
解释：第一行的两台服务器互相通信，第三列的两台服务器互相通信，但右下角的服务器无法与其他服务器通信。
提示
m == grid.lengthn == grid[i].length1 <= m <= 2501 <= n <= 250grid[i][j] == 0 or 1
解题思路
计算每行每列的机器个数及所有机器坐标
循环机器坐标，判断所在行列是否仅为 1 台
题解 JAVA 实现
public int countServers(int[][] grid) {
Map<Integer, Integer> mapx = new HashMap<>();
Map<Integer, Integer> mapy = new HashMap<>();
List<Integer[]> list = new ArrayList<>();
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) {
mapx.put(i, mapx.getOrDefault(i, 0) + 1);
mapy.put(j, mapy.getOrDefault(j, 0) + 1);
list.add(new Integer[]{i, j});
}
}
}
int result = 0;
for (Integer[] integers : list) {
if (mapx.get(integers[0]) > 1 || mapy.get(integers[1]) > 1) {
result++;
}
}
return result;
}
1268. 搜索推荐系统
给你一个产品数组 products 和一个字符串 searchWord ，products 数组中每个产品都是一个字符串。
请你设计一个推荐系统，在依次输入单词 searchWord 的每一个字母后，推荐 products 数组中前缀与 searchWord 相同的最多三个产品。如果前缀相同的可推荐产品超过三个，请按字典序返回最小的三个。
请你以二维列表的形式，返回在输入 searchWord 每个字母后相应的推荐产品的列表。
示例 1
输入：products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”], searchWord = “mouse”
输出：[
[“mobile”,“moneypot”,“monitor”],
[“mobile”,“moneypot”,“monitor”],
[“mouse”,“mousepad”],
[“mouse”,“mousepad”],
[“mouse”,“mousepad”]
]
解释：按字典序排序后的产品列表是 [“mobile”,“moneypot”,“monitor”,“mouse”,“mousepad”]
输入 m 和 mo，由于所有产品的前缀都相同，所以系统返回字典序最小的三个产品 [“mobile”,“moneypot”,“monitor”]
输入 mou， mous 和 mouse 后系统都返回 [“mouse”,“mousepad”]
示例 2
输入：products = [“havana”], searchWord = “havana”
输出：[[“havana”],[“havana”],[“havana”],[“havana”],[“havana”],[“havana”]]
示例 3
输入：products = [“bags”,“baggage”,“banner”,“box”,“cloths”], searchWord = “bags”
输出：[[“baggage”,“bags”,“banner”],[“baggage”,“bags”,“banner”],[“baggage”,“bags”],[“bags”]]
示例 4
输入：products = [“havana”], searchWord = “tatiana”
输出：[[],[],[],[],[],[],[]]
提示
1 <= products.length <= 10001 <= Σ products[i].length <= 2 * 10^4products[i]中所有的字符都是小写英文字母。1 <= searchWord.length <= 1000searchWord中所有字符都是小写英文字母。
解题思路
- 现对数据排序，找出首字母与查找单词相同的词，出入 List
- 循环从 List 找出第 0.1.2…searchWord.length-1 个字母与查找单词相同的
- List 超过 3 个单词，返回前三个，不超过 3 个单词，返回 List
题解 JAVA 实现
public List<List<String>> suggestedProducts(String[] products, String searchWord) {
List<List<String>> result = new ArrayList<>(searchWord.length());
List<String> list = new ArrayList<>(products.length);
Arrays.sort(products);
char first = searchWord.toCharArray()[0];
for (String product : products) {
if (product.toCharArray()[0] == first) {
list.add(product);
}
}
for (int i = 0; i < searchWord.length(); i++) {
List<String> l = new ArrayList<>();
list = search(list, searchWord, i);
int size = list.size();
for (int j = 0; j < Math.min(size, 3); j++) {
l.add(list.get(j));
}
result.add(l);
}
return result;
}
public List<String> search(List<String> products, String searchWord, int x) {
List<String> list = new ArrayList<>();
for (String product : products) {
if (product.toCharArray().length > x && product.toCharArray()[x] == searchWord
.toCharArray()[x]) {
list.add(product);
}
}
return list;
}
1269. 停在原地的方案数
有一个长度为 arrLen 的数组，开始有一个指针在索引 0 处。
每一步操作中，你可以将指针向左或向右移动 1 步，或者停在原地（指针不能被移动到数组范围外）。
给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。
由于答案可能会很大，请返回方案数 模 10^9 + 7 后的结果。
示例 1
输入：steps = 3, arrLen = 2
输出：4
解释：3 步后，总共有 4 种不同的方法可以停在索引 0 处。
向右，向左，不动
不动，向右，向左
向右，不动，向左
不动，不动，不动
示例 2
输入：steps = 2, arrLen = 4
输出：2
解释：2 步后，总共有 2 种不同的方法可以停在索引 0 处。
向右，向左
不动，不动
示例 3
输入：steps = 4, arrLen = 2
输出：8
提示
1 <= steps <= 5001 <= arrLen <= 10^6
解题思路
如果第 X 步停留在 Y 处的
则第 X-1 步应停留在 Y-1 或 Y 或 Y+1 处
以此类推（需判断 Y-1 和 Y+1 是否越界）
题解 JAVA 实现
public int numWays(int steps, int arrLen) {
Long mod = 1000000007L;
long[][] result = new long[steps + 1][steps + 1];
int min = Math.min(arrLen, steps);
result[0][0] = 1L;
for (int i = 1; i <= steps; i++) {
for (int j = 0; j < min; j++) {
// 1. 第i-1步到位置j，i步停留原地j
result[i][j] = result[i - 1][j];
if (j != 0) {
// 3. 第i-1步到位置j-1，i步右移到j
result[i][j] += result[i - 1][j - 1];
}
if (j != min - 1) {
// 2. 第i-1步到位置j+1，i步左移到j
result[i][j] += result[i - 1][j + 1];
}
result[i][j] %= mod;
}
}
return (int) result[steps][0];
}
