[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

leetcode/121. Best Time to Buy and Sell Stock.md

@@ -139,3 +139,22 @@ class Solution {
       }
   }
   ```
+
+### Fifth Time
+* Method 1:
+	1. Find previous min price(means we buy at that day).
+	2. Update current max profit.
+	3. Update min buy time.
+	```Java
+	class Solution {
+		public int maxProfit(int[] prices) {
+			if(prices == null || prices.length == 0) return 0;
+			int profit = 0, min = prices[0];
+			for(int i = 1; i < prices.length; i++){
+				profit = Math.max(profit, prices[i] - min);
+				min = Math.min(min, prices[i]);
+			}
+			return profit;
+		}
+	}
+	```

leetcode/17. Letter Combinations of a Phone Number.md

@@ -91,3 +91,28 @@ class Solution {
     }
 }
 ```
+
+### Fourth Time
+* Method 1: dfs
+	```Java
+	class Solution {
+		private static final String[] vals = new String[]{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+		private List<String> result;
+		public List<String> letterCombinations(String digits) {
+			this.result = new ArrayList<>();
+			if(digits.length() == 0) return this.result;
+			dfs(digits, 0, "");
+			return result;
+		}
+		private void dfs(String digits, int cur, String temp){
+			if(cur == digits.length()){
+				result.add(temp);
+			}else{
+				int num = digits.charAt(cur) - '0';
+				for(char c : vals[num].toCharArray()){
+					dfs(digits, cur + 1, temp + c);
+				}
+			}
+		}
+	}
+	```

leetcode/253. Meeting Rooms II.md

@@ -9,7 +9,67 @@ return 2.
 
 ### Thinking:
 * Method 1:
+    1. Sort the intervals according to the starting time.
+    2. Use a minHeap(pq) to save the endTime for all intervals according to the order of start time.
+        * Add end time to the pq.
+        * if cur start time < pq.peek() => means current start time is before first ending time, which means we must have a new room.
+        * if cur start time >= pq.peek() => means we can use this room for the meeting, we poll out the the original period and add current period to the pq(Means we update the room with the new meeting).
+    ```Java
+    class Solution {
+        public int minMeetingRooms(int[][] intervals) {
+            if(intervals == null || intervals.length == 0) return 0;
+            Arrays.sort(intervals, new Comparator<int[]>(){
+                @Override
+                public int compare(int[] a, int[] b){
+                    return a[0] - b[0];
+                }
+            });
+            PriorityQueue<Integer> pq = new PriorityQueue<>();
+            int room = 0;
+            for(int i = 0; i < intervals.length; i++){
+                pq.offer(intervals[i][1]);
+                if(intervals[i][0] < pq.peek())  room++;
+                else{
+                    pq.poll();
+                }
+            }
+            return room;
+        }
+    }
+    ```
 
-```Java
-To be add
-```
+* Method 2: Two pointer + sort
+    * we sort start time and end time.
+    * initialize the start and end index as 0.
+    * if start time < end time, means we have a meeting in active, active++.
+    * else active--.
+    * We need to record the max number of the active room.
+    ```Java
+    class Solution {
+        public int minMeetingRooms(int[][] intervals) {
+            int len = intervals.length;
+            int[] startTime = new int[len];
+            int[] endTime = new int[len];
+            int index = 0;
+            for(int[] interval: intervals){
+                startTime[index] = interval[0];
+                endTime[index++] = interval[1];
+            }
+            Arrays.sort(startTime);
+            Arrays.sort(endTime);
+            int i = 0, j = 0;
+            int activate = 0, max = 0;
+            while(i < len && j < len){
+                if(startTime[i] < endTime[j]){
+                    activate++;
+                    i++;
+                }else{
+                    activate--;
+                    j++;
+                }
+                max = Math.max(max, activate);
+            }
+            return max;
+        }
+    }
+    ```

leetcode/53. Maximum Subarray.md

@@ -107,3 +107,22 @@ class Solution {
       }
   }
   ```
+
+### Fourth Time
+* Method 1: dp
+	```Java
+	class Solution {
+		public int maxSubArray(int[] nums) {
+			if(nums == null || nums.length == 0) return 0;
+			int len = nums.length;
+			int res = Integer.MIN_VALUE;
+			int[] dp = new int[len + 1];
+			dp[0] = 0;
+			for(int i = 1; i <= len; i++){
+				dp[i] = Math.max(nums[i - 1], dp[i - 1] + nums[i - 1]);
+				res = Math.max(res, dp[i]);
+			}
+			return res;
+		}
+	}
+	```

leetcode/70. Climbing Stairs.md

@@ -98,4 +98,20 @@ class Solution {
 			return dp[n];
 		}
 	}
+	```
+
+### Fourth Time
+* Method 1: dp
+	```Java
+	class Solution {
+		public int climbStairs(int n) {
+			int[] dp = new int[n + 1];
+			dp[0] = 1;
+			for(int i = 1; i <= n; i++){
+				dp[i] = dp[i - 1];
+				dp[i] += (i - 2 >= 0) ? dp[i - 2]: 0;
+			}
+			return dp[n];
+		}
+	}
 	```