refactor for format

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_11.java

@@ -16,7 +16,8 @@ public int maxArea(int[] height) {
             if (Math.min(height[i], height[j]) * (j - i) > max) {
                 max = Math.min(height[i], height[j]) * (j - i);
             }
-            if (height[i] <= height[j]) {// we need to find the shorter one,
+            if (height[i] <= height[j]) {
+                // we need to find the shorter one,
                 // then calculate its area
                 i++;
             } else {

src/main/java/com/fishercoder/solutions/_120.java

@@ -26,8 +26,10 @@ public static int minimumTotal(List<List<Integer>> triangle) {
         int n = triangle.size();
         List<Integer> cache = triangle.get(n - 1);
 
-        for (int layer = n - 2; layer >= 0; layer--) {//for each layer
-            for (int i = 0; i <= layer; i++) {//check its very node
+        for (int layer = n - 2; layer >= 0; layer--) {
+            //for each layer
+            for (int i = 0; i <= layer; i++) {
+                //check its very node
                 int value = Math.min(cache.get(i), cache.get(i + 1)) + triangle.get(layer).get(i);
                 cache.set(i, value);
             }

src/main/java/com/fishercoder/solutions/_126.java

@@ -77,15 +77,17 @@ public List<List<String>> findLadders(String start, String end, List<String> dic
                     String newWord = builder.toString();
                     if (ladder.containsKey(newWord)) {
 
-                        if (step > ladder.get(newWord)) {//Check if it is the shortest path to one word.
+                        if (step > ladder.get(newWord)) {
+                            //Check if it is the shortest path to one word.
                             continue;
                         } else if (step < ladder.get(newWord)) {
                             queue.add(newWord);
                             ladder.put(newWord, step);
                         } else ;// It is a KEY line. If one word already appeared in one ladder,
                         // Do not insert the same word inside the queue twice. Otherwise it gets TLE.
 
-                        if (map.containsKey(newWord)) {//Build adjacent Graph
+                        if (map.containsKey(newWord)) {
+                            //Build adjacent Graph
                             map.get(newWord).add(word);
                         } else {
                             List<String> list = new LinkedList();
@@ -100,10 +102,14 @@ public List<List<String>> findLadders(String start, String end, List<String> dic
                             min = step;
                         }
 
-                    }//End if dict contains new_word
-                }//End:Iteration from 'a' to 'z'
-            }//End:Iteration from the first to the last
-        }//End While
+                    }
+                    //End if dict contains new_word
+                }
+                //End:Iteration from 'a' to 'z'
+            }
+            //End:Iteration from the first to the last
+        }
+        //End While
 
         //BackTracking
         LinkedList<String> result = new LinkedList<>();

src/main/java/com/fishercoder/solutions/_128.java

@@ -17,53 +17,56 @@ Your algorithm should run in O(n) complexity.
 public class _128 {
     //inspired by this solution: https://discuss.leetcode.com/topic/29286/my-java-solution-using-unionfound
     public int longestConsecutive(int[] nums) {
-        Map<Integer, Integer> map = new HashMap();//<value, index>
+        Map<Integer, Integer> map = new HashMap();
+        //<value, index>
         UnionFind uf = new UnionFind(nums);
-        for(int i = 0; i < nums.length; i++){
-            if(map.containsKey(nums[i])) continue;
+        for (int i = 0; i < nums.length; i++) {
+            if (map.containsKey(nums[i])) continue;
             map.put(nums[i], i);
-            if(map.containsKey(nums[i]-1)){
-                uf.union(i, map.get(nums[i]-1));//note: we want to union this index and nums[i]-1's root index which we can get from the map
+            if (map.containsKey(nums[i] - 1)) {
+                uf.union(i, map.get(nums[i] - 1));
+                //note: we want to union this index and nums[i]-1's root index which we can get from the map
             }
-            if(map.containsKey(nums[i]+1)){
-                uf.union(i, map.get(nums[i]+1));
+            if (map.containsKey(nums[i] + 1)) {
+                uf.union(i, map.get(nums[i] + 1));
             }
         }
         return uf.maxUnion();
     }
 
-    class UnionFind{
+    class UnionFind {
         int[] ids;
 
-        public UnionFind(int[] nums){
+        public UnionFind(int[] nums) {
             ids = new int[nums.length];
-            for(int i = 0; i < nums.length; i++) {
+            for (int i = 0; i < nums.length; i++) {
                 ids[i] = i;
             }
         }
 
-        public void union(int i, int j){
+        public void union(int i, int j) {
             int x = find(ids, i);
             int y = find(ids, j);
             ids[x] = y;
         }
 
-        public int find(int[] ids, int i){
-            while(i != ids[i]){
+        public int find(int[] ids, int i) {
+            while (i != ids[i]) {
                 ids[i] = ids[ids[i]];
                 i = ids[i];
             }
             return i;
         }
 
-        public boolean connected(int i, int j){
+        public boolean connected(int i, int j) {
             return find(ids, i) == find(ids, j);
         }
 
-        public int maxUnion(){//this is O(n)
+        public int maxUnion() {
+            //this is O(n)
             int max = 0;
             int[] count = new int[ids.length];
-            for(int i = 0; i < ids.length; i++){
+            for (int i = 0; i < ids.length; i++) {
                 count[find(ids, i)]++;
                 max = max < count[find(ids, i)] ? count[find(ids, i)] : max;
             }
@@ -72,23 +75,27 @@ public int maxUnion(){//this is O(n)
     }
 
     class SolutionUsingHashSet {
-    //inspired by this solution: https://discuss.leetcode.com/topic/25493/simple-fast-java-solution-using-set
+        //inspired by this solution: https://discuss.leetcode.com/topic/25493/simple-fast-java-solution-using-set
         public int longestConsecutive(int[] nums) {
-            if(nums == null || nums.length == 0) return 0;
+            if (nums == null || nums.length == 0) return 0;
 
             Set<Integer> set = new HashSet();
-            for(int i : nums) set.add(i);
+            for (int i : nums) set.add(i);
             int max = 1;
 
-            for(int num : nums){
-                if(set.remove(num)){
+            for (int num : nums) {
+                if (set.remove(num)) {
                     int val = num;
                     int count = 1;
-                    while(set.remove(val-1)) val--;//we find all numbers that are smaller than num and remove them from the set
+                    while (set.remove(val - 1)) {
+                        val--;//we find all numbers that are smaller than num and remove them from the set
+                    }
                     count += num - val;
 
                     val = num;
-                    while(set.remove(val+1)) val++;//then we find all numbers that are bigger than num and also remove them from the set
+                    while (set.remove(val + 1)) {
+                        val++;//then we find all numbers that are bigger than num and also remove them from the set
+                    }
                     count += val - num;
 
                     max = Math.max(max, count);

src/main/java/com/fishercoder/solutions/_129.java

@@ -24,30 +24,30 @@
  */
 public class _129 {
     public int sumNumbers(TreeNode root) {
-        if(root == null) return 0;
+        if (root == null) return 0;
         List<Integer> allNumbers = new ArrayList();
         dfs(root, new StringBuilder(), allNumbers);
         int sum = 0;
-        for(int i : allNumbers){
+        for (int i : allNumbers) {
             sum += i;
         }
         return sum;
     }
 
     private void dfs(TreeNode root, StringBuilder sb, List<Integer> allNumbers) {
         sb.append(root.val);
-        if(root.left != null){
+        if (root.left != null) {
             dfs(root.left, sb, allNumbers);
         }
-        if(root.right != null){
+        if (root.right != null) {
             dfs(root.right, sb, allNumbers);
         }
-        if(root.left == null && root.right == null){
+        if (root.left == null && root.right == null) {
             allNumbers.add(Integer.parseInt(sb.toString()));
         }
-        sb.deleteCharAt(sb.length()-1);
+        sb.deleteCharAt(sb.length() - 1);
     }
-    
+
     class MoreConciseVersion {
         public int sumNumbers(TreeNode root) {
             return dfs(root, 0);

src/main/java/com/fishercoder/solutions/_13.java

@@ -17,12 +17,12 @@ public int romanToInt(String s) {
         map.put('C', 100);
         map.put('D', 500);
         map.put('M', 1000);
-        
+
         char[] schar = s.toCharArray();
         int result = 0;
-        for(int i = 0; i < s.length(); i++){
-            if(i > 0 && map.get(schar[i]) > map.get(schar[i-1])){
-                result = result + map.get(schar[i]) - 2*map.get(schar[i-1]);
+        for (int i = 0; i < s.length(); i++) {
+            if (i > 0 && map.get(schar[i]) > map.get(schar[i - 1])) {
+                result = result + map.get(schar[i]) - 2 * map.get(schar[i - 1]);
             } else {
                 result = result + map.get(schar[i]);
             }

src/main/java/com/fishercoder/solutions/_130.java

@@ -25,62 +25,64 @@
  */
 public class _130 {
 
-    /**I won't call this problem hard, it's just confusing, you'll definitely want to clarify what the problem means before coding.
+    /**
+     * I won't call this problem hard, it's just confusing, you'll definitely want to clarify what the problem means before coding.
      * This problem eactually means:
      * any grid that is 'O' but on the four edges, will never be marked to 'X';
      * furthermore, any grid that is 'O' and that is connected with the above type of 'O' will never be marked to 'X' as well;
-     * only all other nodes that has any one direct neighbor that is an 'X' will be marked to 'X'.*/
+     * only all other nodes that has any one direct neighbor that is an 'X' will be marked to 'X'.
+     */
 
 
-    int[] dirs = new int[]{0,1,0,-1,0};
+    int[] dirs = new int[]{0, 1, 0, -1, 0};
 
     public void solve(char[][] board) {
-        if(board == null || board.length == 0 || board[0].length == 0) return;
+        if (board == null || board.length == 0 || board[0].length == 0) return;
         int m = board.length, n = board[0].length;
         Queue<int[]> queue = new LinkedList();
         //check first row and last row and mark all those '0' on these two rows to be '+' to let them be different from other 'O',
         //at the same time, we put them into the queue to get ready for a BFS to mark all those adjacent 'O' nodes to '+' as well
-        for(int j = 0; j < n; j++){
-            if(board[0][j] == 'O') {
+        for (int j = 0; j < n; j++) {
+            if (board[0][j] == 'O') {
                 board[0][j] = '+';
-                queue.offer(new int[]{0,j});
+                queue.offer(new int[]{0, j});
 
             }
-            if(board[m-1][j] == 'O') {
-                board[m-1][j] = '+';
-                queue.offer(new int[]{m-1,j});
+            if (board[m - 1][j] == 'O') {
+                board[m - 1][j] = '+';
+                queue.offer(new int[]{m - 1, j});
             }
         }
 
         //check first column and last column too
-        for(int i = 0; i < m; i++){
-            if(board[i][0] == 'O') {
+        for (int i = 0; i < m; i++) {
+            if (board[i][0] == 'O') {
                 board[i][0] = '+';
                 queue.offer(new int[]{i, 0});
             }
-            if(board[i][n-1] == 'O') {
-                board[i][n-1] = '+';
-                queue.offer(new int[]{i,n-1});
+            if (board[i][n - 1] == 'O') {
+                board[i][n - 1] = '+';
+                queue.offer(new int[]{i, n - 1});
             }
         }
 
-        while(!queue.isEmpty()){
+        while (!queue.isEmpty()) {
             int[] curr = queue.poll();
-            for(int i = 0; i < 4; i++){
-                int x = curr[0]+dirs[i];
-                int y = curr[1]+dirs[i+1];
-                if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O'){
+            for (int i = 0; i < 4; i++) {
+                int x = curr[0] + dirs[i];
+                int y = curr[1] + dirs[i + 1];
+                if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') {
                     board[x][y] = '+';
-                    queue.offer(new int[]{x,y});
+                    queue.offer(new int[]{x, y});
                 }
             }
         }
 
         //now we can safely mark all other 'O' to 'X', also remember to put those '+' back to 'O'
-        for(int i = 0; i < m; i++){
-            for(int j = 0; j < n; j++){
-                if(board[i][j] == 'O') board[i][j] = 'X';
-                else if(board[i][j] == '+') board[i][j] = 'O';
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (board[i][j] == 'O') board[i][j] = 'X';
+                else if (board[i][j] == '+') board[i][j] = 'O';
             }
         }
     }

src/main/java/com/fishercoder/solutions/_131.java

@@ -20,30 +20,31 @@ public List<List<String>> partition(String s) {
         List<List<String>> result = new ArrayList();
         int n = s.length();
         boolean[][] dp = new boolean[n][n];
-        for(int i = 0; i < n; i++){
-            for(int j = 0; j <= i; j++){
-                if(s.charAt(j) == s.charAt(i) && (j+1 >= i-1 || dp[j+1][i-1])){// j+1 >= i-1 means j and i are adjance to each other or only one char apart from each other
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j <= i; j++) {
+                if (s.charAt(j) == s.charAt(i) && (j + 1 >= i - 1 || dp[j + 1][i - 1])) {
+                    // j+1 >= i-1 means j and i are adjance to each other or only one char apart from each other
                     //dp[j+1][i-1] means its inner substring is a palindrome, so as long as s.charAt(j) == s.charAt(i), then dp[j][i] must be a palindrome.
                     dp[j][i] = true;
                 }
             }
         }
-        
-        for(boolean[] list : dp){
-            for(boolean b : list){
+
+        for (boolean[] list : dp) {
+            for (boolean b : list) {
                 System.out.print(b + ", ");
             }
             System.out.println();
         }
         System.out.println();
-        
+
         backtracking(s, 0, dp, new ArrayList(), result);
-        
+
         return result;
     }
-    
+
     void backtracking(String s, int start, boolean[][] dp, List<String> temp,
-            List<List<String>> result) {
+                      List<List<String>> result) {
         if (start == s.length()) {
             List<String> newTemp = new ArrayList(temp);
             result.add(newTemp);
@@ -57,13 +58,13 @@ void backtracking(String s, int start, boolean[][] dp, List<String> temp,
         }
     }
 
-    
-    public static void main(String...strings){
+
+    public static void main(String... strings) {
         _131 test = new _131();
         String s = "aab";
         List<List<String>> result = test.partition(s);
-        for(List<String> list : result){
-            for(String str : list){
+        for (List<String> list : result) {
+            for (String str : list) {
                 System.out.print(str + ", ");
             }
             System.out.println();