feat: add the solution of Image Smoother(661) with Java.

Author: Mukyu

README.md

@@ -66,7 +66,7 @@
 | [645][645-question] | [Set Mismatch][645-tips]                                     | [✅][645-java] | [✅][645-js] |                  |
 | [653][653-question] | [Two Sum IV - Input is a BST][653-tips]                      | [✅][653-java] | [✅][653-js] |                  |
 | [657][657-question] | [Judge Route Circle][657-tips]                               | [✅][657-java] | [✅][657-js] |                  |
-| [661][661-question] | [Image Smoother][661-tips]                                   |                | [✅][661-js] |                  |
+| [661][661-question] | [Image Smoother][661-tips]                                   | [✅][661-java] | [✅][661-js] |                  |
 | [665][665-question] | [Non-decreasing Array][665-tips]                             |                | [✅][665-js] |                  |
 | [669][669-question] | [Trim a Binary Search Tree][669-tips]                        |                | [✅][669-js] |                  |
 | [671][671-question] | [Second Minimum Node In a Binary Tree][671-tips]             |                | [✅][671-js] |                  |
@@ -457,6 +457,7 @@
 [645-java]: ./src/_645/Solution.java
 [653-java]: ./src/_653/Solution.java
 [657-java]: ./src/_657/Solution.java
+[661-java]: ./src/_661/Solution.java
 [728-java]: ./src/_728/Solution.java
 [771-java]: ./src/_771/Solution.java
 [804-java]: ./src/_804/Solution.java

src/_661/Solution.java

@@ -0,0 +1,34 @@
+package _661;
+
+class Solution {
+    public int[][] imageSmoother(int[][] M) {
+        int[][] result = new int[M.length][M[0].length];
+
+        int sum;
+        int count;
+        int xLen = M.length;
+        int yLen = M[0].length;
+        int nx, ny;
+
+        for (int x = 0; x < M.length; x++) {
+            for (int y = 0; y < M[x].length; y++) {
+                sum = 0;
+                count = 0;
+                for (int i = -1; i <= 1; i++) {
+                    for (int j = -1; j <= 1; j++) {
+                        nx = x+i;
+                        ny = y+j;
+                        if (nx >= 0 && nx < xLen && ny >= 0 && ny < yLen) {
+                            sum += M[nx][ny];
+                            count++;
+                        }
+                    }
+                }
+
+                result[x][y] = sum / count;
+            }
+        }
+
+        return result;
+    }
+}

tips/661/README.md

@@ -1,46 +1,74 @@
-[xxxx][title]
+[Image Smoother][title]
 
 ## Description
-// 抄题目
-
+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:**
 
 ```
-// 抄Example
+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:**
-// Note
 
-**Tags:** // tags
+1. The value in the given matrix is in the range of [0, 255].
+2. The length and width of the given matrix are in the range of [1, 150].
 
+**Tags:** [Array](https://leetcode.com/tag/array/)
 
-## 思路 1
-// 贴一些关键代码,说一些解题思路
-// (同一种语言可以写多种思路，与某种语言思路相同的另一种语言的思路无须赘述，但可以把代码贴在后面) 
-```java
+## 思路
 
-```
-```javascript
+题意为对像素进行平滑化处理。平滑化后的像素值为周围的8个像素加上自己的平均值，再取整。
 
-```
+**Java**
 
-## 思路 2
-// 贴一些关键代码,说一些解题思路
 ```java
-
-```
-
-## 思路 3
-// 贴一些关键代码,说一些解题思路
-```kotlin
-
+class Solution {
+    public int[][] imageSmoother(int[][] M) {
+        int[][] result = new int[M.length][M[0].length];
+
+        int sum;
+        int count;
+        int xLen = M.length;
+        int yLen = M[0].length;
+        int nx, ny;
+        for (int x = 0; x < M.length; x++) {
+            for (int y = 0; y < M[x].length; y++) {
+                sum = 0;
+                count = 0;
+                for (int i = -1; i <= 1; i++) {
+                    for (int j = -1; j <= 1; j++) {
+                        nx = x+i;
+                        ny = y+j;
+                        if (nx >= 0 && nx < xLen && ny >= 0 && ny < yLen) {
+                            sum += M[nx][ny];
+                            count++;
+                        }
+                    }
+                }
+                result[x][y] = sum / count;
+            }
+        }
+
+        return result;
+    }
+}
 ```
 
 ## 结语
-   
+
 如果你同我们一样热爱数据结构、算法、LeetCode，可以关注我们 GitHub 上的 LeetCode 题解：[LeetCode-Solution][ls]
 
-[title]: https://leetcode.com/problems/xxxx
+[title]: https://leetcode.com/problems/image-smoother/description/
 [ls]: https://github.com/SDE603/LeetCode-Solution