386. 字典序排数

class Solution {
     /**
     * 1~n
     * 1,10,11,12,2,3,4,5
     * 树的结构
     * 深度优先遍历
     */
    List<Integer> pathList = new ArrayList<>();

    public List<Integer> lexicalOrder(int n) {
        for (int i = 1; i <= 9; i++) {
            dfs(i, n);
        }
        return pathList;
    }

    private void dfs(int cur, int n) {
        // 终止条件
        if (cur > n) return;
        // 根
        pathList.add(cur);
        for (int i = 0; i <= 9; i++) {
            if (cur * 10 + i > n) return;
            dfs(cur * 10 + i, n);
        }
    }
}

300. 最长递增子序列

class Solution {
     /**
     * 动态规划
     * 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
     * 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
     * <p>
     * 以 nums[i] 这个数结尾的最长递增子序列的长度。
     */
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        int n = nums.length;
        // 以nums[i]结尾的最长递增序列的长度
        int[] dp = new int[n];
        //  dp 数组全都初始化为 1 每个数字都是1
        Arrays.fill(dp, 1);
        // 遍历n次
        for (int i = 0; i < n; i++) {
            // 从0 - n-1 以n-1结尾
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        // 最终拿出dp中最大的
        int res = 0;
        for (int i = 0; i < n; i++) {
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

461. 汉明距离

class Solution {
       /**
     * 两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。
     * 给你两个整数 x 和 y，计算并返回它们之间的汉明距离。
     */
    public int hammingDistance(int x, int y) {
        // 异或运算,如果两个数相同,就为1,否则为0 Integer.bitCount
        return bitCount(x ^ y);
    }

    private int bitCount(int cur) {
        int count = 0;
        while (cur > 0) {
            // 判断是否不相等,二进制是否能被2整除
            if (cur % 2 == 1) {
                count++;
            }
            cur >>= 1;
        }
        return count;
    }
}

821. 字符的最短距离

class Solution {
    /**
     * 给你一个字符串 s 和一个字符 c ，且 c 是 s 中出现过的字符。
     * 返回一个整数数组 answer ，其中 answer.length == s.length 且 answer[i] 是 s 中从下标 i 到离它 最近 的字符 c 的 距离 。
     * 两个下标i 和 j 之间的 距离 为 abs(i - j) ，其中 abs 是绝对值函数。
     */
    public int[] shortestToChar(String s, char c) {
        if (s == null || s.length() == 0) return new int[]{};
        int len = s.length();
        int[] answer = new int[len];
        Arrays.fill(answer, Integer.MAX_VALUE);
        // 存下标
        Set<Integer> cIndex = new HashSet<>();
        for (int i = 0; i < len; i++) {
            if (s.charAt(i) == c) cIndex.add(i);
        }
        for (int i = 0; i < len; i++) {
            for (Integer index : cIndex) {
                int distance = Math.abs(index - i);
                answer[i] = Math.min(distance, answer[i]);
                System.out.println(answer[i]);
            }
        }
        return answer;
    }
}