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