add 661

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|661|[Image Smoother](https://leetcode.com/problems/image-smoother/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_661.java) | O(m*n) | O(1) | Easy | Array 
 |660|[Remove 9](https://leetcode.com/problems/remove-9/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_660.java) | O(n) | O(1) | Hard | Math
 |659|[Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_659.java) | O(n) | O(n) | Medium | HashMap
 |658|[Find K Closest Elements](https://leetcode.com/problems/find-k-closest-elements/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_658.java) | O(n) | O(1) | Medium |

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

@@ -0,0 +1,82 @@
+package com.fishercoder.solutions;
+
+/**
+ * 661. Image Smoother
+ *
+ * Given a 2D integer matrix M representing the gray scale of an image,
+ * you need to design a smoother to make the gray scale of each cell becomes the average gray scale (rounding down) of
+ * all the 8 surrounding cells and itself. If a cell has less than 8 surrounding cells, then use as many as you can.
+
+ Example 1:
+ Input:
+ [[1,1,1],
+ [1,0,1],
+ [1,1,1]]
+
+ Output:
+ [[0, 0, 0],
+ [0, 0, 0],
+ [0, 0, 0]]
+
+ Explanation:
+ For the point (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
+ For the point (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
+ For the point (1,1): floor(8/9) = floor(0.88888889) = 0
+
+ Note:
+ The value in the given matrix is in the range of [0, 255].
+ The length and width of the given matrix are in the range of [1, 150].
+
+ */
+public class _661 {
+    public int[][] imageSmoother(int[][] M) {
+        if (M == null || M.length == 0) return M;
+        int m = M.length;
+        int n = M[0].length;
+        int[][] result = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                bfs(M, i, j, result, m, n);
+            }
+        }
+        return result;
+    }
+
+    private void bfs(int[][] M, int i, int j, int[][] result, int m, int n) {
+        int sum = M[i][j];
+        int denominator = 1;
+        if (j + 1 < n) {
+            sum += M[i][j + 1];
+            denominator++;
+        }
+        if (i + 1 < m && j + 1 < n) {
+            sum += M[i + 1][j + 1];
+            denominator++;
+        }
+        if (i + 1 < m) {
+            sum += M[i + 1][j];
+            denominator++;
+        }
+        if (i + 1 < m && j - 1 >= 0) {
+            sum += M[i + 1][j - 1];
+            denominator++;
+        }
+        if (j - 1 >= 0) {
+            sum += M[i][j - 1];
+            denominator++;
+        }
+        if (i - 1 >= 0 && j - 1 >= 0) {
+            sum += M[i - 1][j - 1];
+            denominator++;
+        }
+        if (i - 1 >= 0) {
+            sum += M[i - 1][j];
+            denominator++;
+        }
+        if (i - 1 >= 0 && j + 1 < n) {
+            sum += M[i - 1][j + 1];
+            denominator++;
+        }
+        result[i][j] = sum / denominator;
+    }
+}

src/test/java/com/fishercoder/_661Test.java

@@ -0,0 +1,34 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._661;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class _661Test {
+    private static _661 test;
+    private static int[][] M;
+    private static int[][] expected;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _661();
+    }
+
+    @Test
+    public void test1(){
+        M = new int[][]{
+                {1,1,1},
+                {1,0,1},
+                {1,1,1}
+        };
+        expected = M = new int[][]{
+                {0,0,0},
+                {0,0,0},
+                {0,0,0}
+        };
+        assertArrayEquals(expected, test.imageSmoother(M));
+    }
+
+}