enable MultipleVariableDeclarations check!

Author: fishercoder1534

fishercoder_checkstyle.xml

@@ -115,7 +115,7 @@
             <property name="allowNoEmptyLineBetweenFields" value="true"/>
         </module>
 
-        <!--<module name="MultipleVariableDeclarations"/>-->
+        <module name="MultipleVariableDeclarations"/>
 
         <module name="SeparatorWrap">
             <property name="tokens" value="DOT"/>

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

@@ -30,7 +30,8 @@ public int maxProfit(int k, int[] prices) {
 
 
     private int quickSolve(int[] prices) {
-        int len = prices.length, profit = 0;
+        int len = prices.length;
+        int profit = 0;
         for (int i = 1; i < len; i++) {
             // as long as there is a price gap, we gain a profit.
             if (prices[i] > prices[i - 1]) profit += prices[i] - prices[i - 1];

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

@@ -56,7 +56,8 @@ public ListNode removeNthFromEnd_one_pass(ListNode head, int n) {
         //then, when fast reaches null, slow reaches the point where the node should be deleted.
         ListNode dummy = new ListNode(-1);
         dummy.next = head;
-        ListNode slow = head, fast = head;
+        ListNode slow = head;
+        ListNode fast = head;
         int tempN = n;
         while (tempN-- > 0) {
             fast = fast.next;
@@ -87,7 +88,8 @@ public ListNode removeNthFromEnd_one_pass(ListNode head, int n) {
     public ListNode removeNthFromEnd_one_pass_more_concise_version(ListNode head, int n) {
         ListNode dummy = new ListNode(-1);
         dummy.next = head;
-        ListNode slow = dummy, fast = dummy;
+        ListNode slow = dummy;
+        ListNode fast = dummy;
         while (fast.next != null) {
             if (n <= 0) slow = slow.next;
             fast = fast.next;

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

@@ -31,7 +31,8 @@ public static class DFSSolution {
         public int numIslands(char[][] grid) {
             if (grid == null || grid.length == 0) return 0;
             int count = 0;
-            int m = grid.length, n = grid[0].length;
+            int m = grid.length;
+            int n = grid[0].length;
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {
                     if (grid[i][j] == '1') {
@@ -95,7 +96,8 @@ public int numIslands(char[][] grid) {
             if (grid == null || grid.length == 0 || grid[0].length == 0) return 0;
             int[] dirs = new int[]{0, 1, 0, -1, 0};
             UnionFind uf = new UnionFind(grid);
-            int m = grid.length, n = grid[0].length;
+            int m = grid.length;
+            int n = grid[0].length;
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {
                     if (grid[i][j] == '1') {

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

@@ -26,7 +26,8 @@ public class _203 {
 	public ListNode removeElements(ListNode head, int val) {
 		ListNode dummy = new ListNode(-1);
 		dummy.next = head;
-		ListNode curr = head, prev = dummy;
+		ListNode curr = head;
+		ListNode prev = dummy;
 		while (curr != null) {
 			if (curr.val == val) {
 				prev.next = curr.next;

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

@@ -15,7 +15,10 @@ public class _209 {
 
     public int minSubArrayLen(int s, int[] nums) {
         if (nums == null || nums.length == 0) return 0;
-        int i = 0, j = 0, min = Integer.MAX_VALUE, sum = 0;
+        int i = 0;
+        int j = 0;
+        int min = Integer.MAX_VALUE;
+        int sum = 0;
         while (j < nums.length) {
             sum += nums[j++];
 

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

@@ -18,7 +18,8 @@ public class _221 {
     /**The idea is pretty straightforward: use a 2d dp table to store the intermediate results*/
     public static int maximalSquare(char[][] matrix) {
         if (matrix == null || matrix.length == 0) return 0;
-        int m = matrix.length, n = matrix[0].length;
+        int m = matrix.length;
+        int n = matrix[0].length;
         int max = Integer.MIN_VALUE;
         int[][] dp = new int[m][n];
         for (int i = 0; i < m; i++) {

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

@@ -16,7 +16,8 @@ public class _233 {
     public int countDigitOne(int n) {
         int count = 0;
         for (long k = 1; k <= n; k *= 10) {
-            long r = n / k, m = n % k;
+            long r = n / k;
+            long m = n % k;
             // sum up the count of ones on every place k
             count += (r + 8) / 10 * k + (r % 10 == 1 ? m + 1 : 0);
         }

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

@@ -21,7 +21,8 @@ public static class Solution1 {
         public boolean isPalindrome(ListNode head) {
             if (head == null) return true;
 
-            ListNode slow = head, fast = head;
+            ListNode slow = head;
+            ListNode fast = head;
             while (fast.next != null && fast.next.next != null) {
                 fast = fast.next.next;
                 slow = slow.next;

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

@@ -14,7 +14,9 @@ public class _243 {
 
     public int shortestDistance(String[] words, String word1, String word2) {
 
-        int p = -1, q = -1, min = Integer.MAX_VALUE;
+        int p = -1;
+        int q = -1;
+        int min = Integer.MAX_VALUE;
         for (int i = 0; i < words.length; i++) {
             if (words[i].equals(word1)) p = i;
             if (words[i].equals(word2)) q = i;

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

@@ -42,7 +42,8 @@ public int shortest(String word1, String word2) {
         List<Integer> list2 = map.get(word2);
         int ret = Integer.MAX_VALUE;
         for (int i = 0, j = 0; i < list1.size() && j < list2.size(); ) {
-            int index1 = list1.get(i), index2 = list2.get(j);
+            int index1 = list1.get(i);
+            int index2 = list2.get(j);
             if (index1 < index2) {
                 ret = Math.min(ret, index2 - index1);
                 i++;

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

@@ -16,7 +16,8 @@
 public class _246 {
 
     public boolean isStrobogrammatic_map(String num) {
-        int i = 0, j = num.length() - 1;
+        int i = 0;
+        int j = num.length() - 1;
         Map<Character, Character> map = new HashMap();
         map.put('8', '8');
         map.put('1', '1');
@@ -47,7 +48,8 @@ public boolean isStrobogrammatic_set(String num) {
         set.add('8');
         set.add('9');
         char[] nums = num.toCharArray();
-        int i = 0, j = num.length() - 1;
+        int i = 0;
+        int j = num.length() - 1;
         while (i <= j) {
             if (!set.contains(nums[i]) || !set.contains(nums[j])) return false;
             if (nums[i] == '6' && nums[j] != '9') return false;

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

@@ -23,7 +23,8 @@ public int threeSumSmaller(int[] nums, int target) {
         int result = 0;
         Arrays.sort(nums);
         for (int i = 0; i < nums.length - 2; i++) {
-            int left = i + 1, right = nums.length - 1;
+            int left = i + 1;
+            int right = nums.length - 1;
             while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right];
                 if (sum < target) {

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

@@ -15,8 +15,12 @@ public class _264 {
     public int nthUglyNumber(int n) {
         int[] ugly = new int[n];
         ugly[0] = 1;
-        int index2 = 0, index3 = 0, index5 = 0;
-        int factor2 = 2, factor3 = 3, factor5 = 5;
+        int index2 = 0;
+        int index3 = 0;
+        int index5 = 0;
+        int factor2 = 2;
+        int factor3 = 3;
+        int factor5 = 5;
         for (int i = 1; i < n; i++) {
             int min = Math.min(Math.min(factor2, factor3), factor5);
             ugly[i] = min;

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

@@ -17,13 +17,16 @@ public int minCostII(int[][] costs) {
 		if (costs == null || costs.length == 0)
 			return 0;
 
-		int n = costs.length, k = costs[0].length;
+		int n = costs.length;
+		int k = costs[0].length;
 		// min1 is the index of the 1st-smallest cost till previous house
 		// min2 is the index of the 2nd-smallest cost till previous house
-		int min1 = -1, min2 = -1;
+		int min1 = -1;
+		int min2 = -1;
 
 		for (int i = 0; i < n; i++) {
-			int last1 = min1, last2 = min2;
+			int last1 = min1;
+			int last2 = min2;
 			min1 = -1;
 			min2 = -1;
 

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

@@ -13,7 +13,8 @@ public class _268 {
     /**we could take advantage of the array indices
     then a number xor with itself is zero, so after we xor the entire array with all of its indices, the missing number will show up.*/
     public int missingNumber(int[] nums) {
-        int xor = 0, i = 0;
+        int xor = 0;
+        int i = 0;
         for (; i < nums.length; i++) {
             xor = xor ^ i ^ nums[i];
         }

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

@@ -26,7 +26,8 @@ public int removeElement_editorial_solution_1(int[] nums, int val) {
 	public int removeElement_editorial_solution_2(int[] nums, int val) {
 		//this approach is very similar to the one below that I came up totally by myself, but it's much concise
 		//Here, it didn't check whether nums[n-1] will be equal to val, because in the next iteration, it will still check that number, smart!
-		int i = 0, n = nums.length;
+		int i = 0;
+		int n = nums.length;
 		while (i < n) {
 			if (nums[i] == val) {
 				nums[i] = nums[n - 1];
@@ -41,7 +42,8 @@ public int removeElement_editorial_solution_2(int[] nums, int val) {
 	//just throw all numbers that are equal to val to the end and make a count of it
 	public int removeElement(int[] nums, int val) {
 		int count = 0;
-		int len = nums.length, throwPosition = len - 1;
+		int len = nums.length;
+		int throwPosition = len - 1;
 		for (int i = 0; i <= throwPosition; i++) {
 			while (throwPosition >= 0 && nums[throwPosition] == val) {
 				throwPosition--;

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

@@ -13,7 +13,8 @@ public class _276 {
     public int numWays(int n, int k) {
         if (n == 0) return 0;
         else if (n == 1) return k;
-        int sameColorCnt = k, diffColorCnt = k * (k - 1);
+        int sameColorCnt = k;
+        int diffColorCnt = k * (k - 1);
         for (int i = 2; i < n; i++) {
             int temp = diffColorCnt;
             diffColorCnt = (diffColorCnt + sameColorCnt) * (k - 1);

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

@@ -8,7 +8,8 @@ You are given an API bool isBadVersion(version) which will return whether versio
 public class _278 {
 
 	public int firstBadVersion(int n) {
-		int left = 1, right = n;
+		int left = 1;
+		int right = n;
 		if (isBadVersion(left))
 			return left;
 

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

@@ -10,9 +10,11 @@
 public class _279 {
 
     public int numSquares(int n) {
-        int result = n, num = 2;
+        int result = n;
+        int num = 2;
         while (num * num <= n) {
-            int temp1 = n / (num * num), temp2 = n % (num * num);
+            int temp1 = n / (num * num);
+            int temp2 = n % (num * num);
             result = Math.min(result, temp1 + numSquares(temp2));
             num++;
         }

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

@@ -26,7 +26,8 @@ public void moveZeroes_Editorial_solution2(int[] nums) {
 
     public void moveZeroes_Editorial_solution1(int[] nums) {
         //keep the last non-zero index and keep overwriting it, then append zeroes to fill the end
-        int j = 0, i = 0;
+        int j = 0;
+        int i = 0;
         for (; j < nums.length; j++) {
             if (nums[j] != 0) {
                 nums[i++] = nums[j];
@@ -59,7 +60,8 @@ public void moveZeroes(int[] nums) {
 
     //this approach won't preserve the relative order of the non-zero numbers
     public void moveZeroes_1st_attempt(int[] nums) {
-        int i = 0, j = nums.length - 1;
+        int i = 0;
+        int j = nums.length - 1;
         while (i < j) {
             if (nums[i] == 0) {
                 int temp = nums[j];

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

@@ -31,10 +31,13 @@ class BFSSolutionWithoutQueue {
 
         public void wallsAndGates(int[][] rooms) {
             if (rooms == null || rooms.length == 0 || rooms[0].length == 0) return;
-            int m = rooms.length, n = rooms[0].length;
+            int m = rooms.length;
+            int n = rooms[0].length;
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {
-                    if (rooms[i][j] == 0) bfs(rooms, i, j, m, n);
+                    if (rooms[i][j] == 0) {
+                        bfs(rooms, i, j, m, n);
+                    }
                 }
             }
         }
@@ -59,7 +62,8 @@ class BFSSolutionWithAQueue {
 
         public void wallsAndGates(int[][] rooms) {
             if (rooms == null || rooms.length == 0 || rooms[0].length == 0) return;
-            int m = rooms.length, n = rooms[0].length;
+            int m = rooms.length;
+            int n = rooms[0].length;
             Queue<int[]> queue = new LinkedList();
             for (int i = 0; i < m; i++) {
                 for (int j = 0; j < n; j++) {

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

@@ -25,7 +25,8 @@ Write a function to compute the next state (after one update) of the board given
 
 public class _289 {
     public void gameOfLife(int[][] board) {
-        int height = board.length, width = board[0].length;
+        int height = board.length;
+        int width = board[0].length;
         int[][] next = new int[height][width];
 
         for (int i = 0; i < board.length; i++) {

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

@@ -19,7 +19,8 @@ class Solution {
 
         public int minArea(char[][] iImage, int x, int y) {
             image = iImage;
-            int m = image.length, n = image[0].length;
+            int m = image.length;
+            int n = image[0].length;
             int left = searchColumns(0, y, 0, m, true);
             int right = searchColumns(y + 1, n, 0, m, false);
             int top = searchRows(0, x, left, right, true);
@@ -29,24 +30,30 @@ public int minArea(char[][] iImage, int x, int y) {
 
         private int searchColumns(int i, int j, int top, int bottom, boolean opt) {
             while (i != j) {
-                int k = top, mid = (i + j) / 2;
-                while (k < bottom && image[k][mid] == '0') ++k;
-                if (k < bottom == opt)
+                int k = top;
+                int mid = (i + j) / 2;
+                while (k < bottom && image[k][mid] == '0') {
+                    ++k;
+                }
+                if (k < bottom == opt) {
                     j = mid;
-                else
+                } else {
                     i = mid + 1;
+                }
             }
             return i;
         }
 
         private int searchRows(int i, int j, int left, int right, boolean opt) {
             while (i != j) {
-                int k = left, mid = (i + j) / 2;
+                int k = left;
+                int mid = (i + j) / 2;
                 while (k < right && image[mid][k] == '0') ++k;
-                if (k < right == opt)
+                if (k < right == opt) {
                     j = mid;
-                else
+                } else {
                     i = mid + 1;
+                }
             }
             return i;
         }

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

@@ -46,7 +46,8 @@ public int find(int[] father, int id) {
         int tf = father[id];
         while (tf != father[tf])
             tf = father[tf];
-        int cur = id, tmp;
+        int cur = id;
+        int tmp;
         while (father[cur] != tf) {
             tmp = father[cur];
             father[cur] = tf;
@@ -79,7 +80,11 @@ public List<Integer> numIslands2(int m, int n, int[][] positions) {
         int[] sz = new int[m * n];
         int[] dr = { 0, 0, -1, 1 };
         int[] dc = { -1, 1, 0, 0 };
-        int r, c, nr, nc, count = 0;
+        int r;
+        int c;
+        int nr;
+        int nc;
+        int count = 0;
         for (int i = 0; i < positions.length; i++) {
             r = positions[i][0];
             c = positions[i][1];