【神奇的技巧】leetcode - 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:

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

分析及解答

解法：（简洁 ）

大神： stefanpochmann

I store the sums and counts in the higher bits and divide them in a second pass.

public int[][] imageSmoother(int[][] M) {
    int m = M.length, n = M[0].length;
    for (int i=0; i<m; i++)
        for (int j=0; j<n; j++)
            for (int I=i-1; I<i+2; I++)
                for (int J=j-1; J<j+2; J++)
                    if (I >= 0 && I < m && J >= 0 && J < n)
                        M[i][j] += 256 + M[I][J] % 256 * 4096;
    for (int i=0; i<m; i++)
        for (int j=0; j<n; j++)
            M[i][j] = M[i][j] / 4096 / (M[i][j] / 256 % 16);
    return M;
}

After my first pass, each M[i][j] holds:

• In bits 0-7: The original value.
• In bits 8-11: The number of contributing cells (i.e., the number of neighbors, plus 1 (for the cell itself)). That's why I add 256 for each contributing cell.
• In bits 12-31: The sum of the original values of the contributing cells. That's why I add the original value of M[I][J] times 4096.

解法：（下面反例的改进）

class Solution {
    public int[][] imageSmoother(int[][] M) {
         if(M==null || M.length<1){
             return null;
         }
         int[][] array = new int[M.length][M[0].length];
         int[][] dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1},{-1,-1},{-1,1},{1,1},{1,-1}};//巧妙的数组设置。
         for(int i=0;i<M.length;i++){
             for(int j=0;j<M[0].length;j++){
                 int sum=M[i][j];
                 int count =1;
                 for(int [] dir:dirs){  //使用数组。
                     int x=i+dir[0];
                     int y=j+dir[1];
                     if(x<0 || x>=M.length || y<0 || y>=M[0].length){  //判断四周的数组是否有效。
                         continue;
                     }else{
                         count++;
                         sum+=M[x][y];
                     }
                 }
                 
                 array[i][j] = sum/count;
             }
         }
        
         return array;
    }
}

解法：（反例：垃圾的算法）

分为好几次遍历：

* 每个元素影响其下面的元素。

*每个元素影响其上面的元素。

*每个元素影响其斜对角的元素。

class Solution {

    public int[][] imageSmoother(int[][] M) {
    	
    	if(M.length == 1 && M[0].length == 1){
    		return M;
    	}
        //1.让每个results中的单元，保留周围元素的和。
        int results[][] = new int[M.length][M[0].length];
        for(int i = 0; i < M.length ; i++){
        	for(int j = 0; j < M[0].length ;j++){
        		results[i][j] = M[i][j];
        	}
        	}
        // 从左向右
        for(int i = 0; i < M.length ; i++){
        	for(int j = 0; j < M[0].length ;j++){
        		if(i < M.length -1){
        			results[i+1][j] += M[i][j];
        		}
        		if(j < M[0].length-1){
        			results[i][j+1] += M[i][j];
        			
        		}
        		if(i < M.length -1 && j < M[0].length-1){
        			results[i+1][j+1] += M[i][j];
        		}
        	}
        }
        
        //从右向左，每个节点去影响周围的元素。
        for(int i = M.length -1; i >= 0;i--){
        	for(int j = M[0].length - 1; j >= 0;j--){
        		if(i > 0){
        			results[i-1][j] += M[i][j];
        		}
        		if(j > 0){
        			results[i][j-1] += M[i][j];
        		if(i > 0 && j > 0){
        			results[i-1][j-1] += M[i][j];
        		}
        	}
        }
    }
        //影响斜对角。
        for(int i = 0; i < M.length ; i++){
        	for(int j = 0; j < M[0].length ;j++){
        		if(i+1 <= M.length -1 && j-1 >= 0){
        			results[i+1][j-1] += M[i][j];
        		}
        		
        		if(i-1 >=0 && j+1 <= M[0].length -1){
        			results[i-1][j+1] += M[i][j];
        		}
        	}}
        
        //2.计算平均值。
        for(int i = 0; i < M.length ; i++){
        	for(int j = 0; j < M[0].length ;j++){
        	int	count = 9;//记录周围元素的数量
            int row = 0;
        	if(i == 0){
        		count -= 3;//顶行，去除3个元素
        		row++;
        	}
        	if(i == M.length-1){
        		count -= 3;//最底行，去除3个元素
        		row++;
        	}
        	
        	if(j == 0){
        		count -=3;//最左列，去除3个元素
        		count += row;//加上多去的。（行与列产生了交叉）
        	}
        	if(j == M[0].length-1){
        		count -= 3;
        		count += row;
        	}
        	results[i][j] = results[i][j]/count;
        	}
        	}
        return results;
}

}