LeetCode第 164 场周赛

LeetCode第 164 场周赛

——————————————————————————————————————————————
百人在线AC场，第一次周赛过4题，最近比较忙，好久没打周赛了，纪念一哈
分割线，下面是正文
——————————————————————————————————————————————

标题1266. 访问所有点的最小时间

链接：https://leetcode-cn.com/problems/minimum-time-visiting-all-points
平面上有 n 个点，点的位置用整数坐标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）。
你可以按照下面的规则在平面上移动：
每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）。
必须按照数组中出现的顺序来访问这些点。

输入：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 秒
提示：
	points.length == n
	1 <= n <= 100
	points[i].length == 2
	-1000 <= points[i][0], points[i][1] <= 1000
思路：能走斜线走斜线，不能就横竖移动

public int minTimeToVisitAllPoints(int[][] points) {
     
    int res = 0;
    for (int i = 0;i < points.length - 1;i++) {
     
        int abs0 = Math.abs(points[i][0] - points[i + 1][0]);
        int abs1 = Math.abs(points[i][1] - points[i + 1][1]);      	
        if (abs0 == abs1)
            res += abs0;
        else
            res += Math.min(abs0, abs1) + Math.abs(abs0 - abs1);
    }
    return res;
}

---

1267. 统计参与通信的服务器

链接：https://leetcode-cn.com/problems/count-servers-that-communicate
这里有一幅服务器分布图，服务器的位置标识在 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.length
n == grid[i].length
1 <= m <= 250
1 <= n <= 250
grid[i][j] == 0 or 1

思路：数据范围很小，横竖判断一下就行

public int countServers(int[][] grid) {
     
    int res = 0,cnt = 0;
    int[] rowS = new int[grid.length];
    int[] colS = new int[grid[0].length];
    for (int i = 0;i < rowS.length;i++) {
     
        for (int j = 0;j < colS.length;j++) {
     
            rowS[i] += grid[i][j];
            colS[j] += grid[i][j];
            if (grid[i][j] == 1)
                cnt++;
        }
    }
    for (int i = 0;i < rowS.length;i++) {
     
        if (rowS[i] == 1) {
     
            for (int j = 0;j < colS.length;j++) {
     
                if (grid[i][j] == 1 && colS[j] == 1)
                    res++;
            }
        }
    }
    return cnt - res;
}

1268. 搜索推荐系统

链接：https://leetcode-cn.com/problems/search-suggestions-system
给你一个产品数组 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 <= 1000
	1 <= Σ products[i].length <= 2 * 10^4
	products[i] 中所有的字符都是小写英文字母。
	1 <= searchWord.length <= 1000
	searchWord 中所有字符都是小写英文字母。
思路：排序之后可以二分查找，我直接调库了

public List<List<String>> suggestedProducts(String[] products, String searchWord) {
     
    List<List<String>> res = new ArrayList<>();
    Arrays.sort(products);
    int len = searchWord.length();
    for (int i = 0;i < len;i++) {
     
        String cur = searchWord.substring(0, i + 1);
        ArrayList<String> list = new ArrayList<String>();
        for (int j = 0;j < products.length;j++) {
     
            if (products[j].startsWith(cur)) {
     
                list.add(products[j]);
                if (list.size() > 2)
                    break;
            }       			
        }
        if (list.size() == 0) {
     
            while (i++ < len) {
     
                ArrayList<String> curList = new ArrayList<String>();
                res.add(curList);
            }	
            break;
        }        		
        res.add(list);
    }
    return res;
}

1269. 停在原地的方案数

链接：https://leetcode-cn.com/problems/number-of-ways-to-stay-in-the-same-place-after-some-steps
有一个长度为 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 <= 500
	1 <= arrLen <= 10^6

思路：典型的动态规划。
	dp[i][j]表示花费j步走到第i个位置的所有方案数，
	dp[i][j]的来源有三种，左边位置往右一步、右边位置往左一步以及原地不动，对于两端只有两种来源
	状态转移方程为：
	dp[i][j] = (dp[i][j - 1] + dp[i + 1][j - 1]) % mod, i == 0;
	dp[i][j] = (dp[i - 1][j - 1] + dp[i][j - 1]) % mod, i == arrLen - 1，即到数组末尾;
	dp[i][j] = (dp[i - 1][j - 1] + dp[i][j - 1] + dp[i + 1][j - 1]) % mod, 其它位置;
最后可以进行状态压缩，仔细查看数据范围

public int numWays(int steps, int arrLen) {
     
    int mod = 1000000007;
    arrLen = Math.min(arrLen, steps);
    long[][] dp = new long[arrLen][2];
    int index = 0;
    dp[0][0] = dp[1][0] = 1;       
    for (int j = 1;j < steps;j++) {
     
        index = j % 2 == 0 ? 1 : 0;
        for (int i = 0;i < arrLen;i++) {
     
            if (i == 0)
                dp[i][j % 2] = (dp[i][index] + dp[i + 1][index]) % mod;
            else if (i == arrLen - 1)
                dp[i][j % 2] = (dp[i - 1][index] + dp[i][index]) % mod;
            else
                dp[i][j % 2] = (dp[i - 1][index] + dp[i][index] + dp[i + 1][index]) % mod;
        }
    }
    return (int) (dp[0][(steps - 1) % 2] % mod);
}