每日5 题

1 50 Power（x, n）

    1 确定n正负  2 结果正负  3 二分

    public double myPow(double x, int n) {
        if (n == 0) return 1.0;
        double res = 1.0;
        if (n < 0) {
            if (x < 1 / Double.MAX_VALUE && x > 1 / Double.MIN_VALUE){
                return Double.MAX_VALUE;
            } else {
                x = 1 / x;
            }
            if (n == Integer.MIN_VALUE){
                res *= x;
                n++;
            }
        }
        n = Math.abs(n);
        boolean isN = false;
        if (n % 2 == 1 && x < 0) isN = true;
        x = Math.abs(x);
        while (n > 0) {
            if ((n & 1) == 1) {
                if (res > Double.MAX_VALUE / x) {
                    return Double.MAX_VALUE;
                }
                res *= x;
            }
            x *= x;
            n >>= 1;
        }
        return isN ? -res : res;
    }

2 49 Group Anagrams

    分成字母，排序

    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) return new ArrayList<List<String>>();
        HashMap<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String item = new String(arr);
            if (!map.containsKey(item)){
                map.put(item, new ArrayList<String>());
            }
            map.get(item).add(str);
        }
        return new ArrayList<>(map.values());
    }

3 48 Rotate Image

    上下翻， \ 对称翻

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

6 45 Jump Game II 

     当前最远，之前最远大，跳

    public int jump(int[] nums) {
        if (nums == null || nums.length == 0)
        {
            return 0;
        }
        int gol = 0, cur = 0, step = 0;
        for (int i = 0; i < nums.length && i <= gol; i++) {
            if (cur < i) {
                cur = gol;
                step++;
            }
            gol = Math.max(gol, nums[i] + i);
        }
        if (gol < nums.length - 1) return -1;
        return step;
    }

7 44 Wildcard Matching  动态规划

    public boolean isMatch(String s, String p) {
        int m = s.length(), n = p.length();
        boolean[][] res = new boolean[m + 1][n + 1];
        res[0][0] = true;
        for (int i = 1; i <= n; i++) {
            res[0][i] = res[0][i - 1] && (p.charAt(i - 1) == '*');
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p.charAt(j - 1) == '*') {
                    res[i][j] = res[i - 1][j] || res[i][j - 1];
                } else {
                    res[i][j] = (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?') && res[i - 1][j - 1];
                }
            }
        }
        return res[m][n];
    }

    public boolean isMatch(String str, String pat) {
        int len = pat.length(), s = 0, p = 0, match = 0, index = -1;
        while (s < str.length()){
            if (p < len && (str.charAt(s) == pat.charAt(p) || pat.charAt(p) == '?')){
                s++;p++;
            } else if (p < len && pat.charAt(p) == '*'){
                index = p;
                match = s;
                p++;
            } else if (index != -1){
                p = index + 1;
                match++;
                s = match;
            } else {
                return false;
            }
        }
        while (p < len && pat.charAt(p) == '*'){
            p++;
        }
        return p == len;
    }

8 Multiply String

  乘法公式

    public String multiply(String num1, String num2) {
        int m = num1.length(), n = num2.length();
        int[] res = new int[m + n];
        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                int num = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
                int p1 = i + j, p2 = i + j + 1;
                int m1 = res[p2] + num;
                res[p2] = m1 % 10;
                res[p1] += m1 / 10;
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            if (sb.length() == 0 && res[i] == 0) continue;
            sb.append(res[i]);
        }
        return sb.length() == 0 ? "0": sb.toString();
    }

9 42 Trapping Rain Water

    public int trap(int[] height) {
        int ml = 0, mr = 0, res = 0, l = 0, r = height.length;
        while (l <= r){
            ml = Math.max(ml, height[l]);
            mr = Math.max(mr, height[r]);
            if (ml < mr){
                res += ml - height[l];
                l++;
            } else {
                res += mr - hright[r];
                r--;
            }
        }
        return res;
    }

10 40 Combination Sum ||

 递归，查看是否重复

    public List<List<Integer>> combinationSum2(int[] can, int tar) {
        List<List<Integer>> res = new ArrayList<>();
        if (can.length == 0) return res;
        Arrays.sort(can);
        help(can, tar, 0, new ArrayList<Integer>(), res);
        return res;
    }
    public void help(int[] can, int tar, int sta, ArrayList<Integer> item, List<List<Integer>> res){
        if (tar == 0){
            res.add(item);
            return;
        }
        if (tar < 0) return;
        for (int i = sta; i < can.length; i++) {
            if (i > sta && can[i] == can[i - 1]) continue;
            item.add(can[i]);
            help(can, tar - can[i], item, res);
            item.remove(item.size() - 1);
        }
    }

11 38 Count and Say

    public String countAndSay(int n) {
        if (n < 1) return "";
        String res = "1";
        for (int i = 2; i <= n; i++) {
            StringBuilder sb = new StringBuilder();
            int k = 0;
            while (k < res.length()) {
                char c = res.charAt(k++);
                int cou = 1;
                while (k < res.length() && res.charAt(k) == c){
                    k++;
                    cou++;
                }
                sb.append(cou);
                sb.append(c);
            }
            res = sb.toString();
        }
        return res;
    }

12 36 Valid Sudoku 

行和列的值

    public boolean isValidSudoku(char[][] board) {
        for (int i = 0; i < 9; i++) {
            Set<Character> row = new HashSet<>();
            Set<Character> col = new HashSet<>();
            Set<Character> cub = new HashSet<>();
            for (int j = 0; j < 9; j++) {
                if (board[i][j] != '.' && !row.add(board[i][j])) return false;
                if (board[j][i] != '.' && !row.add(board[j][i])) return false;
                int r = 3 * (i / 3), c = 3 * (i % 3);
                if (board[r + j / 3][c + j % 3] != '.' && !row.add(board[r + j / 3][c + j % 3])) return false;
            }
        }
        return true;
    }

13 37 Sudoku Solver

    public void solveSudoku(char[][] board) {
        if (board == null || board.length == 0) return;
        slove(board, 0, 0);
    }
    public boolean slove(char[][] c, int i, int j) {
        if (i == c.length) return true;
        if (j == c.length) return slove(c, i + 1, 0);
        if (c[i][j] != '.') return slove(c, i, j + 1);
        for (char k = '0'; k <= '9'; k++) {
            c[i][j] = k;
            if (isV(c, i, j)){
                return slove(c, i, j + 1);
            }
            c[i][j] = '.';
        }
     }
 private boolean isV(char[][] board, int i, int j)  
{  
    for(int k=0;k<9;k++)  
    {  
        if(k!=j && board[i][k]==board[i][j])  
            return false;  
    }  
    for(int k=0;k<9;k++)  
    {  
        if(k!=i && board[k][j]==board[i][j])  
            return false;  
    }          
    for(int row = i/3*3; row<i/3*3+3; row++)  
    {  
        for(int col=j/3*3; col<j/3*3+3; col++)  
        {  
            if((row!=i || col!=j) && board[row][col]==board[i][j])  
                return false;  
        }  
    }  
    return true;  
}  

 14 34 Search for a Range

二分

    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[2]{-1,-1};
        if (nums.length == 0) return res;
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int m = (r - l) / 2 + l;
            if (nums[m] < target) l = m + 1;
            else r = m;
        }
        if (nums[l] != target) return res;
        res[0] = l;
        r = nums.length - 1;
        while (l < r) {
            int m = (r - l) / 2 + l;
            if (nums[m] > target) r = m - 1;
            else l = m;
        }
        res[1] = r;
        return res;
    }

15 32 Longest Valid Parentheses

  栈

    public int longestValidParentheses(String s) {
        Stack<Integer> stack = new Stack<>();
        int start = 0, max = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '('){
                stack.push(i);
            } else {
                if (stack.isEmpty()){
                    start = i + 1;
                } else{
                    stack.pop();
                    int cur = stack.isEmpty() ? i - start + 1 : i - stack.peek();
                    max = Math.max(cur, max);
                }
            }
        }
        return max;
    }

16 31 Next Permutation

    public void nextPermutation(int[] nums) {
        if (nums.length < 2) return;
        int i = nums.length - 1;
        while (; i > 0; i--) {
            if (nums[i - 1] < nums[i]) break;
        }
        if (i != 0) {
            swap(i - 1, nums);
        }
        reverse(i, nums);
    }
    public void swap(int i, int[] nums) {
        int j = nums.length - 1;
        for (; j > i; j--) {
            if (nums[i] < nums[j]){
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
                return;
            }
        }
    }
    public void reverse(int i, int[] nums){
        int j = nums.length - 1;
        while (i < j) {
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            i++;j--;
        }
    }