// class Solution {
// public boolean isAnagram(String s, String t) {
// if (s.length() != t.length()) return false;
// char[] c1 = s.toCharArray();
// char[] c2 = t.toCharArray();
// Arrays.sort(c1);
// Arrays.sort(c2);
// return Arrays.equals(c1, c2);
// }
// }
class Solution {
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) return false;
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
map.put(ch, map.getOrDefault(ch, 0) + 1);
}
for (int i = 0; i < t.length(); i++) {
char ch = t.charAt(i);
map.put(ch, map.getOrDefault(ch, 0) - 1);
if (map.get(ch) < 0) return false;
}
return true;
}
}
// class Solution {
// public boolean isAnagram(String s, String t) {
// if (s.length() != t.length()) {
// return false;
// }
// int[] table = new int[26];
// for (int i = 0; i < s.length(); i++) {
// table[s.charAt(i) - 'a']++;
// }
// for (int i = 0; i < t.length(); i++) {
// table[t.charAt(i) - 'a']--;
// if (table[t.charAt(i) - 'a'] < 0) {
// return false;
// }
// }
// return true;
// }
// }
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
Map<Character, Integer> map = new HashMap<>();
int n1 = magazine.length();
for (int i = 0; i < n1; i++) {
char c = magazine.charAt(i);
map.put(c, map.getOrDefault(c, 0) + 1);
}
int n2 = ransomNote.length();
for (int i = 0; i < n2; i++) {
char c = ransomNote.charAt(i);
map.put(c, map.getOrDefault(c, 0) - 1);
if (map.get(c) < 0) return false;
}
return true;
}
}
class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
Map<String, List<String>> map = new HashMap<>();
for (String str : strs) {
char[] ch = str.toCharArray();
Arrays.sort(ch);
//传char数组可以得到字符串
String key = new String(ch);
List<String> list = map.getOrDefault(key, new ArrayList<String>());
list.add(str);
map.put(key, list);
}
List<List<String>> res = new ArrayList<>();
//hash表遍历
for (Map.Entry<String, List<String>> x : map.entrySet()) {
res.add(x.getValue());
}
return res;
//return new ArrayList<List<String>>(map.values());
}
}
//滑动窗口+数组
class Solution {
public List<Integer> findAnagrams(String s, String p) {
int sLen = s.length();
int pLen = p.length();
List<Integer> res = new ArrayList<>();
if (sLen < pLen) return res;
int[] sCount = new int[26];
int[] pCount = new int[26];
for (int i = 0; i < pLen; i++) {
sCount[s.charAt(i) - 'a']++;
pCount[p.charAt(i) - 'a']++;
}
if (Arrays.equals(sCount, pCount)) {
res.add(0);
}
//这个sLen - pLen 想清楚,避免了数组越界异常
for (int i = 0; i < sLen - pLen; i++) {
sCount[s.charAt(i) - 'a']--;
sCount[s.charAt(i + pLen) - 'a']++;
if (Arrays.equals(sCount, pCount)) {
res.add(i + 1);
}
}
return res;
}
}
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
//用TreeSet和HashSet一样,只不过,TreeSet大小自动排序
Set<Integer> set = new HashSet<>();
for (int i = 0; i < nums1.length; i++) {
int num = nums1[i];
set.add(num);
}
//int[] res = new int[nums2.length];
//List<Integer> list = new ArrayList<>();
Set<Integer> set1 = new HashSet<>();
for (int i = 0; i < nums2.length; i++) {
int num = nums2[i];
if (set.contains(num)) {
set1.add(num);
}
}
int[] res = new int[set1.size()];
int index = 0;
//int自动类型转换
for (int x : set1) {
//执行完后在++
res[index++] = x;
}
return res;
}
}
//哈希表
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
if (nums1.length > nums2.length) {
return intersect(nums2, nums1);
}
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int num : nums1) {
int count = map.getOrDefault(num, 0) + 1;
map.put(num, count);
}
int[] intersection = new int[nums1.length];
int index = 0;
for (int num : nums2) {
int count = map.getOrDefault(num, 0);
if (count > 0) {
intersection[index++] = num;
count--;
if (count > 0) {
map.put(num, count);
} else {
map.remove(num);
}
}
}
return Arrays.copyOfRange(intersection, 0, index);
}
}
//排序+双指针
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
Arrays.sort(nums1);
Arrays.sort(nums2);
int length1 = nums1.length, length2 = nums2.length;
int[] intersection = new int[Math.min(length1, length2)];
int index1 = 0, index2 = 0, index = 0;
while (index1 < length1 && index2 < length2) {
if (nums1[index1] < nums2[index2]) {
index1++;
} else if (nums1[index1] > nums2[index2]) {
index2++;
} else {
intersection[index] = nums1[index1];
index1++;
index2++;
index++;
}
}
return Arrays.copyOfRange(intersection, 0, index);
}
}
class Solution {
private int getNext(int n) {
int sum = 0;
while (n > 0) {
int qm = n % 10;
n = n / 10;
sum = sum + qm * qm;
}
return sum;
}
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
while (n != 1 && !set.contains(n)) {
set.add(n);
n = getNext(n);
}
return n == 1;
}
}
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int a = nums[i];
if (map.containsKey(target - a)) {
return new int[]{map.get(target - a), i};
}
map.put(a, i);
}
return new int[0];
}
}
//n个数之和都可以分成两数之和,一个意思
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> count12 = new HashMap<>();
int n = nums1.length;
for (int i = 0; i < n; i++) {
int a = nums1[i];
for (int j = 0; j < n; j++) {
int b = nums2[j];
count12.put((a + b), count12.getOrDefault((a + b), 0) + 1);
}
}
int res = 0;
for (int i = 0; i < n; i++) {
int a = nums3[i];
for (int j = 0; j < n; j++) {
int b = nums4[j];
if (count12.containsKey(0 - a - b)) {
res = res + count12.get(0 - a - b);
}
}
}
return res;
}
}
//排序+双指针
//将其中一个数字固定,然后循环查找其他另外两个数字
//会涉及到去重的操作,其中包括固定的数字重复、其他另外两个数字的重复,也是通过循环的方式。
//好的,开始写。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
//首先就是如果,传入的数组是空或者数组的长度小于3,那么直接返回空集合。
List<List<Integer>> res = new ArrayList<>();
//将数组的长度单独写出来,我看基本都是这么操作的,应该会比较方便
int len = nums.length;
if (nums == null || len < 3) return res;
//排序
Arrays.sort(nums);
//后面留2个数字才够3个,其实减不减无所谓,不影响多少
for (int i = 0; i < len - 2; i++) {
//在这边先判断一下,如果第一个就大于0的话,那么就不存在和为0
//这里你想了一下,那么最后的数字小于0的话呢,这样是不行的,因为本来就是从第一个数字开始判断
//只不过是顺带刚好判断了一个第一个数字大于0的情况
if (nums[0] > 0) return res;
//指定固定数字的去重,从第二个数字开始
//用短路与的方式,两侧有一个条件不满足就撤退,嘿嘿
if (i > 0 && nums[i] == nums[i - 1]) continue;
//定义指定位置两侧的左右数字
int left = i + 1;
int right = len - 1;
//双指针循环指定while
while (left < right) {
int sum = nums[left] + nums[i] + nums[right];
if (sum == 0) {
//将此时的数字加入到list集合
res.add(Arrays.asList(nums[left], nums[i], nums[right]));
//一般循环之内的循环直接带上外部条件就行。
while (left < right && nums[left] == nums[left + 1]) left++;
while (left < right && nums[right] == nums[right - 1]) right--;
//同时左佳佳右渐渐了,因为刚好等于0,去重后,一个不动,一个动肯定不行的
left++;
right--;
} else if(sum < 0) {
//合小于0,那么就要么加大左边值,要么减小右边值,这里是左
left++;
} else if(sum > 0) {
right--;
}
}
}
return res;
}
}