LeetCode: Tags-[Array], Difficulty-[Medium]

Tags: Array

Difficulty: Medium

11. Container With Most Water: https://leetcode.com/problems/container-with-most-water/

n条纵线，找出两条线使得容器最大:(题意:假设ai,aj  Cmax =min(ai,aj)*(j-i));

暴力解法: (内外for循环; 外循环遍历, 内循环遍历i后的数, 嵌套求最值 max = Math.max(max,min([i],[j]))*(j-i) ps:LeetCode最后大数据TLE,LintCode可以通过)

public class Solution {
    public int maxArea(int[] height) {
        int max = 0;
        for (int i = 0; i < height.length; i++) {
            for (int j = i; j < height.length; j++) {
                max = Math.max(max,Math.min(height[j],height[i])*(j - i));
            }
        }
        return max;
    }
}

 解法2：<Two Pointers> (首尾双指针遍历 left,right, 记录max, 保留[left]/[right]中大的一个,另一边指针移动;)

(0.int area; 1.left,right,max; 2.while(<=)max=max(,area); 3.if([left]<)left++);  (Q: 可以嵌套for循环的就可以双指针??Todo;)

public class Solution {
    /**
     * @param heights: an array of integers
     * @return: an integer
     */
    int computeArea(int left, int right,  int[] heights) {
        return (right-left)*Math.min(heights[left], heights[right]);
    }
    
    public int maxArea(int[] heights) {
        // write your code here
        int left = 0, ans=  0 ; 
        int right = heights.length - 1;
        while(left <= right) {
            ans = Math.max(ans,computeArea(left, right, heights));
            if(heights[left]<=heights[right])
                left++;
            else
                right--;
        }
        return ans;
    }
}

15. 3Sum: https://leetcode.com/problems/3sum/

找出数组中所有3数之和为零的数：

解法：(遍历,第一个数的相反数作为后两个数的和,二分遍历后两个数 1.排序 2.for(0,n-2)遍历 3.if(i=0 || [i]=[i-1]) 跳过重复元素  4.lo,high,sum  5.while(<)if等sum则add,while(<&&=)lo++,while(<&&=)hi--跳过重复元素; lo++ hi-- 搜索下一对2SUM;  6.if(<sum)那么lo++,else()hi--;  )

(1.sort,rst; 2.for(n-2)if(0||!=);  3.lo=i+1,hi,sum; 4.while() if(=)tmp,add,while(<&=)++while(>&=)--; 5.if(<)++(>)-- 6.return;)

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> rst = new ArrayList<List<Integer>>();
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || (i > 0 && nums[i] != nums[i - 1])){
                int lo = i + 1, hi = nums.length - 1, sum = 0 - nums[i];
                while (lo < hi) {
                    if (nums[lo] + nums[hi] == sum) {
                        List<Integer> tmp = new ArrayList<Integer>();
                        tmp.add(nums[i]);
                        tmp.add(nums[lo]);
                        tmp.add(nums[hi]);
                        rst.add(tmp);
                        while (lo < hi && nums[lo] == nums[lo + 1]) lo++;
                        while (lo < hi && nums[hi] == nums[hi - 1]) hi--;
                        lo++; hi--;
                    } else if (nums[lo] + nums[hi] < sum) lo++;
                    else hi--;
                }
            }
        }
        return rst;
    }
}

public List<List<Integer>> threeSum(int[] num) {
    Arrays.sort(num);
    List<List<Integer>> res = new LinkedList<>(); 
    for (int i = 0; i < num.length-2; i++) {
        if (i == 0 || (i > 0 && num[i] != num[i-1])) {
            int lo = i+1, hi = num.length-1, sum = 0 - num[i];
            while (lo < hi) {
                if (num[lo] + num[hi] == sum) {
                    res.add(Arrays.asList(num[i], num[lo], num[hi]));
                    while (lo < hi && num[lo] == num[lo+1]) lo++;
                    while (lo < hi && num[hi] == num[hi-1]) hi--;
                    lo++; hi--;
                } else if (num[lo] + num[hi] < sum) lo++;
                else hi--;
           }
        }
    }
    return res;
}

16.3Sum Closest: https://leetcode.com/problems/3sum-closest/

找出数组中三数之和最接近target，返回三数之和: 

解法：(遍历第一个数，后两个数二分遍历，比较rst和遍历出的sum的与tar的差值大小；根据sum和tar的差值决定lo和hi的变化)(和我自己思路类似，但是我卡在了lo和hi的变化上，不能用lo++hi——，这样会导致有的组合被跳过 [a,b,c,d]->[a]+[d]->[b]+[c] 漏掉了ab,ac,bd,cd 所以应该根据sum和tar的大小关系确定lo和hi的变化；)(用到方法：Math.abs()取绝对值)

(1.if()-1;  2.sort,rst;  3.for(n-2) if()lo,hi;  4.while()sum if(Math.abs<)rst=sum;  5.if()lo++;if()hi--  6.return;) (ps:while里的语句跳过重复，也可以不用)

public class Solution {
    public int threeSumClosest(int[] nums, int target) {
        if (nums == null || nums.length < 3) {
            return -1;
        }
        Arrays.sort(nums);
        int rst = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length - 2; i++) {
            if (i == 0 || (i > 0 && nums[i] != nums[i - 1])) {
                int lo = i + 1, hi = nums.length - 1;
                while (lo < hi){
                    int sum = nums[lo] + nums[hi] + nums[i];
                    if (Math.abs(rst - target) > Math.abs(sum - target))
                        rst = sum;
                    if (sum < target)
                        lo++;
                    else hi--;
                }
            }
        }
        return rst;
    }
}

18. 4Sum：https://leetcode.com/problems/4sum/

 我的解法：(与3SUM解法相同，两趟for循环遍历第一个值和第二个值，注意每趟遍历依然要去重！且每趟for循环的首位要保留；[00000] i=0,j=1去重时不能把j=1也去了)

(1.rst,sort;  2.for(n-3)if(||&&); for(i+!,n-2)if(||&&);  3.lo,hi while();  4.if(=)tmp,add,while(&);  5.else if(<) else(>)  6.return;)

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> rst = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 3; i++) {
            if (i == 0 || (i !=0 && nums[i] != nums[i - 1])){
                for (int j = i + 1; j < nums.length - 2; j++) {
                    if (j == i + 1 || (j != i + 1 && nums[j] != nums[j - 1])){
                        int lo = j + 1, hi = nums.length - 1;
                        while (lo < hi) {
                            if (nums[lo] + nums[hi] + nums[i] + nums[j] == target) {
                                List<Integer> tmp = new ArrayList<Integer>();
                                tmp.add(nums[i]); tmp.add(nums[j]);
                                tmp.add(nums[lo]); tmp.add(nums[hi]);
                                rst.add(tmp);
                                while (lo < hi && nums[lo] == nums[lo + 1]) lo++;
                                while (lo < hi && nums[hi] == nums[hi - 1]) hi--;
                                lo++; hi--;
                            } else if (nums[i] + nums[j] + nums[lo] + nums[hi] < target)
                                lo++;
                            else hi --;
                        }
                    }
                }
            }
        }
        return rst;
    }
}

if也可以有其他写法：(continue)

public class Solution {
    public List<List<Integer>> fourSum(int[] num, int target) {
        ArrayList<List<Integer>> ans = new ArrayList<>();
        if(num.length<4)return ans;
        Arrays.sort(num);
        for(int i=0; i<num.length-3; i++){
            if(i>0&&num[i]==num[i-1])continue;
            for(int j=i+1; j<num.length-2; j++){
                if(j>i+1&&num[j]==num[j-1])continue;
                int low=j+1, high=num.length-1;
                while(low<high){
                    int sum=num[i]+num[j]+num[low]+num[high];
                    if(sum==target){
                        ans.add(Arrays.asList(num[i], num[j], num[low], num[high]));
                        while(low<high&&num[low]==num[low+1])low++;
                        while(low<high&&num[high]==num[high-1])high--;
                        low++;
                        high--;
                    }
                    else if(sum<target)low++;
                    else high--;
                }
            }
        }
        return ans;
    }
}

31. Next Permutation: https://leetcode.com/problems/next-permutation/

 找出下一个排列：[1,2,3,1]->[1,3,1,2]; [1,3,5,4,3,2,1]->[1,4,1,2,3,3,5]

解法：(1.从后往前遍历,找到第一个不满足降序的i;  2.从后往前遍历 找出i后第一个比i大的数并swap;  3.将i后的数(已经是倒序)reverse反转;  这样能保证变化范围最小)

(我的代码，有问题。。暂时没找到原因……)

错！误！代！码！：原因swap(i,j)是按值传递,swap(nums[i],nums[j])后对数组没有变化；swap(int[] nums, int i, int j)是引用传递，将数组作为方法的参数，可以改变数组

public class Solution {
    public void nextPermutation(int[] nums) {
        if (nums == null || nums.length == 0) {
            return;
        }
        int i = nums.length - 1;
        for (; i >= 1; i--) {
            if (nums[i] > nums[i - 1]) {
                break;
            }
        }
        if (i != 0) {
            int j = nums.length - 1;
            for (; j >= i; j--) {
                if (nums[j] > nums[i - 1]) {
                    swap(nums[i - 1],nums[j]);
                    break;
                }
            }
        }
        reverse(nums,i);
    }
    void swap(int i,int j) {
        int tmp = i;
        i = j;
        j = tmp;
    }
    void reverse(int[] nums, int start) {
        int end = nums.length - 1;
        for (; start < end; start++,end--) {
            swap(nums[start],nums[end]);
        }
    }
}

正确代码：(利用break记录指针最后的位置)

(1.if;  2.i for(0)if()break;  3.if(!=)j,for(>=) if(i-1)swap break;  4.reverse(i);  5.swap([]),reverse([],start)) 

public class Solution {
    public void nextPermutation(int[] nums) {
        if (nums == null || nums.length == 0) {
            return;
        }
        int i = nums.length - 1;
        for (; i > 0; i--) {
            if (nums[i] > nums[i - 1]) {
                break;
            }
        }
        if (i != 0) {
            int j = nums.length - 1;
            for (; j >= i; j--) {
                if (nums[j] > nums[i - 1]) {
                    swap(nums, i - 1, j);
                    break;
                }
            }
        }
        reverse(nums, i);
    }
    void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    void reverse(int[] nums, int start) {
        int end = nums.length - 1;
        for (; start < end; start++,end--) {
            swap(nums,start,end);
        }
    }
}

类似的：

public class Solution {
    public void nextPermutation(int[] nums) {
        // find two adjacent elements, n[i-1] < n[i]
        int i = nums.length - 1;
        for (; i > 0; i --) {
            if (nums[i] > nums[i-1]) {
                break;
            }
        }
        if (i != 0) {
            // swap (i-1, x), where x is index of the smallest number in [i, n)
            int x = nums.length - 1;
            for (; x >= i; x --) {
                if (nums[x] > nums[i-1]) {
                    break;
                }
            }
            swap(nums, i - 1, x);
        }
        reverse(nums, i, nums.length - 1);
    }
    
    void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    // reverse a[i, j]
    void reverse(int[] a, int i, int j) {
        for (; i < j; i ++, j --) {
            swap(a, i, j);
        }
    }
}

public class Solution {
    public void nextPermutation(int[] nums) {
      if(nums.length<=1){
          return;
      }
      
      int i= nums.length-1;
      
      for(;i>=1;i--){
         
         if(nums[i]>nums[i-1]){ //find first number which is smaller than it's after number
             break;
         }
      }
      
      if(i!=0){
          swap(nums,i-1); //if the number exist,which means that the nums not like{5,4,3,2,1}
      }
      
      reverse(nums,i);    
    }
    
    private void swap(int[] a,int i){
        for(int j = a.length-1;j>i;j--){
            if(a[j]>a[i]){
                int t = a[j];
                a[j] = a[i];
                a[i] = t;
                break;
            }
        }
    }
    
    private void reverse(int[] a,int i){//reverse the number after the number we have found
        int first = i;
        int last = a.length-1;
        while(first<last){
            int t = a[first];
            a[first] = a[last];
            a[last] = t;
            first ++;
            last --;
        }
    }
    
}

34. Search for a Range: https://leetcode.com/problems/search-for-a-range/

找出有序数组中tar的首尾位置：

九章解法：(两次二分查找，注意while循环条件是start+1<end; 一般涉及范围问题、有重复值问题都应该用这个条件；对应的，下面的mid=start,end;并且要在最后判断边界值start和end。这样可以模板化，避免判断最终边界值start、mid、end混乱、错误的问题)

(start,end,while(+1<)mid,mid  if([]=)else if([]=))

public class Solution {
    public int[] searchRange(int[] A, int target) {
        if (A.length == 0) {
            return new int[]{-1, -1};
        }
        
        int start, end, mid;
        int[] bound = new int[2]; 
        
        // search for left bound
        start = 0; 
        end = A.length - 1;
        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            if (A[mid] == target) {
                end = mid;
            } else if (A[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (A[start] == target) {
            bound[0] = start;
        } else if (A[end] == target) {
            bound[0] = end;
        } else {
            bound[0] = bound[1] = -1;
            return bound;
        }
        
        // search for right bound
        start = 0;
        end = A.length - 1;
        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            if (A[mid] == target) {
                start = mid;
            } else if (A[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (A[end] == target) {
            bound[1] = end;
        } else if (A[start] == target) {
            bound[1] = start;
        } else {
            bound[0] = bound[1] = -1;
            return bound;
        }
        
        return bound;
    }
}

 我的解法：(第二次搜索从rst[0]开始,循环一直继续直到start和end都指向第一个tar)

(1.rst if(0);  2.lo,hi,while(<=)mid,if(>=)mid-1,else mid+1;if(=)mid;  3.if(-1)return;  4.lo,hi,while()mid,if(<=)mid+1,else mid-1;if(=)mid;  5.return)

public class Solution {
    public int[] searchRange(int[] A, int target) {
        int[] rst = new int[]{-1,-1};
        if (A.length == 0) {
            return rst;
        }
        int lo = 0, hi = A.length - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (A[mid] >= target) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
            if (A[mid] == target) rst[0] = mid;
        }
        if (rst[0] == -1) {
            return rst;
        }
        lo = rst[0]; 
        hi = A.length - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (A[mid] <= target) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
            if (A[mid] == target) rst[1] = mid;
        }
        return rst;
    }
}

类似：

public int[] searchRange(int[] nums, int target) {
    int[] result = new int[2];
    result[0] = findFirst(nums, target);
    result[1] = findLast(nums, target);
    return result;
}

private int findFirst(int[] nums, int target){
    int idx = -1;
    int start = 0;
    int end = nums.length - 1;
    while(start <= end){
        int mid = (start + end) / 2;
        if(nums[mid] >= target){
            end = mid - 1;
        }else{
            start = mid + 1;
        }
        if(nums[mid] == target) idx = mid;
    }
    return idx;
}

private int findLast(int[] nums, int target){
    int idx = -1;
    int start = 0;
    int end = nums.length - 1;
    while(start <= end){
        int mid = (start + end) / 2;
        if(nums[mid] <= target){
            start = mid + 1;
        }else{
            end = mid - 1;
        }
        if(nums[mid] == target) idx = mid;
    }
    return idx;
}

35. Search Insert Position: https://leetcode.com/problems/search-insert-position/

找出插入位置：

我的解法：(二分查找，=的时候作为pos即为mid，>的时候-1，< +1，最后的mid 如果大于等于tar，那么pos就是mid，小于tar，pos就是mid+1)

(1.lo,hi,rst,mid;  2.while(<=)if(=)return,if(>)-,if(<)+;  3.if([mid]>=)mid. else mid+1;  4.return)

public class Solution {
    public int searchInsert(int[] nums, int target) {
        int lo = 0, hi = nums.length - 1;
        int rst = 0;
        int mid = 0;
        while (lo <= hi) {
            mid = lo + (hi - lo) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        }
        if (nums[mid] >= target) {
            rst = mid;
        } else {
            rst = mid + 1;
        }
        return rst;
    }
}

类似：(return low; low=mid/low=mid+1)

    public int searchInsert(int[] A, int target) {
        int low = 0, high = A.length-1;
        while(low<=high){
            int mid = (low+high)/2;
            if(A[mid] == target) return mid;
            else if(A[mid] > target) high = mid-1;
            else low = mid+1;
        }
        return low;
    }

39. Combination Sum: https://leetcode.com/problems/combination-sum/

找出数组中所有相加可得到tar的组合(个数不限、使用次数不限)：

解法：(回溯法; target-index作为新的target从i处继续判断; 判断语句放在for外,则是target和0比较;注意递归参数是(tar-[i]和i))(PS:逻辑简单,刚开始参数搞错,结果就一直不对;要学会根据错误结果推断原因)

(1.helper(nums,tar,rst,tmp,index)  2.if(0)rst.add,if(<)return;  3.for(index)add,helper(,tar-[i],rst,tmp,i),remove;  4.conbSum:sort,rst,tmp,helper,return)

public class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> rst = new ArrayList<List<Integer>>();
        Arrays.sort(candidates);
        List<Integer> tmp = new ArrayList<Integer>();
        helper(candidates, target, rst, tmp, 0);
        return rst;
    }
    public void helper(int[] nums, int target, List<List<Integer>> rst, List<Integer> tmp, int index){
        if (target == 0) {
            rst.add(new ArrayList<Integer>(tmp));
            return;
        }
        if (target < 0) {
            return;
        }
        for (int i = index; i < nums.length; i++) {
            tmp.add(nums[i]);
            helper(nums, target - nums[i], rst, tmp, i);
            tmp.remove(tmp.size() - 1);
        }
    }
}

40. Combination Sum II: https://leetcode.com/problems/combination-sum-ii/

含重复数组找出和为tar的组合(个数不限，只能使用一次):

我的解法：(与Combination Sum的解法相同; 区别：1.回溯时要把指针后移一位i+1;  2.遍历时要跳重,只能使用每轮遍历重复数字的第一个(i=index || [i]!=[i-1])

(1.helper(nums,tar,rst,tmp,index)  2.if(0)rst.add,if(<)return;  3.for(index) if(||&&),add helper(,tar-[i],rst,tmp,i+1),remove;  4.cSum:sort,rst,tmp,help,retu)

public class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> rst = new ArrayList<>();
        List<Integer> tmp = new ArrayList<>();
        helper(candidates, target, rst, tmp, 0);
        return rst;
    }
    public void helper(int[] nums, int target, List<List<Integer>> rst, List<Integer> tmp, int index) {
        if (target == 0) {
            rst.add(new ArrayList<Integer>(tmp));
            return;
        }
        if (target < 0) {
            return;
        }
        for (int i = index; i < nums.length; i++) {
            if (i == index || (i != index && nums[i] != nums[i - 1])) {
                tmp.add(nums[i]);
                helper(nums, target - nums[i], rst, tmp, i + 1);
                tmp.remove(tmp.size() - 1);
            }
        }
    }
}

48. Rotate Image: https://leetcode.com/problems/rotate-image/

顺时针九十度旋转二维矩阵: (todo)

public class Solution {
    public void rotate(int[][] matrix) {
        for(int i = 0; i<matrix.length; i++){
            for(int j = i; j<matrix[0].length; j++){
                int temp = 0;
                temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        for(int i =0 ; i<matrix.length; i++){
            for(int j = 0; j<matrix.length/2; j++){
                int temp = 0;
                temp = matrix[i][j];
                matrix[i][j] = matrix[i][matrix.length-1-j];
                matrix[i][matrix.length-1-j] = temp;
            }
        }
    }
}

public class Solution {
    public void rotate(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return;
        }

        int length = matrix.length;

        for (int i = 0; i < length / 2; i++) {
            for (int j = 0; j < (length + 1) / 2; j++){
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[length - j - 1][i];
                matrix[length -j - 1][i] = matrix[length - i - 1][length - j - 1];
                matrix[length - i - 1][length - j - 1] = matrix[j][length - i - 1];
                matrix[j][length - i - 1] = tmp;
            }
        }   
    }
}

53. Maximum Subarray: https://leetcode.com/problems/maximum-subarray/

 连续子数组的最大和: 

解法：(动态规划?)(A[i]前的 Sum<0, 那么就从A[i]作为新的起始点; Sum>0, 那么比较Sum+A[i]和max的大小)(很乱……)

(maxSoFar,maxEndingHere)

public static int maxSubArray(int[] A) {
    int maxSoFar=A[0], maxEndingHere=A[0];
    for (int i=1;i<A.length;++i){
        maxEndingHere= Math.max(maxEndingHere+A[i],A[i]);
        maxSoFar=Math.max(maxSoFar, maxEndingHere);    
    }
    return maxSoFar;
}

public class Solution {
    public int maxSubArray(int[] A) {
        if (A == null || A.length == 0){
            return 0;
        }
        
        int max = Integer.MIN_VALUE, sum = 0;
        for (int i = 0; i < A.length; i++) {
            sum += A[i];
            max = Math.max(max, sum);
            sum = Math.max(sum, 0);
        }

        return max;
    }
}

54.Spiral Matrix: https://leetcode.com/problems/spiral-matrix/

返回矩阵的螺旋顺序：

解法：(画出矩阵图, 第一趟为[00]-[0n], [1n]-[mn], [m,n-1]-[m0], [m-1,0]-[1,0]; 第二趟,左右边界各加1,用count计数; 判断只剩一行或一列的break)

(1.rst,if();  2.rows,cols,count;  3.while(*2<) for for if(==1) for for, count++;  4.return rst;)

public class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> rst = new ArrayList<>();
        if (matrix == null || matrix.length == 0)
            return rst;
        int rows = matrix.length;
        int cols = matrix[0].length;
        int count = 0;
        while (count * 2 < rows && count * 2 < cols) {
            for (int i = count; i < cols - count; i++) {
                rst.add(matrix[count][i]);
            }
            for (int i = count + 1; i < rows - count; i++) {
                rst.add(matrix[i][cols - count - 1]);
            }
            
            if (rows - 2 * count == 1 || cols - 2 * count == 1)
                break;
            
            for (int i = cols - count - 2; i >= count; i--) {
                rst.add(matrix[rows - count - 1][i]);
            }
            for (int i = rows - count - 2; i >= count + 1; i--) {
                rst.add(matrix[i][count]);
            }
            count++;
        }
        return rst;
    }
}

55. Jump Game：https://leetcode.com/problems/jump-game/

步数不大于值从开始跳到结尾：

 解法1：DP动态规划 (定义数组boolean[] can, 对于数组中任意i,true的条件是存在j<i满足can[j]=true且j+a[j]<=i;所以需要遍历i之前的所有值; O(n^2))(大数据TLE)

(1.if();  2.[]can,[0];  3.for(0,n-1)for(0,i) if(&&)[i];  4.return [n-1];)

public class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return true;
        }
        boolean[] can = new boolean[nums.length];
        can[0] = true;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (can[j] && j + nums[j] >= i) {
                    can[i] = true;
                }
            }
        }
        return can[nums.length - 1];
    }
}

解法2：Greedy--根据已知条件得出局部最优解 (0-farthest-a[0];遍历数组,如果i在far范围内,那么far=max(far,a[i]+i); 最后判断far和n-1;)

public class Solution {
    public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return true;
        }
        int farthest = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (farthest >= i ) 
                farthest = Math.max(farthest, i + nums[i]);
        }
        return farthest >= nums.length - 1;
    }
}

public class Solution {
    public boolean canJump(int[] A) {
        // think it as merging n intervals
        if (A == null || A.length == 0) {
            return false;
        }
        int farthest = A[0];
        for (int i = 1; i < A.length; i++) {
            if (i <= farthest && A[i] + i >= farthest) {
                farthest = A[i] + i;
            }
        }
        return farthest >= A.length - 1;
    }
}

59. Spiral Matrix II: https://leetcode.com/problems/spiral-matrix-ii/

 平方螺旋矩阵：

我的解法：(与Spiral Matrix解法相同, 区别是rows和cols都是n, 定义count计数四边已经铺了数字的边框,定义num++;对四边分别for循环赋值, 内部与最外圈的区别就是多了一个count,包括起始条件+/-count, 终止条件+/-count; 前两个for顺序遍历, 中间插入判断条件break, 后两个for倒序;)

(1.int[][],num,count;  2.while(*2<) for for if() for for;  3.return)

public class Solution {
    public int[][] generateMatrix(int n) {
        int[][] Matrix = new int[n][n];
        int count = 0;
        int num = 1;
        while (count * 2 < n) {
            for (int i = count; i < n - count; i++) {
                Matrix[count][i] = num++;
            }
            for (int i = count + 1; i < n - count; i++) {
                Matrix[i][n - count - 1] = num++;
            }
            
            if (count * 2 == n - 1) break;
            
            for (int i = n - count - 2; i >= count; i--) {
                Matrix[n - count - 1][i] = num++;
            }
            for (int i = n - count - 2; i >= count + 1; i--) {
                Matrix[i][count] = num++;
            }
            count++;
        }
        return Matrix;
    }
}

类似：(不定义count, 直接用n-2作为变化, 判断条件为n>0; 不过重复定义了xStart,yStart; 其实方法一样……)

public class Solution {
    public int[][] generateMatrix(int n) {
        if (n < 0) {
            return null;
        }

        int[][] result = new int[n][n];

        int xStart = 0;
        int yStart = 0;
        int num = 1;

        while (n > 0) {
            if (n == 1) {
                result[yStart][xStart] = num++;
                break;
            }

            for (int i = 0; i < n - 1; i++) {
                result[yStart][xStart + i] = num++;
            }

            for (int i = 0; i < n - 1; i++) {
                result[yStart + i][xStart + n - 1] = num++;
            }

            for (int i = 0; i < n - 1; i++) {
                result[yStart + n - 1][xStart + n - 1 - i] = num++;
            }

            for (int i = 0; i < n - 1; i++) {
                result[yStart + n - 1 - i][xStart] = num++;
            }

            xStart++;
            yStart++;
            n = n - 2;
        }

        return result;
    }
}

62. Unique Paths: https://leetcode.com/problems/unique-paths/

 网格首尾的所有可能路径：

 Wrong!典型TLE解法：递归

public class Solution {
    public int uniquePaths(int m, int n) {
        if (m == 1 || n == 1) return 1;
        return (uniquePaths(m - 1, n) + uniquePaths(m, n - 1));
    }
}

解法：(for循环;第一列和第一行上的所有数sum为1,对于[i][j], 有递推关系sum=[i-1][j]+[i][j-1], return[m-1][n-1]) (Q: 所有递归均能改成for循环遍历+递推?)

(1.sum[][];  2.for[i][0] for[0][i]; 3.for()for()[i][j];  4.return[-1][-1])

public class Solution {
    public int uniquePaths(int m, int n) {
        int[][] sum = new int[m][n];
        for (int i = 0; i < m ; i++) {
            sum[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            sum[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                sum[i][j] = sum[i - 1][j] + sum[i][j - 1];
            }
        }
        return sum[m - 1][n - 1];
    }
}

63. Unique Paths II: https://leetcode.com/problems/unique-paths-ii/

有障碍的网格的所有可能路径：

我的解法: (类似U Paths, 区别:对于第一行和第一列,如果在[i][0]出现1,那么i上的sum为1,i下的sum为零;用递推关系sum[i][0] = sum[i-1][0]来表示, 当存在a[i][0]为1时,则sum[i][0]=0,后面依然用递推关系……(这段似乎可以用指针优化,一旦发现第一个1,就把后面的sum都置零?); 其次 对于[i][j]区别就是多一个判断条件,如果a[i][j]=1,那么sum[i][j]=0)

(1.m,n,int,if,sum;  2.for(1,m)if(0)[i][0]=[i-1][0] else[i][0]=0; for(1,n);  3.for(1,m)(1,n)if(1)0 else[i][j]=[i-1][j]+[i][j-1];  4.return)

public class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] sum = new int [m][n];
        if (obstacleGrid[0][0] == 1) return 0;
        sum[0][0] = 1;
        for (int i = 1; i < m; i++) {
            if (obstacleGrid[i][0] == 0) 
                sum[i][0] = sum[i - 1][0];
            else sum[i][0] = 0;
        }
        for (int i = 1; i < n; i++) {
            if (obstacleGrid[0][i] == 0)
                sum[0][i] = sum[0][i - 1];
            else sum[0][i] = 0;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1)
                    sum[i][j] = 0;
                else
                    sum[i][j] = sum[i -1][j] + sum[i][j - 1];
            }
        }
        return sum[m - 1][n - 1];
    }
}

类似: (第一行第一列遇到1后就break,其他基本相同)

public class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if (obstacleGrid == null || obstacleGrid.length == 0 || obstacleGrid[0].length == 0) {
            return 0;
        }
        
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;
        int[][] paths = new int[n][m];
        
        for (int i = 0; i < n; i++) {
            if (obstacleGrid[i][0] != 1) {
                paths[i][0] = 1;
            } else {
                break;
            }
        }
        
        for (int i = 0; i < m; i++) {
            if (obstacleGrid[0][i] != 1) {
                paths[0][i] = 1; 
            } else {
                break;
            }
        }
        
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < m; j++) {
                if (obstacleGrid[i][j] != 1) {
                    paths[i][j] = paths[i - 1][j] + paths[i][j - 1];
                } else {
                    paths[i][j] = 0;
                }
            }
        }
        
        return paths[n - 1][m - 1];
    }
}

64. Minimum Path Sum：https://leetcode.com/problems/minimum-path-sum/

 网格路径上元素和的最小值：

我的解法：(类似U Paths 和UP II, 方法是动态规划/递推关系。对于grid[i][j], sum的值为sum[i-1][j]和sum[i][j-1]的小的值加上grid[i][j]; 其次对于第一行和第一列,sum就是[0][i-1]+grid[0][i]) (PS:Bug Free!! 一次AC!!)

public class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] sum = new int[m][n];
        sum[0][0] = grid[0][0];
        for (int i = 1; i < m; i++) {
            sum[i][0] = sum[i - 1][0] + grid[i][0];
        }
        for (int i = 1; i < n; i++) {
            sum[0][i] = sum[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                sum[i][j] = Math.min(sum[i - 1][j], sum[i][j - 1]) + grid[i][j];
            }
        }
        return sum[m - 1][n - 1];
    }
}

73. Set Matrix Zeroes：https://leetcode.com/problems/set-matrix-zeroes/

 零所在的行和列都置零：

 解法1：(O(m+n)space, 初始化row[]和col[], if(matrix[i][j])等于零, 就将row[i]和col[j]置一; 遍历row,将为1的i行置零; 同理col;)

(1.m,n,row,col;  2.for()for()if(=)1;  3.for()if()for()0; for()if()for()0; )

public class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[] row = new int[m];
        int[] col = new int[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    row[i] = 1;
                    col[j] = 1;
                }
            }
        }
        for (int i = 0; i < m; i++) {
            if (row[i] == 1) {
                for (int j = 0; j < n; j++) {
                    matrix[i][j] = 0;
                }
            }
        }
        for (int j = 0; j < n; j++) {
            if (col[j] == 1) {
                for (int i = 0; i < m; i++) {
                    matrix[i][j] = 0;
                }
            }
        }

    }
}

解法2：(In place 用第一行和第一列作为标记;  从[1][1]后遍历, 如果[i][j]=0,  那么就标记对应的[i][0]和[0][j]=0; 但需要单独考虑row0和col0; 如果存在i=0或j=0时[i][j]=0,需要先暂时用fr和fc标记, 最后额外将first row或者first col置零)

 (1.m,n,fr,fc;  2.for()for()if(=) if()if() 0 0;  3.for(1)for(1)if(||)0;  4.if(fr) if(fc);)

public class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        boolean fr = false;
        boolean fc = false;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    if (i == 0) fr = true;
                    if (j == 0) fc = true;
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        if (fr) {
            for (int i = 0; i < n; i++) {
                matrix[0][i] = 0;
            }
        }
        if (fc) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
    }
}

74. Search a 2D Matrix: https://leetcode.com/problems/search-a-2d-matrix/

查找二维矩阵: (参考LintCode 1-30 里的T28)

解法1： 暴力解法 (for)

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int row = matrix.length;
        int col = matrix[0].length;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (matrix[i][j] == target)
                    return true;
            }
        }
        return false;
    }
}

解法2： 两次二分(第一次找到tarRow,防止遗漏while(+1<)+mid+if判断; 第二次while(<=)+ mid+1/-1;)

(1.ifif;  2.start,end,row;  3.while(+1<)mid if(=)if(</>)mid;  4.if(<=)elseif(<=)else false;  5.while(<=)if eif e;  6.return false;)

public class Solution {
    /**
     * @param matrix, a list of lists of integers
     * @param target, an integer
     * @return a boolean, indicate whether matrix contains target
     */
    public boolean searchMatrix(int[][] matrix, int target) {
        // write your code here
        if (matrix == null || matrix.length == 0){
            return false;
        }
        if (matrix[0] == null || matrix[0].length == 0){
            return false;
        }
        int start = 0;
        int end = matrix.length - 1;
        int row ;
        while (start + 1 < end) {
            int mid = start + (end - start)/2;
            if (matrix[mid][0] == target){
                return true;
            } else if (matrix[mid][0] < target) {
                start = mid ;
            } else {
                end = mid ;
            }
        }
        if (matrix[end][0] <= target){
            row = end;
        } else if (matrix[start][0] <= target){
            row = start;
        } else {
            return false;
        }
     
        start = 0;
        end = matrix[0].length - 1;
        while (start <= end) {
            int mid = start + (end - start)/2;
            if (matrix[row][mid] == target){
                return true;
            } else if (matrix[row][mid] < target) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return false;
    }
}

解法3：一次二分(把matrix看成数组, m*n-1; row=mid/col, col=mid%col;)

(1.ifif;  2.row,col,start,end;  3.while(<=)mid num=[/][%], if()e if() e;  4.return false; )

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix ==  null ||  matrix.length == 0) 
            return false;
        if (matrix[0] == null || matrix[0].length == 0) 
            return false;
        int row = matrix.length;
        int col = matrix[0].length;
        
        int start = 0, end = row * col - 1;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (matrix[mid / col][mid % col] == target) {
                return true;
            } else if (matrix[mid / col][mid % col] > target) {
                end = mid - 1;
            } else
                start = mid + 1;
        }
        return false;
    }
}

75. Sort Colors: https://leetcode.com/problems/sort-colors/

 只含0,1,2的数组排序:

解法1：计数 两趟for循环:

public class Solution {
    public void sortColors(int[] nums) {
        int cnt0 = 0, cnt1 = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == 0)
                cnt0++;
            else if (nums[i] == 1)
                cnt1++;
        }
        for (int i = 0; i < nums.length; i++) {
            if (i < cnt0) 
                nums[i] = 0;
            else if (i < cnt0 + cnt1)
                nums[i] = 1;
            else nums[i] = 2;
        }
    }
}

解法2：Two Pointers (左指针指向0的后一位, 右指针指向2的前一位, i遍历l;  如果遍历到[i]为0,交换pl和i,pr++,i++; 如果遍历到2,交换pr和i,pr--; 遍历到1,i++;)(注意：循环条件i<=pr; [i]=2时,swap后i不增;)

(1.pl,pr,i;  2.for(<=)if()swap(++,++), if()++, if()swap(--);  3.swap)

public class Solution {
    public void sortColors(int[] nums) {
        int pl = 0, pr = nums.length - 1;
        for (int i = 0; i <= pr;) {
            if (nums[i] == 0)
                swap(nums, i++, pl++);
            else if (nums[i] == 1)
                i++;
            else
                swap(nums, i, pr--);
        }
    }
    public void swap (int[]a, int i, int j) {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
}

78. Subsets: https://leetcode.com/problems/subsets/

数组的子集数组：(参考LintCode 1-30: T17)

解法1：(1.rst,if();  2.tmp,helper,return;  3.helper(nums,rst,tmp,index), add, for(index) add,help(i+1),remove)

public class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        ArrayList<List<Integer>> rst = new ArrayList<List<Integer>>();
        if (nums.length == 0) {
            rst.add(new ArrayList<Integer>());
            return rst;
        }
        List<Integer> tmp = new ArrayList<Integer>();
        helper(nums, rst, tmp, 0);
        return rst;
    }
    public void helper(int[] nums, List<List<Integer>> rst, List<Integer> tmp, int index){
        rst.add(new ArrayList<Integer>(tmp));
        
        for (int i = index; i < nums.length; i++) {
            tmp.add(nums[i]);
            helper(nums, rst, tmp, i + 1);
            tmp.remove(tmp.size() - 1);
        }
    }
}

解法2：位运算(用bit位来表示这一位的number要不要取，第一位有1，0即取和不取2种可能性。所以只要把0到N种可能都用bit位表示，再把它转化为数字集合，就可以了)

class Solution {
    /**
     * @param S: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        int n = nums.length;
        Arrays.sort(nums);
        
        // 1 << n is 2^n
        // each subset equals to an binary integer between 0 .. 2^n - 1
        // 0 -> 000 -> []
        // 1 -> 001 -> [1]
        // 2 -> 010 -> [2]
        // ..
        // 7 -> 111 -> [1,2,3]
        for (int i = 0; i < (1 << n); i++) {
            ArrayList<Integer> subset = new ArrayList<Integer>();
            for (int j = 0; j < n; j++) {
                // check whether the jth digit in i's binary representation is 1
                if ((i & (1 << j)) != 0) {
                    subset.add(nums[j]);
                }
            }
            result.add(subset);
        }
        
        return result;
    }
}

79. Word Search：https://leetcode.com/problems/word-search/

 二维矩阵查找字符串(todo)

80. Remove Duplicates from Sorted Array II: https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/

 解法：<Two Pointers> (index指向"新"数组的后一位, i指向原数组; 如果i所指的数num和index-2所指的数相同, 表面new Array里已经包含两个数了, 那么就跳过这个数;)

(1.index;  2.for() if(<2||!=[index-2])=  3.return index;)

public class Solution {
    public int removeDuplicates(int[] nums) {
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i < 2 || nums[i] != nums[index - 2]) {
                nums[index++] = nums[i];
            }
        }
        return index;
    }
}

Remove Duplicates from Sorted Array(no duplicates) :

public int removeDuplicates(int[] nums) {
    int i = 0;
    for(int n : nums)
        if(i < 1 || n > nums[i - 1]) 
            nums[i++] = n;
    return i;
}
Remove Duplicates from Sorted Array II (allow duplicates up to 2):

public int removeDuplicates(int[] nums) {
   int i = 0;
   for (int n : nums)
      if (i < 2 || n > nums[i - 2])
         nums[i++] = n;
   return i;
}

81. Search in Rotated Sorted Array II: https://leetcode.com/problems/search-in-rotated-sorted-array-ii/

 (todo)

90. Subsets II: https://leetcode.com/problems/subsets-ii/

含重复元素的子集：

public class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> rst = new ArrayList<>();
        if (nums.length == 0) {
            rst.add(new ArrayList<Integer>());
            return rst;
        }
        Arrays.sort(nums);
        List<Integer> tmp = new ArrayList<Integer>();
        helper(nums, rst, tmp, 0);
        return rst;
    }
    public void helper(int[] nums, List<List<Integer>> rst, List<Integer> tmp, int index) {
        rst.add(new ArrayList<Integer>(tmp));
        for (int i = index; i < nums.length; i++) {
            if (i == index || (i > index && nums[i] != nums[i - 1])){
                tmp.add(nums[i]);
                helper(nums, rst, tmp, i + 1);
                tmp.remove(tmp.size() - 1);
            }
            
        }
    }
}