第 196 場力扣周賽題解

5452. 判斷能否形成等差數列

思路：排序後直接看相鄰元素的差是否唯一即可。

class Solution {
    public boolean canMakeArithmeticProgression(int[] arr) {

        Arrays.sort(arr);
        for (int i = 2; i < arr.length; i++)
            if (arr[i] - arr[i - 1] != arr[i - 1] - arr[i - 2])
                return false;
        return true;
    }
}

5453. 所有螞蟻掉下來前的最後一刻

思路：這題千萬不要往難了想，雖然你要回頭，但是你仔細想想，假如一個螞蟻往左走的過程中，遇到一個往右走的螞蟻，此時兩隻螞蟻都要朝着其各自原來相反的方向繼續走，則對於每一隻螞蟻來說，他原本方向剩下要走的路會讓呢個撞他的螞蟻繼續走，呢不就是找最大值了嘛。

class Solution {
    public int getLastMoment(int n, int[] left, int[] right) {

        int ans = 0;
        for (int i = 0; i < left.length; i++)
            ans = Math.max(ans, left[i]);
        for (int i = 0; i < right.length; i++)
            ans = Math.max(ans, n-right[i]);

        return ans;
    }
}

5454. 統計全 1 子矩形

思路：這道題是之前做過一道題的簡化版，因爲n只有150這麼大，因此我們完全可以考慮O(n^3)的複雜度過這道題，我們知道原始暴力是O(n^4)的，爲了降低複雜度，我們可以考慮前綴和預處理，例如我採用的是預處理出每一行的前綴和，不過這個前綴和有些特殊，若當前位是0，則sum[i][j]=0，而不是sum[i][j]=sum[i][j-1]，這一點是需要注意的，之後我們可以暴力一個點，然後枚舉行並順帶存儲行的前綴最小值，我們就能計算出以該點爲右上角的矩形數量。

class Solution {
    public int numSubmat(int[][] mat) {

        int ans = 0;
        int m = mat.length;
        int n = mat[0].length;
        int[][] sum = new int[m][n];

        for (int i = 0; i < m; i++) {
            sum[i][0] = mat[i][0];
            for (int j = 1; j < n; j++) {
                if (mat[i][j] == 0)
                    sum[i][j] = 0;
                else
                    sum[i][j] = sum[i][j - 1] + 1;
            }
        }

        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 0)
                    continue;
                int mn = Integer.MAX_VALUE;
                for (int k = i; k < m; k++) {
                    mn = Math.min(mn, sum[k][j]);
                    ans += mn;
                    if(mn==0) break;
                }
            }

        return ans;
    }
}

5455. 最多 K 次交換相鄰數位後得到的最小整數

吐槽：這道題我必須要吐槽一下了，明明是一道質量很好的題，偏偏數據賊弱，比賽時讓很多連第三題都沒過的人都暴力過了這道題，這樣對過了第三題卻沒過第四題的人來說公平嘛？好像上週雙週賽也是，我寫了半天的位運算優化狀壓dp，結果賽後發現一坨人暴力過的？what？

思路：貪心思想其實賊簡單，我們每次要找的一定是當前能移動到最前面的最小數，這裏的最前面是指從已排好的位置的下一個位置，但是我們往往限於暴力置換使得複雜度達到O(n^2)，我們其實唯一要解決的問題就是當前要往前移動的數應該移動多少次。我們考慮預處理出每種數的個數以及分別在那些位置上存在，之後我們考慮從小到大開始移動，當前元素可以移動的條件是當且僅當某一個位置上該元素能夠在k步之內移動到最前面，而它的移動次數我們需要靠一些數據結構進行優化，我們的目的是快速的找到當前位置到最前邊中，有哪些位置是已經排好的，我們可以藉助樹狀數組，當然線段樹也是ok的。

class Solution {

    private int n;
    private int[] sum;

    public String minInteger(String num, int k) {

        n = num.length();
        sum = new int[n + 1];
        int[] index = new int[10];
        List<List<Integer>> list = new ArrayList<>();

        for (int i = 0; i < 10; i++)
            list.add(new ArrayList<>());
        for (int i = 0; i < n; i++)
            list.get(num.charAt(i) - '0').add(i + 1);

        String ans = "";

        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < 10; j++) {
                if (index[j] >= list.get(j).size()) continue;
                int op = list.get(j).get(index[j]);
                int p = op + get(op) - 1;
                if (p <= k) {
                    k -= p;
                    ans += (char) (j + '0');
                    add(op, -1);
                    index[j]++;
                    break;
                }
            }
        }

        return ans;

    }

    private int lowbit(int x) {
        return x & -x;
    }

    private void add(int x, int v) {
        while (x <= n) {
            sum[x] += v;
            x += lowbit(x);
        }
    }

    private int get(int x) {
        int res = 0;
        while (x > 0) {
            res += sum[x];
            x -= lowbit(x);
        }
        return res;
    }
}