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;
}