題目

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].

解釋： 看題目第一眼就想到暴力解是怎麼回事？ 暴力解法，python程式碼：

class Solution(object):
    def imageSmoother(self, M):
        """
        :type M: List[List[int]]
        :rtype: List[List[int]]
        """
        height=len(M)
        width=len(M[0]) if height else 0
        new_M=copy.deepcopy(M)
        for i in xrange
 
(height):
            for j in xrange(width):
                neighbor=[
                    M[_i][_j] 
                    for _i in (i-1,i,i+1) 
                    for _j in (j-1,j,j+1) 
                    if 0<=_i<height and 0<=_j<width
                ]
                new_M[i][j]=sum(neighbor)/len(neighbor)
        return new_M  

c++程式碼：

class Solution {
public:
    vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
        vector<int>delta={-1,0,1};
        vector<int>delta2={-1,0,1};
        int m=M.size();
        int n=M[0].size();
        vector<vector<int>>result(m,vector<int>(n,0));
        for (int r=0;r<m;r++)
        {
            for(int c=0;c<n;c++)
            {
                int _sum=0;
                int _count=0;
                for(auto d1:delta)
                {
                    for(auto d2:delta2)
                    {
                        if (r+d1>=0 &&r+d1<m &&c+d2>=0&&c+d2<n)
                            
                        {   
                            _sum+=M[r+d1][c+d2];
                            _count++;
                        }
                    }
                }
                result[r][c]=_sum/_count;
            }      
            
        }
        return result;
    }
};

總結： 判斷的時候，不能連用兩個不等式，要用&&連線兩個判斷語句