每日力扣刷题

格雷编码

题目

89. 格雷编码 - 力扣（LeetCode）

思路

总体思路根据前一个格雷码找出下一个n位格雷码。

我们已知 n=1 时，格雷码为【0，1】

要保证格雷码特性并且找出下一个n位格雷码，就需要正序+前缀逆转

简单来说，我们需要先保留n=1时的格雷码【0，1】，再将其逆转为【1，0】，同时为逆转后的列表中的元素加上前缀，即2^(n-1)次方。

这样就能保证相邻元素的二进制位只有一位的区别。

所以 n=2 的格雷码即为 【0，1】+【1+2^1，0+2^1]，也就是【0，1，3，2】

就这样不断的递归就可以找出n位的格雷码

代码

public List<Integer> grayCode(int n) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(0);
        list.add(1);
        list = fun(n, 2, list);
        return list;

    }

    private List<Integer> fun(int n, int x, List<Integer> list) {
        if (x > n) {
            return list;
        }
        List<Integer> item = new ArrayList<>();
        for (int i = list.size() - 1; i >= 0; i--) {
            item.add((int) (list.get(i) + Math.pow(2, x - 1)));
        }
        list.addAll(item);
        return fun(n, x + 1, list);
    }

解码方法

题目

91. 解码方法 - 力扣（LeetCode）

思路

刚开始我用的是递归，后来时间超限了。

仔细一想这一题可以用动态规划来做，首先定义dp数组，dp[i]即表示从0-i的字符串有几种编码方式。

然后确定动态转移方程，dp[i]=dp[i-1] //当两个字符表示的数字大小会超出26的限制，或者有0

                                        dp[i]=dp[i-1]+dp[i-2] //两个字符表述的数字大小在区间内

最后就是遍历更新dp数组，最后的dp[s.length()]就是代表s字符串的解码方式次数了。

代码

public int numDecodings(String s) {
        if (s.isEmpty() || s.charAt(0) == '0') {
            return 0;
        }
        int[] dp = new int[s.length() + 1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= s.length(); i++) {
            if (s.charAt(i - 1) != '0') {
                dp[i] = dp[i] + dp[i - 1];
            }
            int twoDigit = Integer.parseInt(s.substring(i - 2, i));
            if (twoDigit > 9 && twoDigit < 27) {
                dp[i] = dp[i] + dp[i - 2];
            }
        }
        return dp[s.length()];
    }

复原IP地址

题目

93. 复原 IP 地址 - 力扣（LeetCode）

思路

这一题三层循环暴力搜索也可以ac，更好的方法自然就是回溯+剪枝

代码

暴力代码

public List<String> restoreIpAddresses(String s) {
        List<String> result = new ArrayList<>();
        if (s.length() < 4 || s.length() > 12) {
            return result;
        }
        for (int i = 1; i < s.length() && i < 4; i++) {
            for (int j = i + 1; j < s.length() && j < i + 4; j++) {
                for (int k = j + 1; k < s.length() && k < j + 4; k++) {
                    String part1 = s.substring(0, i);
                    String part2 = s.substring(i, j);
                    String part3 = s.substring(j, k);
                    String part4 = s.substring(k);
                    if (isValid(part1) && isValid(part2) && isValid(part3) && isValid(part4)) {
                        result.add(part1 + "." + part2 + "." + part3 + "." + part4);
                    }
                }
            }
        }

        return result;
    }

private boolean isValid(String part) {
     if (part.length() > 1 && part.charAt(0) == '0') {
        return false;
     }
     int num = Integer.parseInt(part);
     return num >= 0 && num <= 255;
 }

 

回溯+剪枝代码

private boolean isValid(String part) {
        if (part.length() > 1 && part.charAt(0) == '0') {
            return false;
        }
        int num = Integer.parseInt(part);
        return num >= 0 && num <= 255;
    }

    public List<String> restoreIpAddresses(String s) {
        if (s.length() < 4 || s.length() > 12) {
            return new ArrayList<>();
        }
        List<String> list = new ArrayList<>();
        List<String> cur = new ArrayList<>();
        funIdp(list, s, cur, 0);
        return list;
    }

    private void funIdp(List<String> list, String s, List<String> cur, int start) {
        if (cur.size() == 4) {
            if (start == s.length()) {
                list.add(String.join(".", cur));
            }
            return;
        }
        for (int i = 1; i <= 3; i++) {
            if (start + i > s.length()) {
                break;
            }
            String str = s.substring(start, start + i);
            if (isValid(str)) {
                cur.add(str);
                funIdp(list, s, cur, i + start);
                cur.remove(cur.size() - 1);
            }
        }

    }

不同的二叉搜索树

题目

95. 不同的二叉搜索树 II - 力扣（LeetCode）

思路

二叉搜索树，特性就是左节点》根节点》右节点

选择每个数字作为根节点，然后将剩下的数字划分为左右子树。每次递归时，都要尝试使用不同的数字作为根节点，构建子树。

代码

public List<TreeNode> generateTrees(int n) {
        if (n == 0) {
            return new ArrayList<>();
        }
        return funTree(1, n);
    }

    private List<TreeNode> funTree(int start, int end) {
        List<TreeNode> res = new ArrayList<>();
        if (start > end) {
            res.add(null);
            return res;
        }
        for (int i = start; i <= end; i++) {
            List<TreeNode> lefts = funTree(start, i - 1);
            List<TreeNode> rights = funTree(i + 1, end);
            for (TreeNode left : lefts) {
                for (TreeNode right : rights) {
                    TreeNode root = new TreeNode(i);
                    root.left = left;
                    root.right = right;
                    res.add(root);
                }
            }
        }
        return res;
    }