算法题总结

1. leetcode #121买卖股票（easy）
   如果第i天卖出股票，则最大利润为(该天的股价-前面天数中最小的股价)，然后与已知的最大利润比较，如果大于则更新当前最大利润的值。
   遍历时考虑最终结果的情况（卖出），反推出前面需要的条件（前序最小的值）。
   如果临场想不出来，可以遍历整体存下来比较

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len <2) return 0;
        int []dp = new int[len];
        int []dp2 = new int[len];
        dp[0] = prices[0];
        for(int i=1;i<len;i++){  //一路上最小的
            dp[i] = dp[i-1] < prices[i] ? dp[i-1] : prices[i];
        }
        dp2[len-1] = prices[len-1];
        for(int i = len-2;i>=0;i--){  //逆序一路上最大的
            dp2[i] = dp[i+1] > prices[i] ? dp[i+1] : prices[i];
        }
        int res = 0;
        for(int i=0;i<len;i++){
            res = dp2[i] -dp[i] > res ? dp2[i] -dp[i] : res;
        }
        return res;
    }
}

2.leetcode #221 最大正方形（middle）
dp[i][j] 以i,j结尾面积最大的边长.
用当前的选择的matrix[i][j] 的值做判断，判断后用目前dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i - 1][j], dp[i][j - 1])) +1 来迭代
可用单独的max来进行记录和更新

 class Solution {
    public int maximalSquare(char[][] matrix) {
        if (matrix == null)
            return 0;
        int row = matrix.length;
        int col = matrix[0].length;
        int[][] dp = new int[row][col];
        int max = 0;
        for (int i = 0; i < row; i++) {
            if (matrix[i][0] == '1') {
                dp[i][0] = 1;
                max =1;
            }
        }
        for (int i = 0; i < col; i++) {
            if (matrix[0][i] == '1') {
                dp[0][i] = 1;
                max =1;
            }
        }
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (matrix[i][j] == '0') {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i - 1][j], dp[i][j - 1])) +1;
                    max = Math.max(max,dp[i][j]);
                }
            }
        }
        return max * max;
    }
}

3. leetcode#135 分发糖果
   从左到右遍历：如果右边比左边多，右边 =左边+1
   在从右到左遍历：如果左边比右边多，左边去= max(左边，右边+1)
   （严禁地想清楚遍历的规律）

class Solution {
    public int candy(int[] ratings) {
        int num = ratings.length;
        int[] res = new int[num];
        Arrays.fill(res, 1);
        for (int i = 0; i < num - 1; i++) {
            if (ratings[i] < ratings[i + 1]) {
                res[i + 1] = res[i] + 1;
            }
        }
        for (int i = num - 1; i > 0; i--) {
            if (ratings[i] < ratings[i -1]  ) {
                res[i - 1] = Math.max( res[i - 1] ,res[i]+1);
            }
        }
        int result = 0;
        for(int i=0;i<num;i++){
            result += res[i];
        }
        return result;
    }
}

4. leetcode#42 接雨水
   找出最大值
   从左到右并从右到左，比temp小则可以接雨水，比temp大则更新temp

  class Solution {
    public int trap(int[] height) {
        int num = height.length;
        int hindex = 0;
        for(int i= 1;i<num;i++){
            if(height[i] > height[hindex]){
                hindex = i;
            }
        }
        int res = 0;
        //寻找当前temp挡板计算雨水
        int temp = height[0];
        for(int i=1;i<hindex;i++){
            if(height[i] < temp  ){
                res += temp - height[i] ;
            }else{
                temp =  height[i];
            }
        }
        temp = height[num-1];
        for(int i=num -2;i>hindex;i--){
             if( height[i] < temp){
                res += temp -height[i];
             }   else{
                temp = height[i];
             }
        }
        return res;
    }
}

leetcode#26. 删除有序数组中的重复项
i重新赋值为j-1，因为while中j已经是不符合要求的值，返回到上面后i还要自动++

class Solution {
    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        int count = 0;
        for(int i=0;i<len;i++){
            nums[count] = nums[i];
            int j=i+1;
            while(j<len && nums[j] == nums[i]){
                j++;
            }
            i =j-1;  //这个地方细节要处理好
            count++;
        }
        return count;
    }
}

leetcode #27 移除元素
因为计数的index本身是从0开始的，所以最后返回时不需要-1

class Solution {
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        int index = 0;
        for(int i=0;i<len;i++){
            if(nums[i] != val){
                nums[index] = nums[i];
                index++;  //因为本身从0开始
            }
        }
        return index;  //所以最后多了 1不用减去
    }
}

leetcode#209长度最小的子数组
左右边界都是从0开始
迭代控制右边，左边的话由区间的和来控制
最后判断Integer.MAX_VALUE，如果还是没变化，就是0

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        int left = 0;
        int right = 0;  
        int res = Integer.MAX_VALUE;
        int temp = 0;
        while (right < len ) {
            temp = temp + nums[right];
            while(temp >=target){   //注意题目是不小于就好
                res = Math.min(res, right - left + 1);
                temp = temp - nums[left];
                left = left + 1;
            }
            right++;
        }
        return res == Integer.MAX_VALUE ? 0: res;
    }
}

leetcode#150 逆波兰式求解
1.直接用String的 .equals来判断，需要switch case依次处理的时候就展开
2.合理而且显示的声明，用 Deque stack = new LinkedList(); //stack来表示具体操作
3.数组长度用length，没有括号。这个是数组的一个属性!!! collection的用size()，String用length()方法

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<Integer>();
        int len = tokens.length;
        for (int i = 0; i < len; i++) {  
            String token = tokens[i];
            if (!isOperator(token) ) {  
                stack.push(Integer.parseInt(token));  
            } else {  
                int num2 = stack.pop();  
                int num1 = stack.pop();  
                switch (token) {
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }
            }  
        } 
        return stack.pop();
    }
    private boolean isOperator(String  token) {  
        return "+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token);
    }  
}