[Function add]

1. Add leetcode solutions with amazon tag.

Author: Seanforfun

leetcode/165. Compare Version Numbers.md

@@ -120,4 +120,32 @@ class Solution {
 			return 0;
 		}
 	}
+	```
+
+### Amazon Session
+* Method 1: String
+	```Java
+	class Solution {
+		public int compareVersion(String version1, String version2) {
+			String[] tokens1 = version1.split("\\.");
+			String[] tokens2 = version2.split("\\.");
+			int index = 0;
+			while(index < tokens1.length || index < tokens2.length){
+				if(index < tokens1.length && index < tokens2.length){
+					int first = Integer.parseInt(tokens1[index]);
+					int second = Integer.parseInt(tokens2[index]);
+					if(first < second) return -1;
+					else if(first > second) return 1;
+				}else if(index < tokens1.length){
+					int first = Integer.parseInt(tokens1[index]);
+					if(first != 0) return 1;
+				}else if(index < tokens2.length){
+					int second = Integer.parseInt(tokens2[index]);
+					if(second != 0) return -1;
+				}
+				index++;
+			}
+			return 0;
+		}
+	}
 	```

leetcode/253. Meeting Rooms II.md

@@ -72,4 +72,30 @@ return 2.
             return max;
         }
     }
-    ```
+    ```
+
+### Amazon Seesion
+* Method 1: Pq + sort
+	```Java
+	class Solution {
+		public int minMeetingRooms(int[][] intervals) {
+			if(intervals.length <= 1) return intervals.length;
+			int result = 1;
+			PriorityQueue<int[]> pq = new PriorityQueue<>((a, b)->{
+				return a[1] - b[1];
+			});
+			Arrays.sort(intervals, (a, b)->{
+				return a[0] != b[0] ? a[0] - b[0]: a[1] - b[1];
+			});
+			pq.offer(intervals[0]);
+			for(int i = 1; i < intervals.length; i++){
+				if(intervals[i][0] >= pq.peek()[1]){
+					pq.poll();
+				}
+				pq.offer(intervals[i]);
+				result = Math.max(result, pq.size());
+			}
+			return result;
+		}
+	}
+	```

leetcode/505. The Maze II.md

@@ -210,5 +210,105 @@ Meanwhile, we need to use some ideas from the shortest path to update the path.
     }
     ```
 
+### Amazon Session
+* Method 1: dfs
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+		private int height, width;
+		private int[][] maze;
+		private int[] destination;
+		private int result;
+		private int[][] dist;
+		public int shortestDistance(int[][] maze, int[] start, int[] destination) {
+			this.height = maze.length;
+			this.width = maze[0].length;
+			this.maze = maze;
+			this.destination = destination;
+			this.result = Integer.MAX_VALUE;
+			this.dist = new int[height][width];
+			for(int[] dd: dist) Arrays.fill(dd, Integer.MAX_VALUE);
+			dist[start[0]][start[1]] = 0;
+			if(start[0] == destination[0] && start[1] == destination[1]) return 0;
+			for(int d = 0; d < 4; d++){
+				dfs(start, 0, d);
+			}
+			return this.result == Integer.MAX_VALUE ? -1: this.result;
+		}
+		private void dfs(int[] cur, int temp, int pre){
+			// cur: current position
+			// temp: current step
+			// pre: previous direction
+			if(cur[0] == this.destination[0] && cur[1] == this.destination[1]){
+				this.result = Math.min(this.result, temp);
+			}else if(dist[cur[0]][cur[1]] < this.result){
+				int tx = 0, ty = 0;
+				for(int d = 0; d < 4; d++){ // 4 directions
+					if(d + pre == 3 || d == pre) continue;
+					int currentStep = temp + 1;
+					tx = cur[0] + dir[d][0];
+					ty = cur[1] + dir[d][1];
+					while(tx >= 0 && tx < height && ty >= 0 && ty < width && maze[tx][ty] != 1){
+						tx += dir[d][0];
+						ty += dir[d][1];
+						currentStep++;
+					}
+					tx -= dir[d][0];
+					ty -= dir[d][1];
+					--currentStep;
+					if(dist[tx][ty] <= currentStep) continue;
+					else{
+						dist[tx][ty] = currentStep;
+						dfs(new int[]{tx, ty}, currentStep, d);
+					}
+				}
+			}
+		}
+	}
+	```
+
+* Method 2: bfs
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		public int shortestDistance(int[][] maze, int[] start, int[] destination) {
+			int height = maze.length, width = maze[0].length;
+			if(start[0] == destination[0] && start[1] == destination[1]) return 0;
+			int[][] dist = new int[height][width];
+			for(int[] dd : dist) Arrays.fill(dd, Integer.MAX_VALUE);
+			dist[start[0]][start[1]] = 0;
+			Queue<int[]> q = new LinkedList<>();
+			q.offer(start);
+			int result = Integer.MAX_VALUE;
+			while(!q.isEmpty()){
+				int[] cur = q.poll();
+				if(cur[0] == destination[0] && cur[1] == destination[1]){
+					result = Math.min(result, dist[cur[0]][cur[1]]);
+					continue;
+				}
+				int tx = 0, ty = 0;
+				for(int d = 0; d < 4; d++){
+					int step = dist[cur[0]][cur[1]] + 1;
+					tx = cur[0] + dir[d][0];
+					ty = cur[1] + dir[d][1];
+					while(tx >= 0 && tx < height && ty >= 0 && ty < width && maze[tx][ty] != 1){
+						tx += dir[d][0];
+						ty += dir[d][1];
+						++step;
+					}
+					--step;
+					tx -= dir[d][0];
+					ty -= dir[d][1];
+					if(tx == cur[0] && ty == cur[1]) continue;
+					if(dist[tx][ty] > step){
+						dist[tx][ty] = step;
+						if(dist[tx][ty] < result)   q.offer(new int[]{tx, ty});
+					}
+				}
+			}
+			return result == Integer.MAX_VALUE ? -1: result;
+		}
+	}
+	```
 ### Reference
 1. [Java 6ms BFS by optimizing solution #2](https://leetcode.com/problems/the-maze-ii/discuss/290079/Java-6ms-BFS-by-optimizing-solution-2)