标签：pre nums int day7 up day1 down ++ 贪心

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。