[Function add]

Seanforfun · Seanforfun · commit fdb0087b522d · 2019-06-13T16:00:09.000-04:00
1. Add leetcode solutions with amazon tag.
diff --git a/leetcode/45. Jump Game II.md b/leetcode/45. Jump Game II.md
@@ -58,4 +58,33 @@ class Solution {
         return result;
     }
 }
-```
+```
+
+### Amazon Session
+* Method 1: Greedy
+	```Java
+	class Solution {
+		public int jump(int[] nums) {
+			//[2,3,1,1,4]
+			if(nums.length <= 1) return 0;
+			if(nums[0] >= nums.length - 1) return 1;
+			int res = 1, cur = 0, max = 0;
+			while(max < nums.length - 1){
+				int nextCur = 0;
+				int nextMax = 0;
+				max = cur + nums[cur];
+				for(int i = cur + 1; i <= max && i < nums.length; i++){                
+					if(i + nums[i] > nextMax){
+						nextCur = i;
+						nextMax = i + nums[i];
+					}
+				}
+				cur = nextCur;
+				max = nextMax;
+				if(max >= nums.length - 1) return res + 1;
+				res++;   
+			}
+			return res;
+		}
+	}
+	```
diff --git a/leetcode/79. Word Search.md b/leetcode/79. Word Search.md
@@ -215,3 +215,45 @@ class Solution {
       }
   }
   ```
+
+### Amazon Session
+* Method 1: dfs
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		private char[][] board;
+		private int height, width;
+		private String word;
+		public boolean exist(char[][] board, String word) {
+			if(board == null || board.length == 0 || board[0].length == 0) return false;
+			this.board = board;
+			this.height = board.length;
+			this.width = board[0].length;
+			this.word = word;
+			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, visited, 0)) return true;
+					}
+				}
+			}
+			return false;
+		}
+		private boolean dfs(int x, int y, Set<Integer> visited, int index){
+			if(index == word.length() - 1) return true;
+			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 + 1)){
+					visited.add(tx * width + ty);
+					if(dfs(tx, ty, visited, index + 1)) return true;
+					visited.remove(tx * width + ty);
+				}
+			}
+			return false;
+		}
+	}
+	```
diff --git a/leetcode/992. subarrays with k different integers.md b/leetcode/992. subarrays with k different integers.md
@@ -0,0 +1,62 @@
+## 992. Subarrays with K Different Integers
+
+### Question
+Given an array A of positive integers, call a (contiguous, not necessarily distinct) subarray of A good if the number of different integers in that subarray is exactly K.
+
+(For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.)
+
+Return the number of good subarrays of A.
+
+```
+Example 1:
+
+Input: A = [1,2,1,2,3], K = 2
+Output: 7
+Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2].
+
+Example 2:
+
+Input: A = [1,2,1,3,4], K = 3
+Output: 3
+Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
+```
+
+Note:
+1. 1 <= A.length <= 20000
+2. 1 <= A[i] <= A.length
+3. 1 <= K <= A.length
+
+### Thinking:
+* Method1: 
+    1. atMost(A, K), number of subarrays with at most K elements in A.
+    2. atMost(A, K) - atMost(A, K - 1): sub-array with exactly K elements.
+    ```Java
+	class Solution {
+        public int subarraysWithKDistinct(int[] A, int K) {
+            return atMost(A, K) - atMost(A, K - 1);
+        }
+        private int atMost(int[] A, int k){
+            Map<Integer, Integer> map = new HashMap<>();
+            int slow = 0, fast = 0;
+            int res = 0;
+            while(fast < A.length){
+                if(!map.containsKey(A[fast])) k--;
+                map.put(A[fast], map.getOrDefault(A[fast], 0) + 1);
+                while(k < 0){
+                    int cur = map.get(A[slow]);
+                    if(cur == 1){
+                        map.remove(A[slow]);
+                        k++;
+                    }else map.put(A[slow], cur - 1);
+                    slow++;
+                }
+                res += fast - slow + 1;
+                ++fast;
+            }
+            return res;
+        }
+    }
+    ```
+
+### Reference
+1. [[Java/C++/Python] Sliding Window with Video](https://leetcode.com/problems/subarrays-with-k-different-integers/discuss/234482/JavaC++Python-Sliding-Window-with-Video)
