试题 F: 统计子矩阵

题目链接：

点击跳转

题目描述：

给定一个 N×M 的矩阵 A，请你统计有多少个子矩阵 (最小 1×1，最大 N×M) 满足子矩阵中所有数的和不超过给定的整数 K?

输入格式 第一行包含三个整数 N,M 和 K。

之后 N 行每行包含 M 个整数，代表矩阵 A。

输出格式 一个整数代表答案。

数据范围
对于 30% 的数据，N,M≤20，
对于 70% 的数据，N,M≤100，
对于 100%的数据，1≤N,M≤500;0≤Aij≤1000;1≤K≤250000000。

输入样例：

3 4 10
1 2 3 4
5 6 7 8
9 10 11 12

输出样例：

19

样例解释：

满足条件的子矩阵一共有 19，包含：

• 大小为 1×1 的有 10 个。
• 大小为 1×2 的有 3 个。
• 大小为 1×3 的有 2 个。
• 大小为 1×4 的有 1 个。
• 大小为 2×1 的有 3 个。

题目分析：

• 分析：要求整个矩阵中每个矩阵的和小于等于k的有多少个，暴力的做法是枚举每个点为起点，和枚举每个点为终点，这样就可以得到所有的子矩阵（不重不漏），但时间复杂度是O(n${}^4$),会超时，那么必有优化
• 思路：可以从枚举每个点转换为枚举每一列，以每一列为起点，和枚举每一列为终点得到所有以起点列为上界，终点列为下届的所有矩阵。枚举每一个矩阵的长度，从 1 ~ m ,这样就可以得到所有的矩阵。
• 此时题目就变成了求一条矩阵中能的所有子矩阵的和小于等于 k 的个数有多少个，这里就可以用 双指针的思维来做，last 代表左边界，从 1 开始， k 代表右边届，也从 1 开始，那么当前这个矩阵中能满足子矩阵的和小于等于 k 的个数就一共有 k - last + 1 个矩阵，如果当前矩阵的大小大于 k 了，那么
  last 就向前移动，一直到满足小于等于 k 位置，当 last 走到 m 点时，此时所有小于等于 k 的子矩阵的个数已经全部被算出来了。

算法1：

前缀和+双指针 – 时间复杂度O（n${}^3$）：

代码：

/*
 * @Author: suhuamo
 * @Date: 2022-04-12 11:38:35
 * @LastEditTime: 2022-04-13 15:23:13
 * @FilePath: \algorithm\蓝桥杯\第十三届蓝桥杯省赛B\F.cpp
 * @slogan: 也许散落在浩瀚宇宙的小行星们也知道
 * 知识点: 前缀和+双指针+二维优化
 * 暴力是枚举以每个点为起点,每个点为终点,需要O(n*n*n*n),但是实际上可以优化为
 * 枚举每一行为起点,每一行为终点,然后遍历每一列,并且采取贪心的做法,只会线性遍历当前这一列,
 * 优化为O(n*n*n)
 */
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 510;
int n, m, K;
int a[N][N];
LL s[N][N];
int main()
{
    cin >> n >> m >> K;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            cin >> a[i][j];
    for(int j = 1; j <= m; j++)
        for(int i = 1; i <= n; i++)
            s[i][j] = s[i - 1][j] + a[i][j];
    
    LL res = 0;
    for(int i = 1; i <= n; i++)
        for(int j = i; j <= n; j++)
        {
            int last = 1;
            LL sum = 0;
            for(int k = 1; k <= m; k++)
            {
                LL r = s[j][k] - s[i - 1][k];
                if(sum + r <= K)
                {
                    sum += r;
                    res += (k - last + 1);
                }
                else
                {
                    LL l = s[j][last] - s[i - 1][last];
                    while(last != k && sum + r > K)
                    {
                        sum -= l;
                        last++;
                        l = s[j][last] - s[i - 1][last];
                    }
                    if(sum + r <= K)
                    {
                        sum += r;
                        res += (k - last + 1);
                    }
                    else
                    {
                        last++;
                    }
                }
            }
        }
    cout << res << endl;
    return 0;
}