回溯day7+贪心day1

37. 解数独

class Solution {
    public void solveSudoku(char[][] board) {
        backtracking(board);
    }
    private boolean backtracking(char[][] board) {
        //遍历整个数组找空位置填入数字1-9中一个
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j] != '.') continue;
                for (char k = '1'; k <= '9'; k++) {
                    if (isValid(board, i, j, k)) {
                        board[i][j] = k;
                        if (backtracking(board)) return true;
                        board[i][j] = '.';
                    }
                }
                //如果1-9没一个能放的，则无解
                return false;
            }
        }
        return true;
    }
    private boolean isValid(char[][] board, int r, int c, char k) {
        //该行可以放吗
        for (int j = 0; j < board[0].length; j++) {
            if (board[r][j] == k) return false;
        }
        //列
        for (int i = 0; i < board.length; i++) {
            if (board[i][c] == k) return false;
        }
        //九宫格
        int sr = r / 3 * 3;
        int sc = c / 3 * 3;
        for (int i = sr; i < sr + 3; i++) {
            for (int j = sc; j < sc + 3; j++) {
                if (board[i][j] == k) return false;
            }
        }
        //合法
        return true;
    }
}

455. 分发饼干

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        //res记录满足的孩子，i为饼干数组下标
        int res = 0, i = 0;
        while (res < g.length && i < s.length) {
            if (g[res] <= s[i]) res++;
            i++;
        }
        return res;
    }
}

376. 摆动序列

//贪心
class Solution {
    //子序列可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。
    public int wiggleMaxLength(int[] nums) {
        //count用来计数 res用来存最大子序列长
        int count = 1, len = nums.length;
       
        //表示上一个差值为正，0表示负
        int pre = -1;
        //初始化pre
        for (int i = 1; pre == -1 && i < len; i++) {
            int deficit = nums[i] - nums[i - 1];
            if (deficit > 0) pre = 1;
            else if (deficit < 0) pre = 0;
            else continue;
            count++;
        }
        for (int i = 1; i < len; i++) {
            int deficit = nums[i] - nums[i - 1];
            //当前差为正数且前一个差为负数
            if (deficit > 0 && pre == 0) {
                count++;
                pre = 1;
            } else if (deficit < 0 && pre == 1) {
                count++;
                pre = 0;
            } else continue; //不满足摆动序列条件，继续往下（根据题设要求不用重置值）
        }
        return count;
    }
}

亦可以使用动规解之

//动规
class Solution {
    public int wiggleMaxLength(int[] nums) {
        int len = nums.length;
        //size of nums in [1, 1000]
        if (len == 1) {
            return len;
        }
        int up, down;
        //第一个数可以作为波峰也可以作为波谷
        //可以不用dp数组 因为i的up和down总是由上一个up或down得来的
        up = down = 1;
        for (int i = 1; i < len; i++) {
            //nums[i] > nums[i - 1] i可能作为波峰，而波峰只能由前面最后一个作为波谷的值得来 因为不可能两次up都计入（没有摆动）
            if (nums[i] > nums[i - 1]) {
                up = down + 1;
            } else if (nums[i] < nums[i - 1]) {
                down = up + 1;
            }
        }
        //最后得出以第一个数作为波谷down和作为波峰up所得到的最长摆动子序列中更优的一个。
        return Math.max(down, up);
    }
}

参考：programmercarl.com

标签：pre,nums,int,day7,up,day1,down,++,贪心
来源： https://www.cnblogs.com/lizihhh/p/backtracking07.html