代码随想录(3)-hash
题单
242.有效的字母异位词
349.两个数组的交集
1.两数之和
454.四数相加 II（middle）
383.赎金信
15.三数之和（middle）
18.四数之和（middle）
242.有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
说明: 你可以假设字符串只包含小写字母。
思路：
使用hashmap保存每个元素的个数
遍历s字符c，h[c]++
遍历t字符c，h[c]--，若小于零则返回false
遍历table，如果有元素个数还大于零，则返回false
返回true
题解的补充：
1、排序法：将字符串字符排序，然后比较字符串
2、hash法，比我的方法更简练：开头判断是否是否相等，可以代替我遍历table的那一步。
public boolean isAnagram(String s, String t) {
if( s.length() != t.length() ){
return false;
}
HashMap<Character, Integer> table = new HashMap<Character, Integer>();
for (int i = 0; i < s.length(); i++) {
Character c = s.charAt(i);
table.put( c, table.getOrDefault(c, 0) + 1);
}for (int i = 0; i < t.length(); i++) {
Character c = t.charAt(i);
table.put( c, table.getOrDefault(c, 0) - 1);
if( table.get(c) < 0){
return false;
}
}
return true;
}
349.两个数组的交集
题意：给定两个数组，编写一个函数来计算它们的交集。
思路：
遍历数组1元素，存入一个集合s
遍历数组2元素，若该元素在集合s中，则将该元素放在新集合ans中。
返回ans。
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integer> set1 = new HashSet<Integer>();
Set<Integer> set2 = new HashSet<Integer>();
for (int num : nums1)
set1.add(num);
for (int num : nums2)
if (set1.contains(num))
set2.add(num);
int[] ans = new int[set2.size()];
int index = 0;
for (int num : set2) {
ans[index++] = num;
}
return ans;
}
202.快乐数
题目：编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
思路：
计算
遍历1-280元素n
计算n，如果是，则放入集合s
计算target各位平方和直到小于280
-- 返回该值是否在s中
-- 如果该数为平方数，则放入
上面有点南辕北辙了
集合s用于存放每次计算的各数和
不断获得各数和
-- 如果等于1，返回true
-- 如果在集合s中，返回false
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
int t = getAllSqure(n);
while(t != 1) {
if( set.contains(t) )
return false;
set.add(t);
t = getAllSqure(t);
}
return true;
}
int getAllSqure(int t ){
int sum = 0;
while ( t > 0 ){
sum += (t%10) * (t%10);
t /= 10;
}
return sum;
}
总结：一开始想的太复杂了，想着预设一个集合，存放小于300的happy数。
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
双层循环法
public int[] twoSum(int[] nums, int target) {
for(int i = 0; i < nums.length; i++){
for(int j = i+1; j < nums.length; j++){
if( nums[i] + nums[j] == target)
return new int[] {i,j};
}
}
return null;
}
单层循环HashMap法
遍历每个元素，查询map是否有差值：
有则返回，
无则加入当前元素值和下标为新的键值对。
454.四数相加 II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。
思路：
暴力解法，提前把第四个数组放入map，三层for循环，遍历前三个数组，然后查看map中是否存在
-key = ( A[i] + B[j] + C[k] )
根据题意，最大循环1.25亿次
题解思路：
首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
最后返回统计值 count 就可以了
代码：
public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
Map<Integer, Integer> map = new HashMap<>();
int result = 0;
int n = A.length;
for(int i = 0; i<n; i++){
for(int j = 0; j<n; j++){
int t = A[i]+B[j];
if( map.containsKey(t) )
map.put( t, map.get( t ) + 1 );
else
map.put( t, 1 );
}
}
for(int k = 0; k<n; k++){
for(int l = 0; l<n; l++){
int t = -C[k]-D[l];
if( map.containsKey(t) )
result += map.get( t );
}
}
return result;
}
总结：将暴力法的四处或者三层大循环，通过map拆成两个二层循环。复杂度从5004或5003，降到500^2（n最大取500）。
383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：你可以假设两个字符串均只含有小写字母。
思路：
将magazine字符串都放入一个map，key为字符，value为个数。遍历ransom每个字符，将对应map[c]减一，如果出现负数则返回false，最后返回true。
代码：
public boolean canConstruct(String ransomNote, String magazine) {
Map<Character,Integer> map = new HashMap<>();
for (char c : magazine.toCharArray()) {
if( map.containsKey(c) ) map.put( c, map.get(c) + 1);
else map.put( c, 1);
}
for (char c : ransomNote.toCharArray()) {
if( map.containsKey(c) && (map.get(c)-1 >= 0) ){
map.put( c, map.get(c) - 1);
}else {
return false;
}
}
return true;
}
总结：不熟悉使用map，好几次拼写错误。
15.三数之和（middle）
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
hash表思路
将元素放入hash表，然后使用双层遍历，遍历map，将差值作为key查询map
如果存在，那么将用列表存下三个数，但是得去重。
下面的代码没错，但超时
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ans = new ArrayList<>();
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < nums.length; i++){
if( map.containsKey( nums[i]) ) map.put(nums[i], map.get(nums[i]) + 1);
else map.put(nums[i],1);
}
for( Map.Entry<Integer,Integer> e1 : map.entrySet() ){
if(e1.getValue() < 1) continue;
int k1 = e1.getKey();
e1.setValue( e1.getValue() -1 );
for( Map.Entry<Integer,Integer> e2 : map.entrySet() ){
if(e2.getValue() < 1) continue;
int k2 = e2.getKey();
e2.setValue( e2.getValue() -1 );
if( map.containsKey( -k1 - k2 ) && map.get( -k1 - k2 ) >= 1){
List<Integer> list = Arrays.asList(k1, k2, -k1-k2);
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer s1, Integer s2) {
return s1 - s2;
}
});
if( ansNotHave(ans, list))
ans.add(list);
}
e2.setValue( e2.getValue() + 1 );
}
e1.setValue( e1.getValue() + 1 );
}
return ans;
}
Boolean ansNotHave(List<List<Integer>> ans, List<Integer>list){
for( List<Integer> t : ans)
if( listEqual(t,list) )
return false;
return true;
}
Boolean listEqual(List<Integer> t, List<Integer> list){
if( t.size() != list.size() )
return false;
for (int i = 0; i < list.size(); i++){
if(t.get(i) != list.get(i) )
return false;
}
return true;
}
双指针法
将元素排好序。
遍历一个元素i，
--初始化元素left=i+1，right=n-1
--当三者相加小于零，left++
--大于0，right--
--等于零，添加三者到答案中，同时legt++和right--
写了三个小时，先hash方法被否定了，后是双指针法中没有考虑等于时两边同时往里靠拢。
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<>();
for(int i = 0; i<nums.length; i++ ){
if( i > 0 && nums[i] == nums[i-1]) continue;
int l = i + 1;
int r = nums.length - 1;
while( l < r){
if(nums[i] + nums[l] + nums[r] == 0){
List<Integer> list = Arrays.asList(nums[i] , nums[l] , nums[r]);
ans.add(list);
while( r > l && nums[r] == nums[r-1]) r--;
while( r > l && nums[l] == nums[l+1]) l++;
r--;
l++;
}
else if(nums[i] + nums[l] + nums[r] > 0) r--;
else l++;
}
}
return ans;
}
18. 四数之和（middle）
题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
注意：
答案中不可以包含重复的四元组。
示例： 给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。 满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
双指针法
思路就是，先遍历a，再遍历b，里面再对c、d使用双指针法。
需要注意abcd下标的，需要合理去除，ab需要判断自己和上一个不同，cd在相等处需要同时移动且不能重复。
有个测试用例，4个100000000相加，超过了int 限制，还以为是逻辑有漏洞，最后发现并不是。
只是需要将相加的等式处理一下，用double封装使结果不要溢出就好了。
public List<List<Integer>> fourSum(int[] nums, int target) {
Arrays.sort( nums );
List<List<Integer>> ans = new ArrayList<>();
for(int a = 0; a < nums.length - 3; a++ ){
if( a > 0 && nums[a] == nums[a-1] ) continue;
for(int b = a + 1; b < nums.length - 2; b++ ){
if( b > a + 1 && nums[b] == nums[b-1] ) continue;
int c = b + 1;
int d = nums.length - 1;
while( c < d ){
double t = 0.0 + nums[a] + nums[b] + nums[c] + nums[d];
if( t < target ){
c++;
}else if( t > target ){
d--;
}else {
List<Integer> list = Arrays.asList(nums[a], nums[b], nums[c], nums[d]);
ans.add(list);
while( d > c && nums[c] == nums[c+1] ) c++;
while( d > c && nums[d] == nums[d-1] ) d--;
c++;
d--;
}
}
}
}
return ans;
}
总结
-
Todo：总结hashMap的使用。
-
更加灵活的使用双指针法。
-
Array类的sort方法可以对nums数组进行排序。
Array可以使用asList方法传入多个参数直接初始化列表。
