LeetCode 第 196 场周赛（题目：5452-5455，这是参加过最坑的周赛，暴力n^2居然可以过）

5452. 判断能否形成等差数列

给你一个数字数组 arr 。

如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为等差数列。

如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [3,5,1]
输出：true
解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。

示例 2：

输入：arr = [1,2,4]
输出：false
解释：无法通过重新排序得到等差数列。

提示：

2 <= arr.length <= 1000
-10^6 <= arr[i] <= 10^6

class Solution {
      public boolean canMakeArithmeticProgression(int[] arr) {
        Arrays.sort(arr);
        int temp = arr[1]-arr[0];
        for (int i=1;i<arr.length;i++){
            if(temp!=arr[i]-arr[i-1]){
                return false;
            }
        }
        return true;
    }
}

5453. 所有蚂蚁掉下来前的最后一刻

有一块木板，长度为 n 个单位。一些蚂蚁在木板上移动，每只蚂蚁都以每秒一个单位的速度移动。其中，一部分蚂蚁向左移动，其他蚂蚁向右移动。

当两只向不同方向移动的蚂蚁在某个点相遇时，它们会同时改变移动方向并继续移动。假设更改方向不会花费任何额外时间。

而当蚂蚁在某一时刻 t 到达木板的一端时，它立即从木板上掉下来。

给你一个整数 n 和两个整数数组 left 以及 right 。两个数组分别标识向左或者向右移动的蚂蚁在 t = 0 时的位置。请你返回最后一只蚂蚁从木板上掉下来的时刻。

示例 1：

输入：n = 4, left = [4,3], right = [0,1]
输出：4
解释：如上图所示：
-下标 0 处的蚂蚁命名为 A 并向右移动。
-下标 1 处的蚂蚁命名为 B 并向右移动。
-下标 3 处的蚂蚁命名为 C 并向左移动。
-下标 4 处的蚂蚁命名为 D 并向左移动。
请注意，蚂蚁在木板上的最后时刻是 t = 4 秒，之后蚂蚁立即从木板上掉下来。（也就是说在 t = 4.0000000001 时，木板上没有蚂蚁）。

示例 2：

输入：n = 7, left = [], right = [0,1,2,3,4,5,6,7]
输出：7
解释：所有蚂蚁都向右移动，下标为 0 的蚂蚁需要 7 秒才能从木板上掉落。

示例 3：

输入：n = 7, left = [0,1,2,3,4,5,6,7], right = []
输出：7
解释：所有蚂蚁都向左移动，下标为 7 的蚂蚁需要 7 秒才能从木板上掉落。

示例 4：

输入：n = 9, left = [5], right = [4]
输出：5
解释：t = 1 秒时，两只蚂蚁将回到初始位置，但移动方向与之前相反。

示例 5：

输入：n = 6, left = [6], right = [0]
输出：6

提示：

1 <= n <= 10^4
0 <= left.length <= n + 1
0 <= left[i] <= n
0 <= right.length <= n + 1
0 <= right[i] <= n
1 <= left.length + right.length <= n + 1
left 和 right 中的所有值都是唯一的，并且每个值只能出现在二者之一中。

PS:

这个题的话，其实想明白了就很简单，两只蚂蚁相撞，就各取反方向，

蚂蚁那么小，我们可以看成，两只蚂蚁互相穿过去了

class Solution {
      public int getLastMoment(int n, int[] left, int[] right) {
            int l=-100000,r=-100000;
          int ll=0,rr=100000;
          //面向左面的想要下去，只能是向左走，他们最大的那个就是距离0最远的点，相差的距离就是最长的时间
        for(int i:left){
            ll=Math.max(ll,i);
        }
        //反之 面向右面就要向右走，距离n最远的点的距离就是最长时间，这里面向右面的要取最小值
        for(int i:right){
            rr=Math.min(rr,i);
        }
        //防止有空数组出现
        if(left.length!=0)
            l = ll;
        if(right.length!=0)
            r = n-rr;
        return Math.max(l,r);
    }
}

5454. 统计全 1 子矩形

给你一个只包含 0 和 1 的 rows * columns 矩阵 mat ，请你返回有多少个子矩形的元素全部都是 1 。

示例 1：

输入：mat = [[1,0,1],
            [1,1,0],
            [1,1,0]]
输出：13
解释：
有 6 个 1x1 的矩形。
有 2 个 1x2 的矩形。
有 3 个 2x1 的矩形。
有 1 个 2x2 的矩形。
有 1 个 3x1 的矩形。
矩形数目总共 = 6 + 2 + 3 + 1 + 1 = 13 。

示例 2：

输入：mat = [[0,1,1,0],
            [0,1,1,1],
            [1,1,1,0]]
输出：24
解释：
有 8 个 1x1 的子矩形。
有 5 个 1x2 的子矩形。
有 2 个 1x3 的子矩形。
有 4 个 2x1 的子矩形。
有 2 个 2x2 的子矩形。
有 2 个 3x1 的子矩形。
有 1 个 3x2 的子矩形。
矩形数目总共 = 8 + 5 + 2 + 4 + 2 + 2 + 1 = 24 。

示例 3：

输入：mat = [[1,1,1,1,1,1]]
输出：21

示例 4：

输入：mat = [[1,0,1],[0,1,0],[1,0,1]]
输出：5

提示：

1 <= rows <= 150
1 <= columns <= 150
0 <= mat[i][j] <= 1

PS：

这里有一份大哥的暴力大法，我还有一份代码，先不写注释了，等下面有时间再加上注释吧

/*暴力法通过
@v7fgg
执行用时：285 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：40.9 MB, 在所有 Java 提交中击败了100.00%的用户
2020年7月5日 13:13
*/
class Solution {
    public int numSubmat(int[][] mat) {
        int ans=0;
        int m=mat.length;
        int n=mat[0].length;
        //ij确定左上角，kl确定右下角
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                for(int k=i;k<m;k++){
                    for(int l=j;l<n;l++){
                        //逐个检查
                        boolean bukeyi=false;//表示此矩形是不是全1
                        for(int a=i;a<=k;a++){
                            for(int b=j;b<=l;b++){
                                if(mat[a][b]==0){
                                    bukeyi=true;
                                    break;
                                }
                            }
                            if(bukeyi){break;}                   
                        }
                        if(bukeyi){break;}
                        ans++;                    
                    }
                }
            }
        }
        return ans;
    }
}

class Solution {
    public int numSubmat(int[][] mat) {
    int[][] a = new int[mat.length+1][mat[0].length+1];
        for(int i=1;i<=mat.length;i++){               
            for(int j=1;j<=mat[i-1].length;j++){
                if( mat[i-1][j-1]==1 ) a[i][j] = a[i-1][j] + 1;
                else          a[i][j] = 0;
            }
        }
//        for(int i=1;i<=mat.length;i++){               
//            for(int j=1;j<=mat[i-1].length;j++){
//                System.out.print(a[i][j]+" ");
//            }
//            System.out.println();
//        }
        int[] Stk = new int[mat.length+5];
        int top = 0;
        int ans = 0,count=0;
        for(int i=1;i<=mat.length;i++){
            top =0; count = 0;
            for(int j=1;j<=mat[0].length;j++){
                count += a[i][j];
                while( top>0 && a[i][j] <= a[i][Stk[top]] ) {
                    count -= ( Stk[top] - Stk[top-1] ) * ( a[i][Stk[top]] - a[i][j] );
                    top--;
                }
                ans += count;
                Stk[++top] = j;
            }
        }
        return ans;
    }
}

5455. 最多 K 次交换相邻数位后得到的最小整数

给你一个字符串 num 和一个整数 k 。其中，num 表示一个很大的整数，字符串中的每个字符依次对应整数上的各个数位。

你可以交换这个整数相邻数位的数字最多 k 次。

请你返回你能得到的最小整数，并以字符串形式返回。

示例 1：

输入：num = "4321", k = 4
输出："1342"
解释：4321 通过 4 次交换相邻数位得到最小整数的步骤如上图所示。

示例 2：

输入：num = "100", k = 1
输出："010"
解释：输出可以包含前导 0 ，但输入保证不会有前导 0 。

示例 3：

输入：num = "36789", k = 1000
输出："36789"
解释：不需要做任何交换。

示例 4：

输入：num = "22", k = 22
输出："22"

示例 5：

输入：num = "9438957234785635408", k = 23
输出："0345989723478563548"

提示：

1 <= num.length <= 30000
num 只包含数字且不含有前导 0 。
1 <= k <= 10^9

PS：

　　这道题有暴力有递归，测试用例不到位，真正得方法不需要用就可以过了

class Solution {
public String minInteger(String num, int k) {
        if (k == 0)return num;
        for (char c = '0' ; c <= '9' ; c++){
            int i = num.indexOf(c);
            if (i >= 0){
                if ( i <= k){
                    return c + minInteger(num.substring(0,i)+ num.substring(i+1),k - i);
                }
            }
        }
        return num;
    }
}

class Solution {
    void sw(char cs[],int i,int j){
        char t = cs[i];
        cs[i] =cs[j];
        cs[j] = t;
        
    }
    
    
    public String minInteger(String num, int k) {
        char cs[] = num.toCharArray();
        int l = cs.length;
        for(int i=0;i<l&&k>0;++i){
            int cur = i;
            for(int j=i+1;j<l&&j-i<=k;++j){
                if(cs[j]<cs[cur]){
                    cur = j;
                }
            }
            for(int j=cur;j>i&&k>0;--j){
                k--;
                sw(cs, j, j-1);
            }
            
            
        }
        
        return new String(cs);
        
        
        
    }
}