LeetCode Weekly Contest 192

5428. 重新排列數組

題目難度Easy
給你一個數組 nums ，數組中有 2n 個元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。

請你將數組按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排後的數組。

示例 1：

輸入：nums = [2,5,1,3,4,7], n = 3
輸出：[2,3,5,4,1,7]
解釋：由於 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案爲 [2,3,5,4,1,7]
示例 2：

輸入：nums = [1,2,3,4,4,3,2,1], n = 4
輸出：[1,4,2,3,3,2,4,1]
示例 3：

輸入：nums = [1,1,2,2], n = 2
輸出：[1,2,1,2]

提示：

1 <= n <= 500
nums.length == 2n
1 <= nums[i] <= 10^3

代碼

class Solution {
    public int[] shuffle(int[] nums, int n) {
        int[] ans = new int[2*n];
        for (int i=0; i<n; ++i) {
            ans[2*i] = nums[i];
            ans[2*i+1] = nums[n + i];
        }
        return ans;
    }
}

5429. 數組中的 k 個最強值

題目難度Medium
給你一個整數數組 arr 和一個整數 k 。

設 m 爲數組的中位數，只要滿足下述兩個前提之一，就可以判定 arr[i] 的值比 arr[j] 的值更強：

|arr[i] - m| > |arr[j] - m|
|arr[i] - m| == |arr[j] - m|，且 arr[i] > arr[j]
請返回由數組中最強的 k 個值組成的列表。答案可以以 任意順序 返回。

中位數 是一個有序整數列表中處於中間位置的值。形式上，如果列表的長度爲 n ，那麼中位數就是該有序列表（下標從 0 開始）中位於 ((n - 1) / 2) 的元素。

例如 arr = [6, -3, 7, 2, 11]，n = 5：數組排序後得到 arr = [-3, 2, 6, 7, 11] ，數組的中間位置爲 m = ((5 - 1) / 2) = 2 ，中位數 arr[m] 的值爲 6 。
例如 arr = [-7, 22, 17, 3]，n = 4：數組排序後得到 arr = [-7, 3, 17, 22] ，數組的中間位置爲 m = ((4 - 1) / 2) = 1 ，中位數 arr[m] 的值爲 3 。

示例 1：

輸入：arr = [1,2,3,4,5], k = 2
輸出：[5,1]
解釋：中位數爲 3，按從強到弱順序排序後，數組變爲 [5,1,4,2,3]。最強的兩個元素是 [5, 1]。[1, 5] 也是正確答案。
注意，儘管 |5 - 3| == |1 - 3| ，但是 5 比 1 更強，因爲 5 > 1 。
示例 2：

輸入：arr = [1,1,3,5,5], k = 2
輸出：[5,5]
解釋：中位數爲 3, 按從強到弱順序排序後，數組變爲 [5,5,1,1,3]。最強的兩個元素是 [5, 5]。
示例 3：

輸入：arr = [6,7,11,7,6,8], k = 5
輸出：[11,8,6,6,7]
解釋：中位數爲 7, 按從強到弱順序排序後，數組變爲 [11,8,6,6,7,7]。
[11,8,6,6,7] 的任何排列都是正確答案。
示例 4：

輸入：arr = [6,-3,7,2,11], k = 3
輸出：[-3,11,2]
示例 5：

輸入：arr = [-7,22,17,3], k = 2
輸出：[22,17]

提示：

1 <= arr.length <= 10^5
-10^5 <= arr[i] <= 10^5
1 <= k <= arr.length

代碼

class Solution {
    public int[] getStrongest(int[] arr, int k) {
        int[] ans = new int[k];
        Arrays.sort(arr);
        int i = 0, n = arr.length, j = n-1, idx = 0, mid = arr[(n-1)/2];
        if (k == n) {
            return arr;
        }
        for (idx=0; idx<k; ++idx) {
            int left =  mid - arr[i], right = arr[j] - mid;
            if (right > left) {
                ans[idx] = arr[j--];
            } else if (right < left) {
                ans[idx] = arr[i++];
            } else {
                ans[idx] = arr[j--];
            }
        }
        return ans;
    }
}

5430. 設計瀏覽器歷史記錄

題目難度Medium
你有一個只支持單個標籤頁的 瀏覽器 ，最開始你瀏覽的網頁是 homepage，你可以訪問其他的網站 url ，也可以在瀏覽歷史中後退 steps 步或前進 steps 步。

請你實現 BrowserHistory 類：

BrowserHistory(string homepage) ，用 homepage 初始化瀏覽器類。
void visit(string url) 從當前頁跳轉訪問 url 對應的頁面 。執行此操作會把瀏覽歷史前進的記錄全部刪除。
string back(int steps) 在瀏覽歷史中後退 steps 步。如果你只能在瀏覽歷史中後退至多 x 步且 steps > x ，那麼你只後退 x 步。請返回後退 至多 steps 步以後的 url 。
string forward(int steps) 在瀏覽歷史中前進 steps 步。如果你只能在瀏覽歷史中前進至多 x 步且 steps > x ，那麼你只前進 x 步。請返回前進 至多 steps步以後的 url 。

示例：

輸入：
[“BrowserHistory”,“visit”,“visit”,“visit”,“back”,“back”,“forward”,“visit”,“forward”,“back”,“back”]
[[“leetcode.com”],[“google.com”],[“facebook.com”],[“youtube.com”],[1],[1],[1],[“linkedin.com”],[2],[2],[7]]
輸出：
[null,null,null,null,“facebook.com”,“google.com”,“facebook.com”,null,“linkedin.com”,“google.com”,“leetcode.com”]

解釋：

BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
browserHistory.visit("google.com");       // 你原本在瀏覽 "leetcode.com" 。訪問 "google.com"
browserHistory.visit("facebook.com");     // 你原本在瀏覽 "google.com" 。訪問 "facebook.com"
browserHistory.visit("youtube.com");      // 你原本在瀏覽 "facebook.com" 。訪問 "youtube.com"
browserHistory.back(1);                   // 你原本在瀏覽 "youtube.com" ，後退到 "facebook.com" 並返回 "facebook.com"
browserHistory.back(1);                   // 你原本在瀏覽 "facebook.com" ，後退到 "google.com" 並返回 "google.com"
browserHistory.forward(1);                // 你原本在瀏覽 "google.com" ，前進到 "facebook.com" 並返回 "facebook.com"
browserHistory.visit("linkedin.com");     // 你原本在瀏覽 "facebook.com" 。 訪問 "linkedin.com"
browserHistory.forward(2);                // 你原本在瀏覽 "linkedin.com" ，你無法前進任何步數。
browserHistory.back(2);                   // 你原本在瀏覽 "linkedin.com" ，後退兩步依次先到 "facebook.com" ，然後到 "google.com" ，並返回 "google.com"
browserHistory.back(7);                   // 你原本在瀏覽 "google.com"， 你只能後退一步到 "leetcode.com" ，並返回 "leetcode.com"

提示：

1 <= homepage.length <= 20
1 <= url.length <= 20
1 <= steps <= 100
homepage 和 url 都只包含 ‘.’ 或者小寫英文字母。
最多調用 5000 次 visit， back 和 forward 函數。

思路

用ArrayList存儲歷史記錄，用tail記錄有效的歷史記錄尾，用tail的移動代替數組刪除。visit, back, forward的時間複雜度均爲O(1).

代碼

class BrowserHistory {
    private ArrayList<String> history;
    private int cur, tail;

    public BrowserHistory(String homepage) {
        history = new ArrayList<>();
        history.add(homepage);
        cur = 0;
        tail = 1;
    }
    
    public void visit(String url) {
        ++cur;
        if (history.size() > cur) {
            history.set(cur, url);
        } else {
            history.add(url);
        }
        tail = cur + 1;
    }
    
    public String back(int steps) {
        cur = steps <= cur? cur - steps: 0;
        return history.get(cur);
    }
    
    public String forward(int steps) {
        cur = cur + steps < tail? cur + steps: tail - 1;
        return history.get(cur);
    }
}

/**
 * Your BrowserHistory object will be instantiated and called as such:
 * BrowserHistory obj = new BrowserHistory(homepage);
 * obj.visit(url);
 * String param_2 = obj.back(steps);
 * String param_3 = obj.forward(steps);
 */

5431. 給房子塗色 III

題目難度Hard
在一個小城市裏，有 m 個房子排成一排，你需要給每個房子塗上 n 種顏色之一（顏色編號爲 1 到 n ）。有的房子去年夏天已經塗過顏色了，所以這些房子不需要被重新塗色。

我們將連續相同顏色儘可能多的房子稱爲一個街區。（比方說 houses = [1,2,2,3,3,2,1,1] ，它包含 5 個街區 [{1}, {2,2}, {3,3}, {2}, {1,1}] 。）

給你一個數組 houses ，一個 m * n 的矩陣 cost 和一個整數 target ，其中：

houses[i]：是第 i 個房子的顏色，0 表示這個房子還沒有被塗色。
cost[i][j]：是將第 i 個房子塗成顏色 j+1 的花費。
請你返回房子塗色方案的最小總花費，使得每個房子都被塗色後，恰好組成 target 個街區。如果沒有可用的塗色方案，請返回 -1 。

示例 1：

輸入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
輸出：9
解釋：房子塗色方案爲 [1,2,2,1,1]
此方案包含 target = 3 個街區，分別是 [{1}, {2,2}, {1,1}]。
塗色的總花費爲 (1 + 1 + 1 + 1 + 5) = 9。
示例 2：

輸入：houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
輸出：11
解釋：有的房子已經被塗色了，在此基礎上塗色方案爲 [2,2,1,2,2]
此方案包含 target = 3 個街區，分別是 [{2,2}, {1}, {2,2}]。
給第一個和最後一個房子塗色的花費爲 (10 + 1) = 11。
示例 3：

輸入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
輸出：5
示例 4：

輸入：houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
輸出：-1
解釋：房子已經被塗色並組成了 4 個街區，分別是 [{3},{1},{2},{3}] ，無法形成 target = 3 個街區。

思路

動態規劃。dp[i][j][t]表示前i個房子形成t個街區且第i個房子塗色爲j的情況下的最小花費。

代碼

class Solution {
    private static final int inf = 0x3f3f3f3f;
    
    public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
        int[][][] dp = new int[m][n][target];
        for (int[][] mat: dp) {
            for (int[] line: mat) {
                Arrays.fill(line, inf);
            }
        }
        int i = 0, j = 0, k = 0, t = 0;
        if (houses[0] == 0) {
            for (j=0; j<n; ++j) {
                dp[0][j][0] = cost[0][j];
            }
        } else {
            dp[0][houses[0]-1][0] = 0;
        }
        for (i=1; i<m; ++i) {
            if (houses[i] == 0) {
                for (j=0; j<n; ++j) {
                    for (k=0; k<n; ++k) {
                        for (t=0; t<target; ++t) {
                            if (dp[i-1][k][t] < inf) {
                                if (k == j) {
                                    dp[i][j][t] = Math.min(dp[i-1][k][t] + cost[i][j], dp[i][j][t]);   
                                } else if (t < target - 1) {
                                    dp[i][j][t+1] = Math.min(dp[i-1][k][t] + cost[i][j], dp[i][j][t+1]);
                                } 
                            }
                        }
                    }
                }
            } else {
                for (k=0; k<n; ++k) {
                    for (t=0; t<target; ++t) {
                        if (dp[i-1][k][t] < inf) {
                            if (k == houses[i] - 1) {
                                dp[i][houses[i] - 1][t] = Math.min(dp[i-1][k][t], dp[i][houses[i] - 1][t]);
                            } else if (t < target - 1) {
                                dp[i][houses[i] - 1][t+1] = Math.min(dp[i-1][k][t], dp[i][houses[i] - 1][t+1]);
                            }
                        }
                    }
                }
            }
        }
        int ans = inf;
        for (j=0; j<n; ++j) {
            ans = Math.min(ans, dp[m-1][j][target-1]);
        }
        return ans == inf? -1: ans;
    }
}