Merge pull request gzc426#57 from gzc426/master

1

Author: beddingearly

2018.11.19-leetcode15/棕榈树.md

@@ -0,0 +1,30 @@
+```
+class Solution {
+    	 public List<List<Integer>> threeSum(int[] nums) {
+		 	List<List<Integer>> res = new ArrayList<>();
+		 	Arrays.sort(nums);
+		 	for(int i=0;i<nums.length-2;i++){
+		 		int low = i+1;
+		 		int high = nums.length-1;
+		 		int sum = 0 - nums[i];
+		 		if(i==0||(i>0&&nums[i]!=nums[i-1])){		
+		 			while(low<high){
+		 				if(sum==nums[low]+nums[high]){
+		 					res.add(Arrays.asList(nums[i],nums[low],nums[high]));//将结果添加到数组中
+		 					while(low<high&&nums[low]==nums[low+1]) low++;
+		 					while(low<high&&nums[high-1]==nums[high])	high--;
+		 					low++;
+		 					high--;
+		 				}
+		 				else if(nums[low]+nums[high]<sum){
+		 					low++;
+		 				}else{
+		 					high--;
+		 				}
+		 			}
+		 		}
+		 	}
+	        return res;
+	 }
+}
+```

2019.01.05-leetcode127/sourcema.md

@@ -0,0 +1,35 @@
+# LeetCode 127
+    class Solution {
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        Set<String> set = new HashSet<>(wordList);
+        if(!set.contains(endWord)){
+            return 0;
+        }
+        Queue<String> queue=new LinkedList<String>();
+        queue.add(beginWord);
+        int step=1;
+        while(!queue.isEmpty()){
+            int size=queue.size();
+            for (int i = 0; i < size; i++) {
+                String s = queue.poll();
+                for (int k = 0; k < s.length(); k++) {
+                    char[] chars = s.toCharArray();
+                    for (char j = 'a'; j <= 'z'; j++) {
+                        chars[k] = j;
+                        String temp = String.valueOf(chars);
+                        if (set.contains(temp)) {
+                            if (temp.equals(endWord)) {
+                                return step + 1;
+                            }
+                            queue.add(temp);
+                            set.remove(temp);
+                        }
+                    }
+                }
+            }
+            step++;
+        }
+        return 0;
+
+    }
+}

2019.01.06-leetcode695/sourcema.md

@@ -0,0 +1,27 @@
+# LeetCode 695
+    class Solution {
+    public int maxAreaOfIsland(int[][] grid) {
+        if (grid[0].length == 0 || grid.length == 0) {
+            return 0;
+        }
+        int row=grid.length,col=grid[0].length;
+        int max=0;
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (grid[i][j] == 1) {
+                    int count=dfs(grid, i, j);
+                    max = Math.max(max, count);
+                }
+            }
+        }
+        return max;
+    }
+     private  int dfs(int[][] grid, int i, int j) {
+        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) {
+            return 0;
+        }
+        grid[i][j]=0;
+        return 1 + dfs(grid, i - 1, j) + dfs(grid, i + 1, j)
+                + dfs(grid, i, j - 1) + dfs(grid, i, j + 1);
+    }
+}

2019.01.07-leetcode200/sourcema.md

@@ -0,0 +1,53 @@
+# leetcode 200
+    class Solution {
+    static int count=0;
+    static int[] parent;
+    public static int numIslands(char[][] arr) {//并查集解法
+        if (arr.length == 0||arr[0].length == 0 ) {
+            return 0;
+        }
+        int length=arr.length * arr[0].length;
+        int width=arr[0].length;
+        parent = new int[length];
+        for (int i = 0; i < length; i++) {
+            int x=i/width;
+            int y=i%width;
+            if (arr[x][y] - '0' == 1) {
+                count++;
+            }
+            parent[i]=i;
+        }
+        for (int i = 0; i < length; i++) {//为什么考查右边和下方 1 0
+            int x=i/width;                                   //1 1如果不考察下方，右下角的1就无法抵消啦
+            int y=i%width;
+            int down=x+1;
+            int right=y+1;
+            if (right < width && arr[x][y] - '0' == 1 && arr[x][right] - '0' == 1) {
+                union(i, i+1);
+            }
+            if (down < arr.length && arr[x][y] - '0' == 1 && arr[down][y] - '0' == 1) {
+                union(i, i+width);
+            }
+        }
+        return count;
+
+    }
+
+    public static void union(int p,int q) {
+        int rootP = find(p);
+        int rootQ = find(q);
+        if (rootP == rootQ) {
+            return;
+        }
+        parent[rootQ]=rootP;
+        count--;
+    }
+
+    public static int find(int e) {
+        while (parent[e] != e) {
+            parent[e] = parent[parent[e]];//让子节点直接连接父节点
+            e = parent[e];
+        }
+        return e;
+    }
+}

2019.01.08-leetcode547/sourcema.md

@@ -0,0 +1,42 @@
+# leetcode 547
+    class Solution {
+    static int[] parent;
+    static int count;
+
+    public static int findCircleNum(int[][] friends) {
+        if (friends == null || friends.length == 0 || friends[0].length == 0) {
+            return 0;
+        }
+        parent = new int[friends.length];
+        count = friends.length;
+        for (int i = 0; i < friends.length; i++) {
+            parent[i] = i;
+        }
+        for (int i = 0; i < friends.length; i++) {
+            for (int j = i+1; j < friends.length; j++) {
+                if (friends[i][j] == 1) {
+                    union(i, j);
+                }
+            }
+        }
+        return count;
+    }
+
+    public static void union(int p, int q) {
+        int rootP = find(p);
+        int rootQ = find(q);
+        if (rootP == rootQ) {
+            return;
+        }
+        parent[rootQ] = rootP;
+        count--;
+    }
+
+    public static int find(int e) {
+        while (parent[e] != e) {
+            parent[e] = parent[parent[e]];//让子节点直接连接父节点
+            e = parent[e];
+        }
+        return e;
+    }
+}

2019.01.10-leetcode417/sourcema.md

@@ -0,0 +1,44 @@
+# leetcode 417
+    class Solution {
+    private static int[][] d = {{0,1}, {1,0}, {0,-1}, {-1,0}};
+    private static int row;
+    private static int col;
+    public static List<int[]> pacificAtlantic(int[][] matrix) {
+        List<int[]> res = new ArrayList<>();
+        if (matrix == null || matrix.length == 0) {
+            return res;
+        }
+        row=matrix.length;
+        col=matrix[0].length;
+        boolean[][] pacific = new boolean[row][col];
+        boolean[][] atlantic = new boolean[row][col];
+        for (int i = 0; i <row ; i++) {//从左右边界开始判断
+            dfs(matrix, pacific, i, 0);
+            dfs(matrix, atlantic, i, col-1);
+        }
+        for (int i = 0; i <col ; i++) {//从左右边界开始判断
+            dfs(matrix, pacific, 0, i);
+            dfs(matrix, atlantic, row-1, i);
+        }
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (pacific[i][j] && atlantic[i][j]) {
+                    res.add(new int[]{i, j});
+                }
+            }
+        }
+        return res;
+    }
+
+    private static void dfs(int[][] matrix, boolean[][] arr, int x, int y) {
+        arr[x][y]=true;
+        for (int i = 0; i < 4; i++) {
+            int nextX=x+d[i][0];
+            int nextY=y+d[i][1];
+            if (nextX >= 0 && nextX < row && nextY >= 0 && nextY < col && !arr[nextX][nextY]
+                    && matrix[nextX][nextY] >= matrix[x][y]) {
+                dfs(matrix,arr,nextX,nextY);
+            }
+        }
+    }
+}

2019.01.11-leetcode17/sourcema.md

@@ -0,0 +1,26 @@
+# leetcode 17
+    class Solution {
+    
+    static String[] letters = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+    public static List<String> letterCombinations(String digits) {
+        List<String> res = new ArrayList<>();
+        if (digits == null || digits.length() == 0) {
+            return res;
+        }
+        dfs(digits, res, 0, digits.length(), "");
+        return res;
+    }
+
+    private static void dfs(String digits, List<String> res, int index, int length, String ret) {
+        if (index >= length) {
+            res.add(ret);
+            return;
+        }
+        int digit = digits.charAt(index) - '0';
+        for (int i = 0; i <letters[digit].length(); i++) {
+            ret += letters[digit].charAt(i);
+            dfs(digits, res, index + 1, length, ret);
+            ret=ret.substring(0, ret.length() - 1);
+        }
+    }
+}

2019.01.12-leetcode93/sourcema.md

@@ -0,0 +1,30 @@
+# leetcode 93
+    class Solution {
+    public static List<String> restoreIpAddresses(String s) {
+        List<String> res = new ArrayList<>();
+        if (s == null || s.length() == 0||s.length()<4||s.length()>12) {
+            return res;
+        }
+        dfs(s, res, 0, "");
+        return res;
+    }
+
+    private static void dfs(String ip, List<String> res, int index, String ret) {
+        if (index == 3) {
+           if ((ip.length()==1||(ip.length()>1&&ip.length()<4&&ip.charAt(0)!='0'))
+                    &&Integer.valueOf(ip) <= 255) {//Integer.valueOf(ip)防止ip的位数超出int范围 首位不能以0开头
+                res.add(ret+ip);
+            }
+            return;
+        }
+        for (int i = 1; i < 4; i++) {
+            String split = ip.substring(0, i>ip.length()?ip.length():i);//可能出现ip的长度小于i的情况，不够长度去切分
+            if ((split.length()==1||(split.length()>1&&split.charAt(0)!='0'))
+                    &&Integer.valueOf(split) <= 255) {
+                ret = ret + split + ".";
+                dfs(ip.substring(i>ip.length()?ip.length():i),res,index+1,ret);
+                ret = ret.substring(0,ret.length() - split.length() - 1);
+            }
+        }
+    }
+}

2019.01.13-leetcode79/sourcema.md

@@ -0,0 +1,33 @@
+# leetcode 79
+    class Solution {
+    public boolean exist(char[][] board, String word) {
+        if (board[0].length == 0 || board.length == 0) {
+            return false;
+        }
+        int row=board.length,col=board[0].length,count=0;
+        boolean flag=false;
+        go:
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                flag=dfs(board,word,i,j,count);
+                if (flag) {
+                    break go;
+                }
+            }
+        }
+        return flag;
+    }
+    private  boolean dfs(char[][] board, String word,int i, int j, int count) {
+        if (count == word.length()) {
+            return true;
+        }
+        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || word.charAt(count) != board[i][j]) {
+            return false;
+        }
+        board[i][j]^=256;
+        boolean flag=dfs(board,word,i+1,j,count+1)||dfs(board,word,i-1,j,count+1)
+                ||dfs(board,word,i,j+1,count+1)||dfs(board,word,i,j-1,count+1);
+        board[i][j]^=256;
+        return flag;
+    }
+}

2019.01.14-leetcode257/sourcema.md

@@ -0,0 +1,25 @@
+# leetcode 257
+    class Solution {
+        public List<String> binaryTreePaths(TreeNode root) {
+            List<String> list = new ArrayList<>();
+            if (root == null) {
+                return list;
+            }
+            dfs(root, list,new String());
+            return list;
+        }
+        private void dfs(TreeNode root, List<String> list,String ret) {
+            if (root.left==null&&root.right==null) {
+                ret+=root.val;
+                list.add(ret);
+                return;
+            }
+            ret += root.val + "->";
+            if(root.left!=null){
+            dfs(root.left,list,ret);
+            }
+            if(root.right!=null){
+            dfs(root.right,list,ret);
+            }
+        }
+    }

2019.01.14-leetcode257/棕榈树.md

@@ -0,0 +1,32 @@
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> res = new ArrayList<>();
+		if(null!=root){
+			DFS(root,"",res);
+		}
+		return res;
+    }
+    
+    public void DFS(TreeNode node,String path,List<String> res){
+		if(node.left==null&&node.right==null){
+			res.add(path+node.val);
+		}
+		if(node.left!=null){
+			DFS(node.left,path+node.val+"->",res);
+		}
+		if(node.right!=null){
+			DFS(node.right,path+node.val+"->",res);
+		}
+	}
+}
+```