661. Image Smoother【easy】

661. Image Smoother【easy】

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:

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

错误解法：

 class Solution {
 public:
     vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
         int row = M.size();
         int col = M[].size();

         vector<vector<int>> temp(row + , vector<int>(col + ));
         for (int j = ; j < col + ; ++j) {
             temp[][j] = ;
         }
         for (int i = ; i < row + ; ++i) {
             temp[i][] = ;
         }
         for (int j = ; j < col + ; ++j) {
             temp[row][j] = ;
         }
         for (int i = ; i < row + ; ++i) {
             temp[i][col] = ;
         }

         for (int i = ; i < row; ++i) {
             for (int j = ; j < col; ++j) {
                 temp[i][j] = M[i - ][j - ];
             }
         }

         for (int i = ; i < row; ++i) {
             for (int j = ; j < col; ++j) {
                 int sum = ;
                 for (int x = -; x <= ; ++x) {
                     for (int y = -; y <= ; ++y) {
                             sum += temp[i + x][j + y];
                     }
                 }

                 temp[i][j] = floor(sum / );
             }
         }

         vector<vector<int>> result(row, vector<int>(col));
         for (int i = ; i < row; ++i) {
             for (int j = ; j < col; ++j) {
                 result[i][j] = temp[i + ][j + ];
             }
         }

         return result;
     }
 };

一开始我还想取巧，把边界扩充，想着可以一致处理，但是发现没有审清题意，坑了啊！

解法一：

 class Solution {
 private:
     bool valid(int i,int j,vector<vector<int>>& M)
     {
         if (i >= && i<M.size() && j>= && j<M[].size())
             return true;
         return false;
     }

 public:
     vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
         vector<vector<int>> res;
         if (M.size()== || M[].size()==)
             return res;

         for (int i = ; i< M.size(); i++)
         {
             vector<int> cur;
             for(int j = ; j< M[].size(); j++)
             {
                 int total = ;
                 int count = ;
                 for (int x = -; x<;x++)
                 {
                     for (int y = -; y<; y++)
                     {
                         if(valid(i+x,j+y,M))
                         {
                             count++;
                             total +=M[i+x][j+y];
                         }
                     }
                 }
                 cur.push_back(total/count);
             }
             res.push_back(cur);
         }
         return res;
     }
 };

中规中矩的解法，完全按照题目意思搞

解法三：

 class Solution {
 public:
     vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
         int m = M.size(), n = M[].size();
         if (m ==  || n == ) return {{}};
         vector<vector<int>> dirs = {{,},{,-},{,},{-,},{-,-},{,},{-,},{,-}};
         for (int i = ; i < m; i++) {
             for (int j = ; j < n; j++) {
                 int sum = M[i][j], cnt = ;
                 for (int k = ; k < dirs.size(); k++) {
                     int x = i + dirs[k][], y = j + dirs[k][];
                     if (x <  || x > m -  || y <  || y > n - ) continue;
                     sum += (M[x][y] & 0xFF);
                     cnt++;
                 }
                 M[i][j] |= ((sum / cnt) << );
             }
         }
          for (int i = ; i < m; i++) {
             for (int j = ; j < n; j++) {
                 M[i][j] >>= ;
             }
          }
         return M;
     }

 };

真正的大神解法！大神解释如下：Derived from StefanPochmann's idea in "game of life": the board has ints in [0, 255], hence only 8-bit is used, we can use the middle 8-bit to store the new state (average value), replace the old state with the new state by shifting all values 8 bits to the right.