给你一个数字数组 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; } }
有一块木板，长度为 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^40 <= left.length <= n + 10 <= left[i] <= n0 <= right.length <= n + 10 <= right[i] <= n1 <= left.length + right.length <= n + 1left和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); } }
给你一个只包含 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 <= 1501 <= columns <= 1500 <= 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; } }
给你一个字符串 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 <= 30000num只包含 数字 且不含有 前导 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); } }
最不堪回收的一次周赛，唉，枉我午饭都没吃
