[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

Diff for: leetcode/140. Word Break II.md

@@ -216,4 +216,33 @@ class Solution {
 			return map.get(s);
 		}
 	}
+	```
+
+### Amazon session
+* Method 1: dp + recursion(bottom to top)
+	```Java
+	class Solution {
+		private Map<String, List<String>> map = new HashMap<>();	// memory
+		public List<String> wordBreak(String s, List<String> wordDict) {
+			if(map.containsKey(s)) return map.get(s);
+			else if(s.equals("")){	// break point
+				List<String> temp = new ArrayList<>();
+				temp.add("");
+				map.put("", temp);
+				return temp;
+			}else{
+				List<String> result = new ArrayList<>();
+				for(String word: wordDict){
+					if(s.startsWith(word)){
+						List<String> res = wordBreak(s.substring(word.length()), wordDict);	// Get result from sub question
+						for(String ss : res){
+							result.add(word + (ss.length() == 0 ? "": " ") + ss);
+						}
+					}
+				}
+				map.put(s, result);
+				return result;
+			}
+		}
+	}
 	```

Diff for: leetcode/53. Maximum Subarray.md

@@ -125,4 +125,22 @@ class Solution {
 			return res;
 		}
 	}
+	```
+
+### Amazon Session
+* Method 1: dp
+	```Java
+	class Solution {
+		public int maxSubArray(int[] nums) {
+			if(nums == null || nums.length == 0) return 0;
+			int[] dp = new int[nums.length];
+			dp[0] = nums[0];
+			int max = nums[0];
+			for(int i = 1; i < nums.length; i++){
+				dp[i] = Math.max(nums[i] + dp[i - 1], nums[i]);
+				max = Math.max(max, dp[i]);
+			}
+			return max;
+		}
+	}
 	```

Diff for: leetcode/64. Minimum Path Sum.md

@@ -88,3 +88,28 @@ class Solution {
 		}
 	}
 	```
+
+### Amazon session
+* Method 1: dp
+	```Java
+	class Solution {
+		public int minPathSum(int[][] grid) {
+			if(grid == null || grid.length == 0 || grid[0].length == 0) return 0;
+			int height = grid.length, width = grid[0].length;
+			int[][] dp = new int[height][width];
+			dp[0][0] = grid[0][0];
+			for(int i = 1; i < height; i++){
+				dp[i][0] = grid[i][0] + dp[i - 1][0];
+			}
+			for(int i = 1; i < width; i++){
+				dp[0][i] = grid[0][i] + dp[0][i - 1];
+			}
+			for(int i = 1; i < height; i++){
+				for(int j = 1; j < width; j++){
+					dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+				}
+			}
+			return dp[height - 1][width - 1];
+		}
+	}
+	```

Diff for: leetcode/773. Sliding Puzzle.md

@@ -90,4 +90,54 @@ Note:
             return new String(arr);
         }
     }
+	```
+
+### Amazon session
+* Method 1:BFS
+	```Java
+	class Solution {
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+		public int slidingPuzzle(int[][] board) {
+			String target = "123450";
+			StringBuilder sb = new StringBuilder();
+			for(int[] bb: board)
+				for(int b: bb)
+					sb.append(b);
+			if(sb.toString().equals(target)) return 0;
+			Set<String> visited = new HashSet<>();
+			visited.add(sb.toString());
+			Queue<String> q = new LinkedList<>();
+			q.offer(sb.toString());
+			int step = 0;
+			while(!q.isEmpty()){
+				int size = q.size();
+				for(int sz = 0; sz < size; sz++){
+					String cur = q.poll();
+					int index = cur.indexOf("0");
+					int x = index / 3, y = index % 3;
+					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 < 2 && ty >= 0 && ty < 3){
+							String next = swap(cur, index, tx * 3 + ty);
+							if(visited.contains(next)) continue;
+							if(next.equals(target)) return step + 1;
+							visited.add(next);
+							q.offer(next);
+						}
+					}
+				}
+				step++;
+			}
+			return -1;
+		}
+		private String swap(String cur, int a, int b){
+			char[] arr = cur.toCharArray();
+			char temp = arr[a];
+			arr[a] = arr[b];
+			arr[b] = temp;
+			return new String(arr);
+		}
+	}
 	```