[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

Diff for: leetcode/212. Word Search II.md

@@ -198,3 +198,54 @@ class Solution {
     }
 }
 ```
+
+### Amazon session
+* Method 1: dfs
+	```Java
+	class Solution {
+		private char[][] board;
+		private int height, width;
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		public List<String> findWords(char[][] board, String[] words) {
+			List<String> result = new ArrayList<>();
+			if(board == null || board.length == 0 || board[0].length == 0) return result;
+			this.board = board;
+			this.height = board.length;
+			this.width = board[0].length;
+			LABEL:
+			for(String word: words){
+				for(int i = 0; i < height; i++){
+					for(int j = 0; j < width; j++){
+						if(word.charAt(0) == board[i][j]){
+							Set<Integer> visited = new HashSet<>();
+							visited.add(i * width + j);
+							if(dfs(i, j, word, 1, visited)){
+								result.add(word);
+								continue LABEL;
+							}
+						}
+					}
+				}
+			}
+			return result;
+		}
+		private boolean dfs(int x, int y, String word, int index, Set<Integer> visited){
+			if(index == word.length()) return true;
+			else if(index < word.length()){
+				int tx = 0, ty = 0;
+				for(int d = 0; d < 4; d++){
+					tx = x + dir[d][0];
+					ty = y + dir[d][1];
+					if(tx >= 0 && tx < height && ty >= 0 && ty < width
+					  && !visited.contains(tx * width + ty)
+					  && board[tx][ty] == word.charAt(index)){
+						visited.add(tx * width + ty);
+						if(dfs(tx, ty, word, index + 1, visited)) return true;
+						visited.remove(tx * width + ty);
+					}
+				}
+			}
+			return false;
+		}
+	}
+	```

Diff for: leetcode/269. Alien Dictionary.md

@@ -94,4 +94,51 @@ Note:
             return result.toString();
         }
     }
-   ```
+   ```
+
+### Amazon session
+* Method 1: Topological sort
+	```Java
+	class Solution {
+		public String alienOrder(String[] words) {
+			Map<Character, Integer> indegree = new HashMap<>(); // key: letter, value: its indegree
+			Map<Character, Set<Character>> map = new HashMap<>(); // key: request, value: its childrens
+			for(String word: words){
+				for(char c : word.toCharArray()){
+					indegree.put(c, 0);
+				}
+			}
+			for(int i = 1; i < words.length; i++){
+				int minLen = Math.min(words[i].length(), words[i - 1].length());
+				char[] arr1 = words[i - 1].toCharArray(), arr2 = words[i].toCharArray();
+				for(int j = 0; j < minLen; j++){
+					if(arr1[j] != arr2[j]){ //arr1[j] is ahead of arr2[j]
+						Set<Character> set = map.getOrDefault(arr1[j], new HashSet<>());
+						if(!set.contains(arr2[j])) indegree.put(arr2[j], indegree.get(arr2[j]) + 1);
+						set.add(arr2[j]);
+						map.put(arr1[j], set);
+						break;
+					}
+				}
+			}
+			Queue<Character> q = new LinkedList<>();
+			for(Map.Entry<Character, Integer> entry: indegree.entrySet()){
+				if(entry.getValue() == 0){
+					q.offer(entry.getKey());
+				}
+			}
+			StringBuilder sb = new StringBuilder();
+			while(!q.isEmpty()){
+				char cur = q.poll();
+				sb.append(cur);
+				if(!map.containsKey(cur)) continue; // current character doesn't have neighbour.
+				Set<Character> neighbours = map.get(cur);
+				for(char c : neighbours){
+					indegree.put(c, indegree.get(c) - 1);
+					if(indegree.get(c) == 0) q.offer(c);
+				}
+			}
+			return sb.length() == indegree.size() ? sb.toString(): "";
+		}
+	}
+	```

Diff for: leetcode/472. Concatenated Words.md

@@ -62,4 +62,42 @@ Note:
 			return dp[len];
 		}
 	}
+	```
+
+### Amazon session
+* Method 1: DP + Set
+	```Java
+	class Solution {
+		private Set<String> set;
+		public List<String> findAllConcatenatedWordsInADict(String[] words) {
+			List<String> result = new ArrayList<>();
+			if(words == null || words.length <= 1) return result;
+			Arrays.sort(words, (a, b)->{
+				return a.length() - b.length();
+			});
+			this.set = new HashSet<>();
+			set.add(words[0]);
+			for(int i = 1; i < words.length; i++){
+				if(dfs(words[i])) result.add(words[i]);
+				set.add(words[i]);
+			}
+			return result;
+		}
+		private boolean dfs(String cur){
+			if(set.isEmpty()) return false;
+			int len = cur.length();
+			boolean[] dp = new boolean[len + 1];
+			dp[0] = true;
+			for(int end = 1; end <= len; end++){
+				for(int start = 0; start < end; start++){
+					String sub = cur.substring(start, end);
+					if(set.contains(sub)){
+						dp[end] |= dp[start];
+					}
+					if(dp[end]) break;
+				}
+			}
+			return dp[len];
+		}
+	}
 	```

Diff for: leetcode/895. Maximum Frequency Stack.md

@@ -87,6 +87,45 @@ Note:
 	 */
 	```
 
+### Amazon Session
+* Method 1: two maps + deque
+	* Fix some bugs in first try, since all frequencies are countinuous, we don't have to use while loop to find next maxCount.
+	```Java
+	class FreqStack {
+		private int maxCount;
+		private Map<Integer, Integer> countMap;
+		private Map<Integer, Deque<Integer>> freqMap;
+		public FreqStack() {
+			this.countMap = new HashMap<>();
+			this.freqMap = new HashMap<>();
+		}
+		
+		public void push(int x) {
+			countMap.put(x, countMap.getOrDefault(x, 0) + 1);
+			int freq = countMap.get(x);
+			maxCount = Math.max(maxCount, freq);
+			Deque<Integer> deque = freqMap.getOrDefault(freq, new ArrayDeque<>());
+			deque.push(x);
+			freqMap.put(freq, deque);
+		}
+		
+		public int pop() {
+			int res = freqMap.get(maxCount).pop();
+			countMap.put(res, countMap.get(res) - 1);
+			if(freqMap.get(maxCount).size() == 0){
+				freqMap.remove(maxCount);
+				maxCount--;
+			}
+			return res;
+		}
+	}
 
+	/**
+	 * Your FreqStack object will be instantiated and called as such:
+	 * FreqStack obj = new FreqStack();
+	 * obj.push(x);
+	 * int param_2 = obj.pop();
+	 */
+	```
 ### Reference
 1. [Java - intuition and thought process](https://leetcode.com/problems/maximum-frequency-stack/discuss/289916/Java-intuition-and-thought-process)