day03-算法热题10题

LeetCode 热题 Hot 100

• 46. 全排列

class Solution {
      /**
     * 存储最终结果
     */
    private List<List<Integer>> pathList = new LinkedList<>();
    /**
     * 存储每组数据
     */
    private List<Integer> path = new LinkedList<>();

    public List<List<Integer>> permute(int[] nums) {
        backtrack(nums);
        return pathList;
    }

    /**
     * 回溯法
     */
    public void backtrack(int[] nums) {
        // 触发结束条件
        // 当全部遍历完,就把本次的结果放到最终结果集合里
        if (path.size() == nums.length) {
            pathList.add(new LinkedList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            // 排除不合法的选择
            if (path.contains(nums[i])) continue;
            path.add(nums[i]);
            backtrack(nums);
            // 撤销选择
            path.remove(path.size() - 1);
        }
    }
}

• 48. 旋转图像

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        // 先沿着对角线进行翻转
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = tmp;
            }
        }
        // 然后反转二维矩阵的每一行
        for (int[] row : matrix) {
            reverse(row);
        }
    }
    // 反转一维数组
    public void reverse(int[] row) {
        int i = 0, j = row.length - 1;
        while (i < j) {
            int tmp = row[i];
            row[i] = row[j];
            row[j] = tmp;
            i++;
            j--;
        }
    }
}

• 49. 字母异位词分组

class Solution {
      /**
     * 1.用hashMap来存储异位词
     * 2.判断是否是同一个异位词,一共有26个字母,都是小写字母,如果有大写字母就是52个字母
     * 利用每个字符的出现次数进行编码
     */
    public List<List<String>> groupAnagrams(String[] strs) {
        // 编码到分组的映射
        Map<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            // 对字符串进行编码
            String code = encode(str);
            map.putIfAbsent(code, new LinkedList<>());
            map.get(code).add(str);
        }
        // 获取结果
        return new ArrayList<>(map.values());
    }

    /**
     * 利用每个字符的出现次数进行编码
     */
    private String encode(String s) {
        char[] code = new char[26];
        for (char c : s.toCharArray()) {
            int delta = c - 'a';
            code[delta]++;
        }
        return new String(code);
    }
}

• 53. 最大子数组和

 /**
     * 动态规划
     */
    public int maxSubArray1(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        // 第一个元素前面没有子数组
        dp[0] = nums[0];
        int res = dp[0];
        // 状态转移方程
        for (int i = 1; i < n; i++) {
            dp[i] = Math.max(nums[i], dp[i - 1] + nums[i]);
            res = Math.max(dp[i], res);
        }
        return res;
    }

    /**
     * 动态规划
     */
    public int maxSubArray2(int[] nums) {
        int n = nums.length;
        // 第一个元素前面没有子数组
        int pre = nums[0];
        int res = pre;
        // 状态转移方程
        for (int i = 1; i < n; i++) {
            pre = Math.max(nums[i], pre + nums[i]);
            res = Math.max(pre, res);
        }
        return res;
    }

• 55. 跳跃游戏

class Solution {
  /**
     * 动态规划-贪心算法
     */
    public boolean canJump(int[] nums) {
        int n = nums.length;
        int fathest = 0;
        for (int i = 0; i < n -1; i++) {
            // 不断计算能跳到的最远距离
            fathest = Math.max(i + nums[i], fathest);
            // 可能碰到了 0，卡住跳不动了
            if (fathest <= i) {
                return false;
            }
        }
        return fathest >= n - 1;
    }
}

• 56. 合并区间

class Solution {
    public int[][] merge(int[][] intervals) {
        int n = intervals.length;
        // / 按区间的 start 升序排列 (x, y) -> x[0] - y[0]
        Arrays.sort(intervals, Comparator.comparingInt(x -> x[0]));
        LinkedList<int[]> res = new LinkedList<>();
        res.add(intervals[0]);
        for (int i = 1; i < n; i++) {
            int[] curr = intervals[i];
            // res 中最后一个元素的引用
            int[] last = res.getLast();
            if (curr[0] <= last[1]) {
                last[1] = Math.max(last[1], curr[1]);
            } else {
                // 处理下一个待合并区间
                res.add(curr);
            }
        }
        return res.toArray(new int[0][0]);
    }
}

• 62. 不同路径

 /**
     * 动态规划
     * -------------------
     * A 1 1 1 ...
     * 1 2 3 4 ...
     * 1 3 6 10 ..
     * ------------------
     * a(1,1) = a(0,1) + a(1,0)
     * ...
     * a(i,j) = a(i-1,j) + a(i,j-1)
     */
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }

• 64. 最小路径和

  /**
     * 动态规划
     * dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1]) + grid[i][j]
     */
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        // 第一行
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0] + grid[i][0];
        }
        // 第一列
        for (int i = 1; i < n; i++) {
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }

• 70. 爬楼梯

  /**
     * 动态规划
     * f(i) = f(i-1) + f(i-2)
     */
    public int climbStairs(int n) {
        if (n < 2) return n;
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n - 1];
    }

• 72. 编辑距离

暂时不写