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);
}