[Function add]

1. Add some leetcode solutions.

Author: Seanforfun

leetcode/127. Word Ladder.md

@@ -0,0 +1,83 @@
+## 127. Word Ladder
+### Thinking:
+* Method1:
+	* 通过递归实现， 无法AC
+
+```Java
+class Solution {
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        if(wordList == null || wordList.size() == 0) return 0;
+        int len = wordList.size();
+        boolean[] used = new boolean[len];
+        List<Integer> result = new ArrayList<>();
+        change(beginWord, endWord, wordList, used, result, 1);
+        if(result.size() == 0) return 0;
+        int min = Integer.MAX_VALUE;
+        for(int i = 0; i < result.size(); i++)
+            min = Math.min(min, result.get(i));
+        return min;
+    }
+    public static void change(String current, String endWord, List<String> wordList, boolean[] used, List<Integer> result, int step){
+        if(current.equals(endWord)){
+            result.add(step);
+        }else{
+            int len = wordList.size();
+            for(int i = 0; i < len; i++){
+                if(used[i]) continue;
+                String temp = wordList.get(i);
+                if(valid(current, temp)){
+                    used[i] = true;
+                    change(temp, endWord, wordList, used, result, step + 1);
+                    used[i] = false;
+                }
+            }
+        }
+    }
+    private static boolean valid(String s, String t){
+        int len = s.length();
+        int temp = 0;
+        for(int i = 0; i < len; i++){
+            if(s.charAt(i) != t.charAt(i))
+                temp++;
+            if(temp == 2) return false;
+        }
+        return true;
+    }
+}
+```
+
+* Method 2
+	* 考虑使用BFS，仍然无法AC
+
+```Java
+class Solution {
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        LinkedList<String> q = new LinkedList<>();
+        if(!wordList.contains(endWord)) return 0;
+        q.add(beginWord);
+        int count = 0;
+        while(!q.isEmpty()){
+            count++;
+            for(int i = 0; i < q.size(); i++){
+                String current = q.poll();
+                if(current.equals(endWord)) return count;
+                char[] arr = current.toCharArray();
+                for(int j = 0; j < arr.length; j++){
+                    for(char a = 'a'; a <= 'z'; a++){
+                        char tempChar = arr[j];
+                        if(a == tempChar) continue;
+                        arr[j] = a;
+                        String temp = String.valueOf(arr);
+                        if(wordList.contains(temp)){
+                            q.add(temp);
+                            wordList.remove(temp);
+                        }
+                        arr[j] = tempChar;
+                    }
+                }
+            }
+        }
+        return 0;
+    }
+}
+```

leetcode/130. Surrounded Regions.md

@@ -0,0 +1,50 @@
+## 130. Surrounded Regions
+### Thinking:
+* Method1:
+	* 只有与最外圈的O相连接的结点无法被转换。
+	* 如果最外层为O，我们通过BFS，不断获取与之相邻的O结点。
+
+```Java
+class Solution {
+    public void solve(char[][] board) {
+        if(board == null || board.length <= 2 || board[0].length <= 2) return;
+        int height = board.length;
+        int width = board[0].length;
+        //row
+        for(int i = 0; i < width; i++){
+            if(board[0][i] == 'O')
+                fill(board, 0, i);
+            if(board[height - 1][i] == 'O')
+                fill(board, height - 1, i);
+        }
+        //col
+        for(int i = 0; i < height; i++){
+            if(board[i][0] == 'O')
+                fill(board, i, 0);
+            if(board[i][width - 1] == 'O')
+                fill(board, i, width - 1);
+        }
+        for(int i = 0; i < height; i++){
+            for(int j = 0; j < width; j++){
+                if(board[i][j] == 'O') board[i][j] = 'X';
+                else if(board[i][j] == '#') board[i][j] = 'O';
+            }
+        }
+    }
+    private static void fill(char[][] board, int row, int col){
+        LinkedList<Integer> q = new LinkedList<>();
+        int width = board[0].length;
+        board[row][col] = '#';
+        q.add(row * width + col);
+        while(!q.isEmpty()){
+            Integer n = q.poll();
+            int x = n / width;
+            int y = n % width;
+            if(x > 0) if(board[x - 1][y] == 'O'){board[x - 1][y] = '#'; q.add((x - 1) * width + y);}
+            if(y > 0) if(board[x][y - 1] == 'O'){board[x][y - 1] = '#'; q.add(x * width + y - 1);}
+            if(x < board.length - 1) if(board[x + 1][y] == 'O'){board[x + 1][y] = '#'; q.add((x + 1) * width + y);}
+            if(y < board[0].length - 1) if(board[x][y + 1] == 'O'){board[x][y + 1] = '#'; q.add(x * width + y + 1);}
+        }
+    }
+}
+```

leetcode/131. Palindrome Partitioning.md

@@ -0,0 +1,41 @@
+## 131. Palindrome Partitioning
+### Thinking:
+* Method1:
+	* 通过递归实现。
+	* 扫描每一位可能并通过回溯，当index的长度和字符串的长度一致时添加进入结果。
+
+```Java
+class Solution {
+    public List<List<String>> partition(String s) {
+        List<List<String>> result = new ArrayList<>();
+        if(s == null || s.length() == 0) return result;
+        backtrace(s, result, new ArrayList<String>(), 0);
+        return result;
+    }
+    public static void backtrace(String s, List<List<String>> result, List<String> list, int index){ //index: end position
+        if(index == s.length()) result.add(new ArrayList<String>(list));
+        else{
+            for(int i = index + 1; i <= s.length(); i++){
+                String sub = s.substring(index, i);
+                if(isPalindrome(sub)){
+                    list.add(sub);
+                    backtrace(s, result, list, i);
+                    list.remove(list.size() - 1);
+                }
+            }
+        }
+    }
+    private static boolean isPalindrome(String s){
+        int len = s.length();
+        if(len == 0 || len == 1) return true;
+        int half = len / 2;
+        int low = -1, high = len;
+        while(++low < len && --high >= 0 && low <= high){
+            char c1 = s.charAt(low);
+            char c2 = s.charAt(high);
+            if(c1 != c2) return false;
+        }
+        return true;
+    }
+}
+```

leetcode/134. Gas Station.md

@@ -0,0 +1,55 @@
+## 134. Gas Station
+### Thinking:
+* Method1:慢
+	* 关于入口要找到gas大于cost。
+
+```Java
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int len = gas.length;
+        for(int i = 0; i < len; i++){
+            if(cost[i] <= gas[i]){
+                if(valid(gas, cost, i))
+                    return i;
+            }
+        }
+        return -1;
+    }
+    private static boolean valid(int[] gas, int[] cost, int start){
+        int remain = 0;
+        int temp = start;
+        for(; start < gas.length; start++){
+            remain += (gas[start] - cost[start]);
+            if(remain < 0) return false;
+        }
+        for(start = 0; start < temp; start++){
+            remain += (gas[start] - cost[start]);
+            if(remain < 0) return false;
+        }
+        return true;
+    }
+}
+```
+
+* Method2:
+
+```Java
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int len = gas.length;
+        int sum = 0; 
+        int total = 0;
+        int index = 0;
+        for(int i = 0; i < len; i++){
+            sum += gas[i] - cost[i];
+            if(sum < 0){
+                total += sum;
+                sum = 0;
+                index = i+1;
+            }
+        }
+        total += sum;
+        return (total >= 0) ? index : -1;
+    }
+}
+```

leetcode/138. Copy List with Random Pointer.md

@@ -0,0 +1,40 @@
+## 138. Copy List with Random Pointer
+### Thinking:
+* Method1:
+
+```Java
+/**
+ * Definition for singly-linked list with a random pointer.
+ * class RandomListNode {
+ *     int label;
+ *     RandomListNode next, random;
+ *     RandomListNode(int x) { this.label = x; }
+ * };
+ */
+public class Solution {
+    public RandomListNode copyRandomList(RandomListNode head) {
+        RandomListNode cur = head;
+        RandomListNode dummy = new RandomListNode(-1);
+        RandomListNode dummyCur = dummy;
+        Map<Integer, RandomListNode> m = new HashMap<>();
+        while(cur != null){
+            dummyCur.next = new RandomListNode(cur.label);
+            m.put(cur.label, dummyCur.next);
+            dummyCur = dummyCur.next;
+            cur = cur.next;
+        }
+        dummyCur.next = null;
+        cur = head;
+        dummyCur = dummy.next;
+        while(cur != null){
+            if(cur.random == null)
+                dummyCur.random = null;
+            else
+                dummyCur.random = m.get(cur.random.label);
+            dummyCur = dummyCur.next;
+            cur = cur.next;
+        }
+        return dummy.next;
+    }
+}
+```