add 672

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|672|[Bulb Switcher II](https://leetcode.com/problems/bulb-switcher-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_672.java) | O(1) | O(1) | Medium | Math 
 |671|[Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_671.java) | O(n) | O(n) | Easy | Tree, DFS
 |670|[Maximum Swap](https://leetcode.com/problems/maximum-swap/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_670.java) | O(n^2) | O(1) | Medium | String
 |669|[Trim a Binary Search Tree](https://leetcode.com/problems/trim-a-binary-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_669.java) | O(n) | O(1) | Easy | Tree, DFS

src/main/java/com/fishercoder/common/utils/CommonUtils.java

@@ -32,6 +32,16 @@ public static void printArray(int[] nums) {
         System.out.println();
     }
 
+    public static void print2DIntArray(int[][] nums) {
+        for (int[] array : nums) {
+            for (int i : array) {
+                System.out.print(i + ", ");
+            }
+            System.out.println();
+        }
+        System.out.println();
+    }
+
     public static void print(String message) {
         System.out.print(message);
     }

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

@@ -0,0 +1,87 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.utils.CommonUtils;
+
+/**
+ * 672. Bulb Switcher II
+ * There is a room with n lights which are turned on initially and 4 buttons on the wall.
+ * After performing exactly m unknown operations towards buttons,
+ * you need to return how many different kinds of status of the n lights could be.
+ * Suppose n lights are labeled as number [1, 2, 3 ..., n], function of these 4 buttons are given below:
+
+ Flip all the lights.
+ Flip lights with even numbers.
+ Flip lights with odd numbers.
+ Flip lights with (3k + 1) numbers, k = 0, 1, 2, ...
+
+ Example 1:
+
+ Input: n = 1, m = 1.
+ Output: 2
+ Explanation: Status can be: [on], [off]
+
+ Example 2:
+
+ Input: n = 2, m = 1.
+ Output: 3
+ Explanation: Status can be: [on, off], [off, on], [off, off]
+
+ Example 3:
+
+ Input: n = 3, m = 1.
+ Output: 4
+ Explanation: Status can be: [off, on, off], [on, off, on], [off, off, off], [off, on, on].
+
+ Note: n and m both fit in range [0, 1000].
+ */
+public class _672 {
+    public static class Solution1 {
+        public int flipLights(int n, int m) {
+            if (m < 1) {
+                return 1;
+            }
+            int[][] dp = new int[m][n];
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (j == 0) {
+                        dp[i][j] = 2;
+                    } else if (i == 0 && j == 1) {
+                        dp[i][j] = 3;
+                    } else if (i == 0) {
+                        dp[i][j] = 4;
+                    } else if (i == 1 && j == 1) {
+                        dp[i][j] = 4;
+                    } else if (i == 1 && j > 1) {
+                        dp[i][j] = 7;
+                    } else if (j == 1) {
+                        dp[i][j] = 4;
+                    } else if (i == 1) {
+                        dp[i][j] = 7;
+                    } else {
+                        dp[i][j] = 8;
+                    }
+                }
+            }
+            CommonUtils.print2DIntArray(dp);
+            return dp[m-1][n-1];
+        }
+    }
+
+    public static class Solution2 {
+        public int flipLights(int n, int m) {
+            if (n == 1 && m > 0) {
+                return 2;
+            } else if (n == 2 && m == 1) {
+                return 3;
+            } else if ((n > 2 && m == 1) || (n == 2 && m > 1)) {
+                return 4;
+            } else if (n > 2 && m == 2) {
+                return 7;
+            } else if (n > 2 && m > 2) {
+                return 8;
+            } else {
+                return 1;
+            }
+        }
+    }
+}

src/test/java/com/fishercoder/_672Test.java

@@ -0,0 +1,109 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._672;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _672Test {
+    private static _672.Solution1 solution1;
+    private static _672.Solution2 solution2;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _672.Solution1();
+        solution2 = new _672.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(2, solution1.flipLights(1, 1));
+        assertEquals(2, solution2.flipLights(1, 1));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(3, solution1.flipLights(2, 1));
+        assertEquals(3, solution2.flipLights(2, 1));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(4, solution1.flipLights(3, 1));
+        assertEquals(4, solution2.flipLights(3, 1));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(4, solution1.flipLights(4, 1));
+        assertEquals(4, solution2.flipLights(4, 1));
+    }
+
+    @Test
+    public void test5() {
+        assertEquals(4, solution1.flipLights(10, 1));
+        assertEquals(4, solution2.flipLights(10, 1));
+    }
+
+    @Test
+    public void test6() {
+        assertEquals(4, solution1.flipLights(2, 2));
+        assertEquals(4, solution2.flipLights(2, 2));
+    }
+
+    @Test
+    public void test7() {
+        assertEquals(2, solution1.flipLights(1, 2));
+        assertEquals(2, solution2.flipLights(1, 2));
+    }
+
+    @Test
+    public void test8() {
+        assertEquals(2, solution1.flipLights(1, 3));
+        assertEquals(2, solution2.flipLights(1, 3));
+    }
+
+    @Test
+    public void test9() {
+        assertEquals(2, solution1.flipLights(1, 4));
+        assertEquals(2, solution2.flipLights(1, 4));
+    }
+
+    @Test
+    public void test10() {
+        assertEquals(2, solution1.flipLights(1, 5));
+        assertEquals(2, solution2.flipLights(1, 5));
+    }
+
+    @Test
+    public void test11() {
+        assertEquals(2, solution1.flipLights(1, 10));
+        assertEquals(2, solution2.flipLights(1, 10));
+    }
+
+    @Test
+    public void test12() {
+        assertEquals(7, solution1.flipLights(3, 2));
+        assertEquals(7, solution2.flipLights(3, 2));
+    }
+
+    @Test
+    public void test13() {
+        assertEquals(8, solution1.flipLights(7, 5));
+        assertEquals(8, solution2.flipLights(7, 5));
+    }
+
+    @Test
+    public void test14() {
+        assertEquals(1, solution1.flipLights(1, 0));
+        assertEquals(1, solution2.flipLights(1, 0));
+    }
+
+    @Test
+    public void test15() {
+        assertEquals(8, solution1.flipLights(7, 5));
+        assertEquals(8, solution2.flipLights(7, 5));
+    }
+
+}