算法刷题打卡（八）

44 通配符匹配

44. 通配符匹配 - 力扣（LeetCode） (leetcode-cn.com)

给定一个字符串 (s) 和一个字符模式 § ，实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。

‘?’ 可以匹配任何单个字符。
‘*’ 可以匹配任意字符串（包括空字符串）。
两个字符串完全匹配才算匹配成功。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。
示例 1:

输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
示例 2:

输入:
s = “aa”
p = ""
输出: true
解释: '’ 可以匹配任意字符串。
示例 3:

输入:
s = “cb”
p = “?a”
输出: false
解释: ‘?’ 可以匹配 ‘c’, 但第二个 ‘a’ 无法匹配 ‘b’。
示例 4:

输入:
s = “adceb”
p = “ab”
输出: true
解释: 第一个 ‘’ 可以匹配空字符串, 第二个 '’ 可以匹配字符串 “dce”.
示例 5:

输入:
s = “acdcb”
p = “a*c?b”
输出: false

动态规划，和lettcode 第10题 正则表达式匹配类似

    public boolean isMatch(String s, String p) {
        char[] str = s.toCharArray();
        char[] pattern = p.toCharArray();
        int N = s.length();
        int M = p.length();
        boolean[][] dp = new boolean[N + 1][M + 1];
        dp[N][M] = true;
        for (int i = M - 1; i >= 0; i--) {//N 行
            dp[N][i] = pattern[i] == '*' && dp[N][i + 1];
        }
        //任何一个普遍位置 都依赖 右下角的值   还依赖 右边格子往下 这一列，  右边往下一列
        //从下往上  右往左填
        for (int si = N - 1; si >= 0; si--) {
            for (int pi = M - 1; pi >= 0; pi--) {
                if (pattern[pi] != '?' && pattern[pi] != '*') {
                    dp[si][pi] = str[si] == pattern[pi] && dp[si + 1][pi + 1];
                    continue;
                }
                if (pattern[pi] == '?') {
                    dp[si][pi] = dp[si + 1][pi + 1];
                    continue;
                }
                // p[pi] == '*' 的情况下不需要 si是什么  依赖 当前位置 下边 和右边的  或
                dp[si][pi] = dp[si][pi + 1] || dp[si + 1][pi];
            }
        }
        return dp[0][0];
    }

46 全排列

46. 全排列 - 力扣（LeetCode） (leetcode-cn.com)

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：

输入：nums = [1]
输出：[[1]]

 	 /*  1 2 3   原数组没有重复值
        1位置 123中选1，  2位置 23选2， 3 位置只能3
        1位置 2 ，2位置 13， 3位置剩下的....
     */
	public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        process(nums, 0, ans);
        return ans;
    }

    public static void process(int[] nums, int index, List<List<Integer>> ans) {
        if (index == nums.length) {//到最后 结束了  添加到 ans
            ArrayList<Integer> array = new ArrayList<>();
            for (int num : nums) {
                array.add(num);
            }
            ans.add(array);
        } else {//没结束的时候   就是 i 位置 和 index位置 交换，交换之后的可能走的路线，走完之后 交换回来
            for (int i = index; i < nums.length; i++) {
                swap(nums, index, i);
                process(nums, index + 1, ans);
                swap(nums, i, index);
            }
        }
    }

    public static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }

48 旋转图像

48. 旋转图像 - 力扣（LeetCode） (leetcode-cn.com)

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 3：

输入：matrix = [[1]]
输出：[[1]]
示例 4：

输入：matrix = [[1,2],[3,4]]
输出：[[3,1],[4,2]]

   /*   n*n    顺时针转 90°
    一圈一圈解决， 2圈不能转到 1圈去
    左上角点 -> 这一行的 最后一个位置   -> 这一列的最后一行 -> 最后一行第一列
    在 4*4 里边 ： [0,0] -> [0,3] -> [3,3] -> [3,0] ->[0,0] .....
     最外的一圈 完成之后 往里去完成第二圈....
     */
	public void rotate(int[][] matrix) {
        int start = 0;//开始的 位置，环
        int end = matrix.length - 1;//结束位置，环
        while (start < end) {//因为已经告诉是 正方形
            for (int i = 0; i < end - start; i++) {//找出交换的位置
                int temp = matrix[start][start + i];
                matrix[start][start + i] = matrix[end - i][start];
                matrix[end - i][start] = matrix[end][end - i];
                matrix[end][end - i] = matrix[start + i][end];
                matrix[start + i][end] = temp;
            }
            start++;
            end--;
        }
    }

49 字母异位词分组

49. 字母异位词分组 - 力扣（LeetCode） (leetcode-cn.com)

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母都恰好只用一次。

示例 1:

输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]
示例 2:

输入: strs = [""]
输出: [[""]]
示例 3:

输入: strs = [“a”]
输出: [[“a”]]

    //  排序 ： K （str.sort） V list
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> map = new HashMap<>();
        for (String s : strs) {//每个字符串 转成数组 排序
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String k = String.valueOf(chars);
            if (!map.containsKey(k)) {//如果没有 创建新的
                map.put(k, new ArrayList<String>());
            }
            map.get(k).add(s);
        }
        List<List<String>> res = new ArrayList<>();
        for (List l : map.values()) {//map 的 V 都放到res种
            res.add(l);
        }
        return res;
    }