lecture-9-hashmap

1、Two pointers
2、If return the two numbers, then HashSet will be enough
3、HashMap is needed to keep the mapping from
number to index

 1 public int[] twoSum(int[] nums, int targer) {
 2     HashMap<Integer, Integer> map = new HashMap<>();
 3     for (int i = 0; i < nums.length; i++) {
 4         map.put(nums[i], i);//key:num[i], value:i
 5     }
 6     int[] result = new int[2];
 7     for (int i = 0; i < nums.length; i++) {
 8         int complement = target - nums[i];
 9         if (map.containsKey(complement) && map.get(complement) != i) {
10             return new int[] {i, map.get(complement)};
11         }
12     }
13     return result;
14 }
15 
16 public int[] twoSum(int[] nums, int targer) {
17     HashMap<Integer, Integer> map = new HashMap<>();
18     for (int i = 0; i < nums.length; i++) {
19         map.put(nums[i], i);//key:num[i], value:i
20     }
21     int[] result = new int[2];
22     for (int i = 0; i < nums.length; i++) {
23         int complement = target - nums[i];
24         if (map.containsKey(complement) && map.get(complement) != i) {
25             result[0] = i;
26             result[1] = map.get(complement);
27             break;
28         }
29     }
30     return result;
31 }

 1 public int[] twoSum(int[] nums, int target) {
 2     HashMap<Integer, Integer> map = new HashMap<>();
 4     for (int i = 0; i < nums.length; i++) {
 5         int complement = target - nums[i];
 6         if (map.containsKey(complement && map.get(complement) != i)) {
 7             return new int[] {i, map.get(complement)};
 8         }
 9         map.put(nums[i], i);//假设result = {1,8}，在找到1时，8还没有放进去，但是找到8时，1在hashmap里面，就找到了
10     }
11     return null;
12 }

Keep a 1:1 mapping relationship
HashMap is A->B, so two HashMaps are needed for
A <-> B

 1 public boolean wordPattern(String pattern, String str) {
 2     HashMap<Character, String> map = new HaspMap<>();
 3     HashMap<String, Character> map_reverse = new HashMap<>();
 4     String[] words = str.split(" ");
 5     if (pattern.length() != words.length) {//length()
 6         return false;
 7     }
 8     for (int i = 0; i < pattern.length(); i++) {
 9         char a = pattern.chatAt(i);
10         String b = words[i];
11         if (!map.containsKey(a)) {
12             map.put(a, b);
13         } else if (！map.get(a).equals(b)) {
14             return false;
15         }
16 
17         if (!map_reverse.containsKey(b)) {
18             map_reverse.put(b, a);
19         } else if (!map_reverse.get(b) != a) {//a is base type, can not use equals
20             return false;
21         }
22     }
23     return true;
24 }

Keep a 1:1 mapping relationship
HashMap is A->B, so two HashMaps are needed for A <-> B
Keep two A->B mappings at the same time
pattern -> index
string -> index

 1 public boolean worPattern(String pattern, String str) {
 2     HashMap<Character, Integer> mapPattern = new HashMap<>();
 3     HashMap<String, Integer> mapStr = new HashMap<>();
 4     String[] words = str.spilt(" ");
 5     if (patterh.length() != words.length) {
 6         return false;
 7     }
 8     for (int i = 0; i < pattern.length(); i++) {
 9         int indexP = -1;
10         int indexS = -1;
11         Character a = pattern.charAt(i);
12         String b = word[i];
13         if (mapPattern.containsKey(a)) {
14             indexP = mapPattern.get(a);
15         } else {
16             mapPattern.put(a, i);
17         }
18 
19         if (mapStr.containsKey(b)) {
20             indexS = mapStr.get(b);
21         } else {
22             mapStr.put(b, i);
23         }
24         if (indexP != indexS) {
25             return false;
26         }
27     }
28     return true;
29 }

 1 public boolean wordPattern(String pattern, String str) {
 2     Map<Character, Integer> mappingPattern = new HashMap<>();
 3     Map<String, Integer> mappingStr = new HashMap<>();
 4     String[] words = str.split(" ");
 5     if (pattern.length() != words.length) {
 6         return false;
 7     }
 8     for (int i = 0; i < pattern.length(); i++) {
 9         if (!Objects.equals(mappingPattern.put(pattern.charAt(i), i),
10             mappingStr.put(words[i], i))) {
11             return false;
12         }
13     }
14     return true;
15 }

 1 public ArrayList<String> anagrams(String[] strs) {
 2     HashMap<String, ArrayList<String>> mapping = new HashMap<>();
 3     for (String str : strs) {
 4         char[] array = str.toCharArray();
 5         Arrays.sort(array);
 6         String newStr = new String(array);//排序后生成一个新字符串，作为key
 7         if (!mapping.containsKey(newStr)) {
 8             ArrayList<String> strList = new ArrayList<>();
 9             strList.add(str);
10             mapping.put(array, strList);
11         } else {
12             mapping.get(newStr).add(str);
13         }
14     }
15     ArrayList<String> result = new ArrayList<>();
16     for (String str : mapping.keySet() {18         result.addAll(mapping.get(str));20     }
21     return result;
22 }