[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

Diff for: leetcode/572. Subtree of Another Tree.md

@@ -88,3 +88,33 @@ Return false.
 		}
 	}
 	```
+
+### Amazon session
+* Method 1: recursion
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public boolean isSubtree(TreeNode s, TreeNode t) {
+			if(s != null && t != null){
+				return same(s, t) || isSubtree(s.left, t) || isSubtree(s.right, t);
+			}else if(s == null && t == null) return true;
+			return false;
+		}
+		private boolean same(TreeNode s, TreeNode t){
+			if(s == null && t == null) return true;
+			else if((s == null && t != null) || (s != null && t == null)) return false;
+			else{
+				if(s.val != t.val) return false;
+				return same(s.left, t.left) && same(s.right, t.right);
+			}
+		}
+	}
+	```

Diff for: leetcode/694. Number of Distinct Islands.md

@@ -86,5 +86,99 @@ Note: The length of each dimension in the given grid does not exceed 50.
     }
     ```
 
+### Amazon session
+* Method 1: dfs
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		private static final String[] dStr = new String[]{"r", "l", "d", "u"};
+		private Set<String> set;
+		private int height;
+		private int width;
+		private int[][] grid;
+		public int numDistinctIslands(int[][] grid) {
+			this.set = new HashSet<>();
+			this.grid = grid;
+			this.height = grid.length;
+			this.width = grid[0].length;
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					if(grid[i][j] == 1){
+						StringBuilder sb = new StringBuilder();
+						sb.append("s");
+						grid[i][j] = 0;
+						dfs(sb, i, j);
+						set.add(sb.toString());
+					}
+				}
+			}
+			return set.size();
+		}
+		private void dfs(StringBuilder sb, int x, int y){
+			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 && grid[tx][ty] == 1){
+					grid[tx][ty] = 0;
+					sb.append(dStr[d]);
+					dfs(sb, tx, ty);
+				}
+			}
+			sb.append("b");
+		}
+	}
+	```
+
+* Method 2: bfs
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		private static final String[] dStr = new String[]{"r", "l", "d", "u"};
+		private Set<String> set;
+		private int height;
+		private int width;
+		private int[][] grid;
+		public int numDistinctIslands(int[][] grid) {
+			this.set = new HashSet<>();
+			this.grid = grid;
+			this.height = grid.length;
+			this.width = grid[0].length;
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					if(grid[i][j] == 1){
+						StringBuilder sb = new StringBuilder();
+						sb.append("s");
+						bfs(sb, i, j);
+					}
+				}
+			}
+			return set.size();
+		}
+		private void bfs(StringBuilder sb, int x, int y){
+			Queue<int[]> q = new LinkedList<>();
+			q.offer(new int[]{x, y});
+			grid[x][y] = 0;
+			while(!q.isEmpty()){
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					int[] cur = q.poll();
+					int tx = 0, ty = 0;
+					for(int d = 0; d < 4; d++){
+						tx = cur[0] + dir[d][0];
+						ty = cur[1] + dir[d][1];
+						if(tx >= 0 && tx < height && ty >= 0 && ty < width && grid[tx][ty] == 1){
+							grid[tx][ty] = 0;
+							sb.append(dStr[d]);
+							q.offer(new int[]{tx, ty});
+						}
+					}
+					sb.append("b");
+				}
+			}
+			set.add(sb.toString());
+		}
+	}
+	```
 ### Reference
 1. [Java very Elegant and concise DFS Solution(Beats 100%)](https://leetcode.com/problems/number-of-distinct-islands/discuss/108475/Java-very-Elegant-and-concise-DFS-Solution(Beats-100))

Diff for: leetcode/994. Rotting Oranges.md

@@ -0,0 +1,82 @@
+## 994. Rotting Oranges
+
+### Question
+In a given grid, each cell can have one of three values:
+1. the value 0 representing an empty cell;
+2. the value 1 representing a fresh orange;
+3. the value 2 representing a rotten orange.
+
+Every minute, any fresh orange that is adjacent (4-directionally) to a rotten orange becomes rotten.
+
+Return the minimum number of minutes that must elapse until no cell has a fresh orange.  If this is impossible, return -1 instead.
+
+```
+Example 1:
+
+Input: [[2,1,1],[1,1,0],[0,1,1]]
+Output: 4
+
+Example 2:
+
+Input: [[2,1,1],[0,1,1],[1,0,1]]
+Output: -1
+Explanation:  The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+
+Example 3:
+
+Input: [[0,2]]
+Output: 0
+Explanation:  Since there are already no fresh oranges at minute 0, the answer is just 0.
+```
+ 
+Note:
+1. 1 <= grid.length <= 10
+2. 1 <= grid[0].length <= 10
+3. grid[i][j] is only 0, 1, or 2.
+
+### Solution
+* Method 1: BFS
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		public int orangesRotting(int[][] grid) {
+			int height = grid.length, width = grid[0].length;
+			Queue<int[]> q = new LinkedList<>();
+			int fresh = 0;
+			Set<Integer> visited = new HashSet<>();
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					if(grid[i][j] == 1) fresh++;
+					else if(grid[i][j] == 2){
+						q.offer(new int[]{i, j});
+						visited.add(i * width + j);
+					}
+				}
+			}
+			int step = 0;
+			if(fresh == 0) return 0;
+			while(!q.isEmpty() && fresh != 0){
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					int[] cur = q.poll();
+					int tx = 0, ty = 0;
+					for(int d = 0; d < 4; d++){
+						tx = cur[0] + dir[d][0];
+						ty = cur[1] + dir[d][1];
+						if(tx >= 0 && tx < height && ty >= 0 && ty < width && !visited.contains(tx * width + ty)){
+							visited.add(tx * width + ty);
+							if(grid[tx][ty] == 1){
+								q.offer(new int[]{tx, ty});
+								fresh--;
+							}
+							if(fresh == 0) return step + 1;
+						}
+					}
+				}
+				step++;
+			}
+			return -1;
+		}
+	}
+	```
+