2021.9.9 CCF-邻域均值

试题背景

顿顿在学习了数字图像处理后，想要对手上的一副灰度图像进行降噪处理。不过该图像仅在较暗区域有很多噪点，如果贸然对全图进行降噪，会在抹去噪点的同时也模糊了原有图像。因此顿顿打算先使用邻域均值来判断一个像素是否处于较暗区域，然后仅对处于较暗区域的像素进行降噪处理。

问题描述

待处理的灰度图像长宽皆为 n 个像素，可以表示为一个 n×n 大小的矩阵 A，其中每个元素是一个 [0,L) 范围内的整数，表示对应位置像素的灰度值。
对于矩阵中任意一个元素 Aij（0≤i,j<n），其邻域定义为附近若干元素的集和：

                Neighbor(i,j,r)={Axy|0≤x,y<n and |x−i|≤r and |y−j|≤r}

这里使用了一个额外的参数 r 来指明 Aij 附近元素的具体范围。根据定义，易知 Neighbor(i,j,r) 最多有 (2r+1)2 个元素。

如果元素 Aij 邻域中所有元素的平均值小于或等于一个给定的阈值 t，我们就认为该元素对应位置的像素处于较暗区域。
下图给出了两个例子，左侧图像的较暗区域在右侧图像中展示为黑色，其余区域展示为白色。

现给定邻域参数 r 和阈值 t，试统计输入灰度图像中有多少像素处于较暗区域。

输入格式

输入共 n+1 行。

输入的第一行包含四个用空格分隔的正整数 n、L、r 和 t，含义如前文所述。

第二到第 n+1 行输入矩阵 A。
第 i+2（0≤i<n）行包含用空格分隔的 n 个整数，依次为 Ai0,Ai1,⋯,Ai(n−1)。

输出格式

输出一个整数，表示输入灰度图像中处于较暗区域的像素总数。

样例输入

4 16 1 6
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

样例输出

7

 这道题想了好久还是只能采取暴力解法，但是暴力解法只能拿到70分，会有几个样例超时：

#include<iostream>
#include<vector>

using namespace std;

int main() {
    int n, L, r, t;
    cin >> n >> L >> r >> t;
    int count = 0;
    vector<vector<int>> A(n, vector<int>(n));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cin >> A[i][j];
        }
    }
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            int sum = 0;
            int num = 0;
            int left = j - r >= 0 ? j - r : 0;
            int right = j + r <= n - 1 ? j + r : n - 1;
            int up = i - r >= 0 ? i - r : 0;
            int down = i + r <= n - 1 ? i + r : n - 1;
            for (int k = up; k <= down; k++)
            {
                for (int m = left; m <= right; m++)
                {
                    sum += A[k][m];
                    num++;
                }
            }
            double average = (double)sum / num;
            if (average <= t) count++;
        }
    }
    cout << count;
    return 0;
}

于是去看了别人的题解，发现所考的知识点是二维前缀和，自己还是第一次听说这个名词和方法，其大致思想是这样的：

                                

 我们假设图中的这么一个矩形，其中区域①是区域A和区域B的交界区域，那么在已知区域A、B、C的面积的前提下，求整个矩形的面积就如图中的第一个式子所示。

之后就好理解二维前缀和的定义及递推式了，如下：

	定义式	递推式
二维前缀和

求二维前缀和的方法为：

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + A[i][j];
        }
    }

这里i和j都是从1开始的，是为了空出一个全为0的第0行和第0列，方便使用递推式。

那么在求完二维前缀和后，假设我们要求矩阵中某一个区域的元素和，那就简单了，还是类比以下这个矩形：

        ​​​​​​​        ​​​​​​​        ​​​​​​​       

 求某一区域的元素和，类比于在已知整个矩形的面积、A的面积、B的面积的前提下，求C的面积，即图中的第二个式子所示。

所以求某一区域的元素和的方法为：

    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            int total = 0;
            int num = 0;
            int left = max(1 , j - r);  
            int right = min(j + r , n); 
            int up = max(1 , i - r);  
            int down = min(i + r , n);

            total = sum[down][right] - sum[down][left - 1] - sum[up - 1][right] + sum[up - 1][left - 1];
            num = (right - left + 1) * (down - up + 1);
            double average = (double)total / num;
            if (average <= t) count++;
        }
    }

其中，left、right、up、down分别表示这个区域的左边界、右边界、上边界和下边界。

完整的代码：

#include<iostream>
#include<vector>

using namespace std;

int main() {
    int n, L, r, t;
    cin >> n >> L >> r >> t;
    int count = 0;
    vector<vector<int>> A(n + 1 , vector<int>(n + 1));
    vector<vector<int>> sum(n + 1, vector<int>(n + 1));
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cin >> A[i][j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + A[i][j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            int total = 0;
            int num = 0;
            int left = max(1 , j - r);  
            int right = min(j + r , n); 
            int up = max(1 , i - r);  
            int down = min(i + r , n);

            total = sum[down][right] - sum[down][left - 1] - sum[up - 1][right] + sum[up - 1][left - 1];
            num = (right - left + 1) * (down - up + 1);
            double average = (double)total / num;
            if (average <= t) count++;
        }
    }
    cout << count;
    return 0;
}