[Function add]

1. Add leetcode solutions with amazon tag.

Author: Seanforfun

leetcode/124. Binary Tree Maximum Path Sum.md

@@ -86,4 +86,33 @@ class Solution {
 			return Math.max(node.val, Math.max(node.val + left, node.val + right));
 		}
 	}
+	```
+
+### Amazon Session
+* Method 1: dfs + traversal 2 childs and return one
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private int result = Integer.MIN_VALUE;
+		public int maxPathSum(TreeNode root) {
+			dfs(root);
+			return this.result;
+		}
+		private int dfs(TreeNode root){
+			if(root == null) return 0;
+			int left = Math.max(dfs(root.left), 0);
+			int right = Math.max(dfs(root.right), 0);
+			int res = Math.max(root.val, left + right + root.val);
+			this.result = Math.max(result, res);
+			return Math.max(Math.max(left, right) + root.val, root.val);
+		}
+	}
 	```

leetcode/347. Top K Frequent Elements.md

@@ -17,29 +17,63 @@ Output: [1]
 
 ### Thinking:
 * Method 1:
+	```Java
+	class Solution {
+		public List<Integer> topKFrequent(int[] nums, int k) {
+			Map<Integer, Integer> map = new HashMap<>();
+			List<Integer> res = new ArrayList<>();
+			for(int num : nums){
+				map.put(num, map.containsKey(num)?map.get(num) + 1: 1);
+			}
+			Set<Map.Entry<Integer, Integer>> set = map.entrySet();
+			PriorityQueue<Map.Entry<Integer, Integer>> pq = new PriorityQueue<>(new Comparator<Map.Entry<Integer, Integer>>(){
+				@Override
+				public int compare(Map.Entry<Integer, Integer> n1, Map.Entry<Integer, Integer> n2){
+					return n2.getValue() - n1.getValue();
+				}
+			});
+			for(Map.Entry<Integer, Integer> entry: set){
+				pq.offer(entry);
+			}
+			for(int i = 0; i < k; i++){
+				res.add(pq.poll().getKey());
+			}
+			return res;
+		}
+	}
+	```
 
-```Java
-class Solution {
-    public List<Integer> topKFrequent(int[] nums, int k) {
-        Map<Integer, Integer> map = new HashMap<>();
-        List<Integer> res = new ArrayList<>();
-        for(int num : nums){
-            map.put(num, map.containsKey(num)?map.get(num) + 1: 1);
-        }
-        Set<Map.Entry<Integer, Integer>> set = map.entrySet();
-        PriorityQueue<Map.Entry<Integer, Integer>> pq = new PriorityQueue<>(new Comparator<Map.Entry<Integer, Integer>>(){
-            @Override
-            public int compare(Map.Entry<Integer, Integer> n1, Map.Entry<Integer, Integer> n2){
-                return n2.getValue() - n1.getValue();
-            }
-        });
-        for(Map.Entry<Integer, Integer> entry: set){
-            pq.offer(entry);
-        }
-        for(int i = 0; i < k; i++){
-            res.add(pq.poll().getKey());
-        }
-        return res;
-    }
-}
-```
+* Method 2: bucket sort
+	1. Take the appearance freq for each number.
+	2. Do another index count to according to their appearance.
+	3. From the end to begin, add k values to result.
+	```Java
+	class Solution {
+		public List<Integer> topKFrequent(int[] nums, int k) {
+			List<Integer> result = new ArrayList<>();
+			if(nums == null || nums.length == 0) return result;
+			Map<Integer, Integer> map = new HashMap<>();
+			int max = 1, freqMax = 0;
+			for(int n : nums){
+				max = Math.max(max, n);
+				map.put(n, map.getOrDefault(n, 0) + 1);
+				freqMax = Math.max(freqMax, map.get(n));
+			}
+			List[] arr = new List[freqMax + 1];
+			for(Map.Entry<Integer, Integer> entry : map.entrySet()){
+				int freq = entry.getValue();
+				if(arr[freq] == null) arr[freq] = new ArrayList<>();
+				arr[freq].add(entry.getKey());
+			}
+			for(int i = arr.length - 1; i >= 0 && k > 0; i--){
+				if(arr[i] == null) continue;
+				result.addAll(arr[i]);
+				k -= arr[i].size();
+			}
+			return result;
+		}
+	}
+	```
+
+### Reference
+1. [Java O(n) solution using Buckets](https://leetcode.com/problems/top-k-frequent-elements/discuss/306454/Java-O(n)-solution-using-Buckets)

leetcode/4. Median of Two Sorted Arrays.md

@@ -134,4 +134,68 @@ class Solution {
 			return (c1 + c2) * 0.5;
 		}
 	}
-	```
+	```
+
+### Amazon Session
+* Method 1: Merge and find medium
+	```Java
+	class Solution {
+		public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+			int[] arr = new int[nums1.length + nums2.length];
+			int index1 = 0, index2 = 0, index = 0;
+			while(index1 < nums1.length && index2 < nums2.length){
+				if(nums1[index1] <= nums2[index2]){
+					arr[index++] = nums1[index1++];
+				}else{
+					arr[index++] = nums2[index2++];
+				}
+			}
+			if(index1 == nums1.length){ // nums1 reached the end, need to append nums2
+				for(; index < nums1.length + nums2.length; index++){
+					arr[index] = nums2[index2++];
+				}
+			}else{
+				for(; index < nums1.length + nums2.length; index++){
+					arr[index] = nums1[index1++];
+				}
+			}        
+			return arr.length % 2 == 1 ? (double)arr[arr.length/2]:
+				(double)(arr[arr.length / 2] + arr[arr.length / 2 - 1]) / 2;
+		}
+	}
+	```
+
+* Method 2: Binary search
+    ![Imgur](https://i.imgur.com/wU6ojSC.png)
+    1. Medium value is created by C1 and C2.
+    2. There are totally K = (len1 + len2 + 1) / 2 will be selected to create the left side of the merged array.
+    3. We use m1 numbers from nums1 and m2 values from nums2, k = m1 + m2.
+    4. The constraint for binary search is nums1[m1 - 1] <= nums2[m2 - 1].
+    5. If total number of values are even, result is (Ck + Ck-1) / 2 else Ck-1.
+    ```Java
+    class Solution {
+        public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+            int len1 = nums1.length, len2 = nums2.length;
+            if(len2 < len1) return findMedianSortedArrays(nums2, nums1);
+            int k = (len1 + len2 + 1) / 2;
+            int l = 0, r = len1, m1 = 0;
+            while(l < r){
+                m1 = l + (r - l) / 2;
+                int m2 = k - m1;
+                if(nums1[m1] < nums2[m2 - 1]) l = m1 + 1;
+                else r = m1;
+            }
+            m1 = l;
+            int c1 = Math.max(m1 <= 0 ? Integer.MIN_VALUE: nums1[m1 - 1],
+                              k - m1 <= 0 ? Integer.MIN_VALUE: nums2[k - m1 - 1]);
+            if((len1 + len2) % 2 == 1)
+                return (double)c1;
+            int c2 = Math.min(m1 >= len1 ? Integer.MAX_VALUE: nums1[m1], 
+                              k - m1 >= len2 ? Integer.MAX_VALUE: nums2[k - m1]);
+            return (double)(c1 + c2) / 2;
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 4. Median of Two Sorted Arrays](https://zxi.mytechroad.com/blog/algorithms/binary-search/leetcode-4-median-of-two-sorted-arrays/)

leetcode/490. The Maze.md

@@ -166,4 +166,48 @@ private static boolean searchBFS(int[][] maze, int[] start, int[] des, boolean[]
 			return new int[]{tx - dir[d][0], ty - dir[d][1]};
 		}
 	}
+	```
+
+### 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[][] maze;
+		private int height, width;
+		private int[] destination;
+		private Set<Integer> visited;
+		public boolean hasPath(int[][] maze, int[] start, int[] destination) {
+			this.maze = maze;
+			this.height = maze.length;
+			this.width = maze[0].length;
+			this.destination = destination;
+			this.visited = new HashSet<>();
+			if(start[0] == destination[0] && start[1] == destination[1]) return true;
+			visited.add(start[0] * width + start[1]);
+			for(int i = 0; i < 4; i++)
+				if(dfs(start[0], start[1], i)) return true;
+			return false;
+		}
+		private boolean dfs(int x, int y, int pre){
+			if(x == destination[0] && y == destination[1]) return true;
+			int tx = 0, ty = 0;
+			for(int d = 0; d < 4; d++){
+				if(d + pre == 3) continue;
+				tx = x + dir[d][0]; 
+				ty = y + dir[d][1];
+				while(tx >= 0 && tx < height && ty >= 0 && ty < width && maze[tx][ty] == 0){
+					tx += dir[d][0];
+					ty += dir[d][1];
+				}
+				tx -= dir[d][0];
+				ty -= dir[d][1];
+				if(!visited.contains(tx * width + ty)){
+					visited.add(tx * width + ty);
+					if(dfs(tx, ty, d)) return true;
+				}
+			}
+			return false;
+		}
+	}
 	```