leetcode 1

public class CoverMaxPoint {
    public static int maxPoint1(int[] arr,int L){
        int res = 1;
        for (int i = 0; i < arr.length; i++) {
            int nearest = nearestIndex(arr,i,arr[i]-L);
            res = Math.min(res,i-nearest+1);
        }
        return res;
    }

    public static int nearestIndex(int[] arr,int R,int value){
        int L = 0;
        int index =R;
        while(L <= R){
            int mid = L + ((R-L) >> 1);
            if(arr[mid] >= value){
                index = mid;
                R = mid -1;
            }else{
                L = mid + 1;
            }
        }
        return index;
    }

    public static int maxPoint2(int[] arr,int L){
        int left=  0;
        int right = 0;
        int N = arr.length;
        int max =0 ;
        while(left < N){
            while(right < N && arr[right]-arr[left] <= L){
                right++;
            }
            max = Math.max(max,right-(left++));
        }
        return max;
    }
}

    public static int needParentheses(String s){
        char[] str= s.toCharArray();
        int count = 0;
        int need= 0;
        for (int i = 0; i < str.length; i++) {
            if (str[i] == '(') {
                count++;
            }else {
                if(count == 0){
                    need++;
                }else{
                    count--;
                }
            }
        }
        return need+count;
    }

    public static int maxLength(String s){
        if(s == null || s.equals("")){
            return 0;
        }
        char[] str = s.toCharArray();
        int[] dp = new int[str.length];
        int pre = 0;
        int res = 0;
        for (int i = 1; i < str.length; i++) {
            if(str[i] == ')'){
                pre = i - dp[i-1] -1;
                if(pre >= 0 && str[pre] == '('){
                    dp[i] = dp[i-1] + 2 + (pre >0?dp[pre-1]:0);
                }
            }
            res = Math.max(res,dp[i]);
        }
        return res;
    }

    public static int minPaint(String s){
        if(s == null || s.length() == 0){
            return 0;
        }
        char[] str = s.toCharArray();
        int N = str.length;
        int[] right = new int[N];
        right[N-1] = str[N-1] == 'R'?1:0;
        for(int i =N-2;i >=0;i--){
            right[i] = right[i+1] + (str[i] == 'R' ? 1 : 0);
        }
        int ans = right[0];//这种默认结果就是左侧没有，右侧全是 这种划分情况的答案
        int left = 0;
        for (int i = 0; i < N - 1; i++) {
            left += str[i] == 'G' ? 1 :0 ;
            ans =Math.min(ans,left + right[i+1]);
        }
        //剩下一种情况，左侧全是，右侧是空的划分。
        ans = Math.min(ans,left + (str[N-1] == 'G'?1:0));

        return ans;
    }

public class MaxOneBoarderSize {
    public static void setBoardMap(int[][] m,int[][] right,int[][] down){
        int r = m.length;
        int c = m[0].length;
        if(m[r-1][c-1] == 1){
            right[r-1][c-1] = 1;
            down[r-1][c-1] = 1;
        }
        for (int i = r-2; i != -1 ; i--) {
            if(m[i][c-1] == 1){
                right[i][c-1] = 1;
                down[i][c-1] =down[i+1][c-1]+1;
            }
        }

        for(int i = c-2;i!=-1;i--){
            if(m[r-1][i] == 1){
                right[r-1][i] = right[r-1][i+1] + 1;
                down[r-1][i] =1;
            }
        }

        //从下往上，从右往左
        for(int i = r-2;i!=-1;i--){
            for(int j = c-2;j!=-1;j--){
                if(m[i][j] == 1){
                    right[i][j] = right[i][j+1] + 1;
                    down[i][j] = down[i+1][j]  +1;
                }
            }
        }

    }

    public static boolean hasSizeOfBorder(int size,int[][] right,int[][] down){
        for (int i = 0; i != right.length-size+1; i++) {
            for(int j= 0;j!=right[0].length-size+1;j++){
                if (right[i][j] >= size && down[i][j] >= size
                        && right[i + size - 1][j] >= size && down[i][j + size - 1] >= size) {//判断这四个点的边长
                    return true;
                }
            }
        }
        return false;
    }

    public static int  getMaxSize(int[][] m){
        int[][] right =  new int[m.length][m[0].length];
        int[][] down = new int[m.length][m[0].length];
        setBoardMap(m,right,down);

        for(int size=Math.min(m.length,m[0].length);size!=0;size--){
            if(hasSizeOfBorder(size,right,down)){
                return size;
            }
        }
        return 0;
    }
}