【刷题记录Day2】977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵

977. 有序数组的平方

AC

题目链接

思路

由于事先知道了是双指针的解法，照着双指针的思路还是不难想出来。数组平方的最大元素位于数组的左右两端，因此分别用两个指针指向，分别向中间靠拢，将较大者放入新的数组，直到两个指针相遇为止。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        int count = nums.length - 1;
        while(left<=right){
            if(nums[left]*nums[left]>=nums[right]*nums[right]){
                result[count] = nums[left]*nums[left];
                left++;
            }
            else{
                result[count] = nums[right]*nums[right];
                right--;
            }
            count--;
        }
        return result;
    }
}

209.长度最小的子数组

超出时间限制

题目链接
自己写的，两层循环，本以为可以过，但有case超出时间限制。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        for(int i=0, sum=0; i<nums.length; i++){
            if(nums[i]>=target){
                return 1;
            }
            sum = add(nums, 0, nums.length - 1);
            if(i==nums.length && sum<target){
                return 0;
            }
        }
        int left = 0;
        int right = 0;
        int size = 2;
        int sum = 0;
        for(size=2; size<=nums.length; size++){
            left = 0;
            for(int i=0; i<=nums.length-size; i++){
                right = left + size - 1;
                sum = add(nums, left, right);
                if(sum>=target){
                    return size;
                }
                left++;
                right++;
            }
        }
        return 0;
    }
    public int add(int[] nums, int l, int r){
        int sum = 0;
        for(int i=l; i<=r; i++){
            sum += nums[i];
        }
        return sum;
    }
}

正确题解—滑动窗口/双指针

看了文字讲解后写的

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int right = 0;
        int sum = 0;
        int size = nums.length;
        for(right=0; right<nums.length; right++)
        {
            sum += nums[right];
            while(sum>=target){
                if(right - left + 1 < size){
                    size = right - left + 1;
                }
                sum = sum - nums[left];
                left++;
            }
        }
        if(left == 0){
            size = 0;
        }
        return size;
    }
}

思考

问题的关键是找到起止位置移动的时机，结束位置和起始位置之间形成窗口，窗口内是试图满足条件的数组。当窗口内数组的和大于目标值是，可以缩短数组的长度，即将起始值变大，直至缩短到不满足条件，继续将结束位置往前滑动，这个过程中不断更新最小长度。
最小长度一开始被初始化为整个数组的长度，如果没有找到满足条件的子数组，则起始位置不会发生变化，否组至少都会为1，以此为条件判断是否有满足条件的子数组，如没有则将最小长度置为0。

59.螺旋矩阵II

调了很久，主要花在了边界的调整上

题目链接

思路

元素按顺时针顺序螺旋排列，之前学javase时看到过回文数的问题，于是按照那个思路自己把圈转了转，本以为很简单，结果写了几遍都错了，花了不少时间。
用一个指针指示当前转圈转到的位置，x表示矩阵的横坐标，正方向向右；y表示矩阵的纵坐标，正方向向下。这样，坐标(x, y)对应的二维数组中的位置就是[y][x]。用minX、maxX，minY、maxY分别表示横纵坐标的取值范围，区间为闭区间。
按照顺时针转圈的顺序，矩阵填充的顺序是右、下、左、上。当向右填充完后，纵坐标区间的左值需要增1，并且当前指针的x需要回退一格(这个很重要！！)，其他三个方向同理。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];
        int maxX = n - 1;
        int minX = 0;
        int minY = 0;
        int maxY = n - 1;
        int count = 1;
        int x = 0;
        int y = 0;
        while(count<=n*n){
            for(x=minX; x<=maxX; x++){
                result[y][x] = count;
                count++;
            }
            minY++;
            x--;
            for(y=minY; y<=maxY; y++){
                result[y][x] = count;
                count++;
            }
            maxX--;
            y--;
            for(x=maxX; x>=minX; x--){
                result[y][x] = count;
                count++;
            }
            maxY--;
            x++;
            for(y=maxY; y>=minY; y--){
                result[y][x] = count;
                count++;
            }
            minX++;
            y++;
        }
        return result;
    }
}

54. 螺旋矩阵

调了巨久

题目链接

思路

由于上一题做的不是很爽，于是想再做一道类似的题过过瘾，按照上面的思路写了一遍，本以为可以顺利AC，结果呵呵，发生了始料未及的错误，并且一脸懵逼明明上一题好好的，为什么这里就会出错。
如下图的矩阵，正确结果是：[1,2,3,4,8,12,11,10,9,5,6,7]
我的输出是[1,2,3,4,8,12,11,10,9,5,6,7,6]，怎么会多出一个元素来？明明count减到0了，怎么还在添加元素。于是开始debug…，又是调了巨久…。

错误分析

在如下的调试图中可以看到，此时整个矩阵已经被遍历完，count的值的确为0，但此时的minY竟然等于maxY，导致仍然进入了一个for循环，将元素’6’添加进了结果。那为什么会出现这样的情况呢？
如下图中的例子，当顺时针转完一圈时，minY指向6，maxY指向7，minX和maxX均指向6所在的这一行，此时继续前进，开始了新一轮的转圈，首先将这一行遍历完后，minX值会增1；然而此时程序并没有结束，还要将这个圈进行下去，当往下遍历时，由于不满足minX≤maxX的条件，不进入for循环，maxY值减1，指向了元素’6’这个位置，注意此时来到了向左遍历，这时minY≤maxY的条件是满足的，于是将该位置的元素又添加进了列表。之后minY++，之后将不再满足任何一个循环的条件，不会出现新一轮的转圈，此时count也不满足进去while循环的条件，程序到这里才算结束。
问题就在于矩阵的行数和列数不相等，像上一题的情况，由于转圈转到最后一圈只会剩下一个元素，向右遍历完该行后，maxY的值就会小于minY的值，该圈后续不会将进入任何一个for循环，圈结束后，while循环也结束，进而程序也结束了。
于是在每一次count–后随即判断是否已经为0了，若为0，直接退出while循环将程序结束。

修正后的代码

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int minX = 0, minY = 0;
        int maxX = matrix.length - 1;
        int maxY = matrix[0].length - 1;
        int count = matrix.length * matrix[0].length;
        int x = 0, y = 0;
        ArrayList<Integer> list = new ArrayList(count);
        out:while(count>0){
            for(y=minY; y<=maxY; y++){
                list.add(matrix[x][y]);
                count--;
                if(count==0){
                    break out;
                }
            }
            minX++;
            y--;
            for(x=minX; x<=maxX; x++){
                list.add(matrix[x][y]);
                count--;
                if(count==0){
                    break out;
                }
            }
            maxY--;
            x--;
            for(y=maxY; y>=minY; y--){
                list.add(matrix[x][y]);
                count--;
                if(count==0){
                    break out;
                }
            }
            y++;
            maxX--;
            for(x=maxX; x>=minX; x--){
                list.add(matrix[x][y]);
                count--;
                if(count==0){
                    break out;
                }
            }
            x++;
            minY++;
        }
        return list;
    }
}