心得技巧：
- 数据范围小，可以使用数组模拟哈希
- 想清楚什么作为哈希的 Key 很重要
- 有些题看似需要两个哈希表，实际上可以用一个解决
有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
输入: s = "anagram", t = "nagaram"
输出: true
数组模拟哈希：
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) return false;
int[] map = new int[128];
for (char c : s.toCharArray()) map[c]++;
for (char c : t.toCharArray())
if (--map[c] < 0) return false;
for (int i : map) if (i != 0) return false;
return true;
}
排序：
public boolean isAnagram(String s, String t) {
char[] cs1 = s.toCharArray();
char[] cs2 = t.toCharArray();
Arrays.sort(cs1);
Arrays.sort(cs2);
return String.valueOf(cs1).equals(String.valueOf(cs2));
}
赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
输入：ransomNote = "a", magazine = "b"
输出：false
数组模拟哈希：
public boolean canConstruct(String s1, String s2) {
int[] map = new int[123]; // s2 中字符出现的次数
for (char c : s2.toCharArray()) map[c]++;
for (char c : s1.toCharArray()) if (--map[c] < 0) return false;
return true;
}
字母异位词分组*
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
两个字母异位词进行排序后，结果是相同的。
public List<List<String>> groupAnagrams(String[] strs) {
Map<String, List<String>> map = new HashMap<>();
for (String s : strs) {
// 对字符数组进行排序, 排序后的字符串作为哈希表的 key
char[] cs = s.toCharArray();
Arrays.sort(cs);
String key = String.valueOf(cs);
System.out.println(key);
if (!map.containsKey(key)) map.put(key, new ArrayList<>());
map.get(key).add(s);
}
return new ArrayList<>(map.values());
}
找到字符串中所有字母异位词
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
双指针 + 数组模拟哈希：类似 [[01_数组#最小覆盖子串]]
public List<Integer> findAnagrams(String s, String p) {
List<Integer> res = new ArrayList<>();
int[] map = new int[123];
for (char c : p.toCharArray()) map[c]++; // map[c] < 0 表示满足需求
int cnt = 0; // cnt == p.length() 表示满足需求
for (int l = 0, r = 0; r < s.length(); r++) {
if (map[s.charAt(r)]-- > 0) cnt++;
while (l < r && map[s.charAt(l)] < 0) map[s.charAt(l++)]++;
if (r - l + 1 == cnt && cnt == p.length())
res.add(l);
}
return res;
}
两个数组的交集
给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
public int[] intersection(int[] nums1, int[] nums2) {
int[] map = new int[1001];
List<Integer> list = new ArrayList<>();
for (int n : nums1) map[n]++;
for (int n : nums2) {
if (map[n] != 0) {
list.add(n);
map[n] = 0; // *
}
}
int[] res = new int[list.size()];
for (int i = 0; i < res.length; i++)
res[i] = list.get(i);
return res;
}
两个数组的交集II
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
int[] map = new int[1001];
for (int n : nums1) map[n]++;
List<Integer> list = new ArrayList<>();
for (int n : nums2) {
if (map[n] != 0) {
list.add(n);
map[n]--; // *
}
}
int[] res = new int[list.size()];
for (int i = 0; i < res.length; i++)
res[i] = list.get(i);
return res;
}
}
快乐数
题目：快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1，那么这个数就是快乐数。
如果n是 快乐数 就返回true；不是，则返回false。
输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
class Solution {
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
while (n != 1) {
n = squareSum(n);
if (set.contains(n)) return false;
set.add(n);
}
return true;
}
int squareSum(int n) {
int sum = 0;
while (n != 0) {
sum += Math.pow(n % 10, 2);
n /= 10;
}
return sum;
}
}
两数之和
题目：1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
if (map.containsKey(target - nums[i]))
return new int[] {
i, map.get(target - nums[i]) };
map.put(nums[i], i);
}
return new int[] {
};
}
四数相加 II
题目：454. 四数相加 II
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < nnums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
将 n1 + n2 视为哈希的 key：
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map = new HashMap<>();
int count = 0;
for (int n1 : nums1)
for (int n2 : nums2)
map.put(n1 + n2, map.getOrDefault(n1 + n2, 0) + 1);
for (int n3 : nums3)
for (int n4 : nums4)
if (map.containsKey(-n3 - n4))
count += map.get(-n3 - n4);
return count;
}
三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
注意结合排序来去重：
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
int n = nums.length;
Arrays.sort(nums); // 排序
for (int i = 0; i < n; i++) {
if (nums[i] > 0) break;
if (i > 0 && nums[i] == nums[i - 1]) continue; // 去重
int l = i + 1, r = n - 1;
while (l < r) {
if (nums[l] + nums[r] < -nums[i]) l++;
else if (nums[l] + nums[r] > -nums[i]) r--;
else {
res.add(Arrays.asList(nums[i], nums[l], nums[r]));
while (l < r && nums[l] == nums[l + 1]) l++; // 去重
while (l < r && nums[r] == nums[r - 1]) r--; // 去重
l++;
r--;
}
}
}
return res;
}
四数之和
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < na、b、c和d互不相同nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> res = new ArrayList<>();
int n = nums.length;
Arrays.sort(nums);
for (int i = 0; i < n - 3; i++) {
if (i > 0 && nums[i] == nums[i - 1]) continue; // 去重
// 剪枝: 最小的情况 > target 则不可能满足; 最大的情况 < target 有可能满足
if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) break;
if ((long) nums[i] + nums[n - 3] + nums[n - 2] + nums[n - 1] < target) continue;
for (int j = i + 1; j < n - 2; j++) {
if (j > i + 1 && nums[j] == nums[j - 1]) continue; // 去重
// 剪枝: 最小的情况 > target 则不可能满足; 最大的情况 < target 有可能满足
if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) break;
if ((long) nums[i] + nums[j] + nums[n - 2] + nums[n - 1] < target) continue;
int l = j + 1, r = n - 1;
while (l < r) {
long sum = (long) nums[i] + nums[j] + nums[l] + nums[r]; // 防止溢出
if (sum < target) l++;
else if (sum > target) r--;
else {
res.add(Arrays.asList(nums[i], nums[j], nums[l], nums[r]));
while (l < r && nums[l] == nums[l + 1]) l++; // 去重
while (l < r && nums[r] == nums[r - 1]) r--; // 去重
l++;
r--;
}
}
}
}
return res;
}