字母异位词分组
给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
示例:
输入:
["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
说明：
- 所有输入均为小写字母。
- 不考虑答案输出的顺序。
方法一：排序数组分类
维护一个映射，key为字符串中字符的最小字典序，value为排列不同的字符串
public List> groupAnagrams(String[] strs) {
Map> map = new HashMap<>();
for (String s : strs) {
char[] chars = s.toCharArray();
Arrays.sort(chars);
if (!map.containsKey(String.valueOf(chars))) {
map.put(String.valueOf(chars), new ArrayList<>());
}
map.get(String.valueOf(chars)).add(s);
}
return new ArrayList<>(map.values());
}
时间复杂度：O(NKlogK)，其中 N 是 strs 的长度，而 K 是 strs 中字符串的最大长度
方法二：按计数分类
根据每个字符串中字母出现的次数构造字符串，作为key
public List> groupAnagrams(String[] strs) {
Map> map = new HashMap<>();
for (String s : strs) {
int[] counts = new int[26];
char[] chars = s.toCharArray();
for (char c : chars) {
counts[c - 'a']++;
}
StringBuilder sb = new StringBuilder();
for (int count : counts) {
sb.append("#").append(count).append("#");
}
String key = sb.toString();
if (!map.containsKey(key)) {
map.put(key, new ArrayList<>());
}
map.get(key).add(s);
}
return new ArrayList<>(map.values());
}
时间复杂度O(NK)
找到字符串中所有字母异位词
给定一个字符串 s和一个非空字符串 p，找到 s中所有是 p的字母异位词的子串，返回这些子串的起始索引。
字符串只包含小写英文字母，并且字符串 s和 p的长度都不超过 20100。
说明：
- 字母异位词指字母相同，但排列不同的字符串。
- 不考虑答案输出的顺序。
示例 1:
输入:s: "cbaebabacd" p: "abc"
输出:[0, 6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。
示例 2:
输入:s: "abab" p: "ab"
输出:[0, 1, 2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词
方法一：暴力（超时）
依次判断s中所有长度和p的长度相同的子串和p是否是异位词
public List findAnagrams(String s, String p) {
List ans = new ArrayList<>();
int len = p.length();
char[] pChars = p.toCharArray();
Arrays.sort(pChars);
for (int i = 0; i <= s.length() - len; i++) {
char[] temp = new char[len];
for (int j = 0; j < len; j++) {
temp[j] = s.charAt(i + j);
}
Arrays.sort(temp);
if (Arrays.toString(temp).equals(Arrays.toString(pChars))) {
ans.add(i);
}
}
return ans;
}
用计数法可以通过
public List findAnagrams(String s, String p) {
List res = new ArrayList<>();
int[] pCount = new int[26];
for (int i = 0; i < p.length(); i++) {
pCount[p.charAt(i) - 'a']++;
}
for (int i = 0; i <= s.length() - p.length(); i++) {
String subStr = s.substring(i, i + p.length());
int[] subCount = new int[26];
for (int j = 0; j < subStr.length(); j++) {
subCount[subStr.charAt(j) - 'a']++;
}
boolean isEqual = true;
for (int j = 0; j < 26; j++) {
if (pCount[j] != subCount[j]) {
isEqual = false;
break;
}
}
if (isEqual) {
res.add(i);
}
}
return res;
}
方法二：滑动窗口
先用一个map存在p中字母存在的次数，再用一个map存滑动窗口中字母存在的次数
滑动窗口指针i,j，每次j向右移动，更新j对应字母出现的次数，如果比p中map的大，i指针向右移动，直到不比map大，i在移动过程中也要更新次数，如果窗口大小和p的长度相等，说明找到了一个满足条件的值
public List findAnagrams(String s, String p) {
List ans = new ArrayList<>();
int[] map = new int[26];
for (int i = 0; i < p.length(); i++) {
map[p.charAt(i) - 'a']++;
}
int i = 0, j = 0;
int[] sMap = new int[26];
while (j < s.length()) {
int cur = s.charAt(j) - 'a';
sMap[cur]++;
j++;
while (sMap[cur] > map[cur]) {
sMap[s.charAt(i) - 'a']--;
i++;
}
if (j - i == p.length()) {
ans.add(i);
}
}
return ans;
}
有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t中每个字符出现的次数都相同，则称 s 和 t互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
int[] smap = new int[26];
int[] tmap = new int[26];
for (int i = 0; i < s.length(); i++) {
smap[s.charAt(i) - 'a']++;
}
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
if (smap[c - 'a'] <= tmap[c - 'a']) {
return false;
}
tmap[c - 'a']++;
}
return true;
}
只统计一个字符串：
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
int[] smap = new int[26];
for (int i = 0; i < s.length(); i++) {
smap[s.charAt(i) - 'a']++;
}
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
if (smap[c - 'a'] == 0) {
return false;
}
smap[c - 'a']--;
}
return true;
}
赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。
示例 1：
输入：ransomNote = "a", magazine = "b"
输出：false
示例 2：
输入：ransomNote = "aa", magazine = "ab"
输出：false
示例 3：
输入：ransomNote = "aa", magazine = "aab"
输出：true
public boolean canConstruct(String ransomNote, String magazine) {
int[] map = new int[26];
for (int i = 0; i < ransomNote.length(); i++) {
map[ransomNote.charAt(i) - 'a']++;
}
int distance = ransomNote.length();
for (int i = 0; i < magazine.length(); i++) {
char c = magazine.charAt(i);
if (map[c - 'a'] > 0) {
map[c - 'a']--;
distance--;
}
if (distance == 0) {
return true;
}
}
return false;
}
最小覆盖子串
给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
说明：
- 如果 S 中不存这样的子串，则返回空字符串
""。 - 如果 S 中存在这样的子串，我们保证它是唯一的答案。
方法一：暴力（超时）
枚举s所有的子串，统计字符的频数看是否符合条件
public String minWindow(String s, String t) {
String ans = "";
int minLen = s.length();
int[] tMap = new int[128];
for (int i = 0; i < t.length(); i++) {
tMap[t.charAt(i)]++;
}
for (int start = 0; start <= s.length() - t.length(); start++) {
for (int end = start + t.length() - 1; end < s.length(); end++) {
if (end - start + 1 > minLen) {//优化，区间比找到的长度更长就不用考虑了
break;
}
int[] sMap = new int[128];
for (int i = start; i <= end; i++) {
sMap[s.charAt(i)]++;
}
boolean flag = true;
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
if (sMap[c] < tMap[c]) {
flag = false;
break;
}
}
if (flag) {
ans = s.substring(start, end + 1);
minLen = end - start + 1;
break;//小优化，不用往右边找了
}
}
}
return ans;
}
时间复杂度O(s3+t)
小优化：直接在循环中统计频数
public String minWindow(String s, String t) {
String ans = "";
int minLen = s.length();
int[] tMap = new int[128];
for (int i = 0; i < t.length(); i++) {
tMap[t.charAt(i)]++;
}
for (int start = 0; start <= s.length() - t.length(); start++) {
int[] sMap = new int[128];
int end = start + t.length() - 1;
for (int i = start; i < end; i++) {
sMap[s.charAt(i)]++;
}
for (end = start + t.length() - 1; end < s.length(); end++) {
if (end - start + 1 > minLen) {//优化，区间比找到的长度更长就不用考虑了
break;
}
sMap[s.charAt(end)]++;
boolean flag = true;
for (int i = 0; i < t.length(); i++) {
char c = t.charAt(i);
if (sMap[c] < tMap[c]) {
flag = false;
break;
}
}
if (flag) {
ans = s.substring(start, end + 1);
minLen = end - start + 1;
break;//小优化，不用往右边找了
}
}
}
return ans;
}
方法二：滑动窗口
滑动窗口中的都是满足条件的，移动左边界找到最小的子串
public String minWindow(String s, String t) {
String ans = "";
int minLen = s.length();
int[] tMap = new int[128];
int[] sMap = new int[128];
for (int i = 0; i < t.length(); i++) {
tMap[t.charAt(i)]++;
}
int left = 0;
int right = 0;
int distance = 0;//滑动窗口中包含t中字符的个数，不重复计算
while (right < s.length()) {
char rightChar = s.charAt(right);
if (tMap[rightChar] == 0) {//这个判断其实可以删掉
right++;
continue;
}
if (sMap[rightChar] < tMap[rightChar]) {
distance++;
}
sMap[rightChar]++;
right++;
while (distance == t.length()) {//滑动窗口包含了t中所有字符，移动左边界
if (right - left <= minLen) {
minLen = right - left;
ans = s.substring(left, right);
}
char leftChar = s.charAt(left);
if (tMap[leftChar] == 0) {//这个判断其实可以删掉
left++;
continue;
}
if (sMap[leftChar] == tMap[leftChar]) {
distance--;
}
sMap[leftChar]--;
left++;
}
}
return ans;
}
时间复杂度O(s+t)：右边界s，最坏情况下左边界s-t
不用存s的频数
public String minWindow(String s, String t) {
String ans = "";
int minLen = s.length();
int[] tMap = new int[128];
for (int i = 0; i < t.length(); i++) {
tMap[t.charAt(i)]++;
}
int left = 0;
int right = 0;
int distance = t.length();//滑动窗口中包含还差t中字符的个数
while (right < s.length()) {
char rightChar = s.charAt(right);
if (tMap[rightChar] > 0) {
distance--;
}
tMap[rightChar]--;
right++;
while (distance == 0) {//滑动窗口包含了t中所有字符，移动左边界
if (right - left <= minLen) {
minLen = right - left;
ans = s.substring(left, right);
}
char leftChar = s.charAt(left);
if (tMap[leftChar] == 0) {
distance++;
}
tMap[leftChar]++;
left++;
}
}
return ans;
}