977

暴力法

直接数组中每个元素平方后用sort进行排序

双指针法

数组是有序的，平方后最大的元素存在于nums的两端，所以就定义两个指向两端的指针，
然后比较两端绝对值的大小，大的加入新定义的ans数组，并且指针向内移动

        vector<int> ans (nums.size(),0);
        //指向nums开头的指针
        int i=0;
        //指向nums结尾的指针
        int j=nums.size()-1;
        //指向ans结尾的指针
        int k=nums.size()-1;
        while(i<=j)
        {
            if(abs(nums[i])>abs(nums[j]))
            {
                ans[k]=nums[i]*nums[i];
                i++;
            }
            else{
                ans[k]=nums[j]*nums[j];
                j--;
            }
            k--;
        }
        return ans;

209

双指针法/类似滑动窗口

同理定义一个双指针，快指针每次前进时都将元素加到sum上，当sum>=target时，计算快慢指针的距离，并比较其和当前答案大小，如果比当前答案小那么就替换成为新的答案，并且，将慢指针指向的值从sum中减去，慢指针向前移动

        //慢指针，指向前面的元素
        int slowptr=0;
        //每次循环中子数组的长度
        int sublength;
        //sum，和target进行比较
        int sum=0;
        //返回值
        int ans=10000000;
        int n=nums.size();
        //快指针，指向远端
        for(int fastptr=0;fastptr<n;fastptr++)
        {
            //每次循环都加到sum上
            sum+=nums[fastptr];
            //这时sum>=target，满足条件进入循环
            while(sum>=target)
            {
                //计算长度
                sublength=fastptr-slowptr+1;
                //比原来的小
                ans=ans>sublength?sublength:ans;
                //减去
                sum-=nums[slowptr];
                //指针向前
                slowptr++;
            }
        }
        return ans==10000000?0:ans;

59

坚持不变量原则，坚持左闭右开区间进行答案的填充

vector<vector<int>> res(n, vector<int>(n, 0));
        // 起始位置，每一次循环都+1
        int startx = 0;
        int starty = 0;
        // 循环次数
        int loop = n / 2;
        // 最中心的位置
        int mid = n / 2;
        // 每个元素的值
        int count = 1;
        // 偏移量，控制与外围的距离，每一次循环都+1
        int offset = 1;
        int i, j;
        while (loop--)
        {
            i = startx;
            j = starty;
            for (j = starty; j < n - offset; j++)
            {
                res[startx][j] = count++;
            }
            for (i = startx; i < n - offset; i++)
            {
                res[i][j] = count++;
            }
            for (; j > starty; j--)
            {
                res[i][j] = count++;
            }
            for (; i > startx; i--)
            {
                res[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
        }
        if (n % 2)
        {
            res[mid][mid] = count;
        }
        return res;