蓝桥杯2022年第十三届省赛真题-统计子矩阵

骑母猪去兜风

于 2023-04-05 18:51:57 发布

阅读量123

点赞数 1

分类专栏：蓝桥杯题解文章标签：蓝桥杯矩阵算法

本文链接：https://blog.csdn.net/QMZQDF/article/details/129974816

版权

蓝桥杯题解专栏收录该内容

4 篇文章 0 订阅

订阅专栏

题目 2659:

蓝桥杯2022年第十三届省赛真题-统计子矩阵

时间限制: 1s 内存限制: 256MB 提交: 1647 解决: 925

题目描述

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

输入格式

第一行包含三个整数 N, M 和 K.

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

输出格式

一个整数代表答案。

样例输入

样例输出

提示

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

大小为 1 × 1 的有 10 个。

大小为 1 × 2 的有 3 个。

大小为 1 × 3 的有 2 个。

大小为 1 × 4 的有 1 个。

大小为 2 × 1 的有 3 个。

对于 30% 的数据，N, M ≤ 20. 对于 70% 的数据，N, M ≤ 100.

对于 100% 的数据，1 ≤ N, M ≤ 500; 0 ≤ Ai j ≤ 1000; 1 ≤ K ≤ 250000000.

思路

朴素解法：

枚举起点和终点并遍历累加时间复杂度On^6，不用考虑了

前缀和

二维数组记录(1,1)到(i,j)的矩阵和

易知：pre[i][j] = v[i][j] + pre[i][j - 1] + pre[i - 1][j] - pre[i - 1][j - 1];

那么对任意矩阵有

左上角(x,y)、右下角(i,j)
矩阵和 = pre[i][j] - pre[x-1][j] - pre[i][y-1] + pre[x-1][y-1]

处理pre需要n^2
如果遍历左上角和右下角需要n^4
这同样很难接受

hhh没想到什么好方法了
不过可以对暴力解法稍微优化一点点
即对满足区域不断分割

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

       以右下角1为最后一个点为例，如果遍历到5满足矩阵和<=k，那么6、7、8、9、10、11、1这几个点就不需要遍历了。
       当然最差条件下还是n^4(只有右下角满足条件，例如上例中k=1)
       所以为了避免最坏条件，我们要倒着来遍历

具体看代码
       时间复杂度分析：
       枚举右下角O(n*m)、遍历O(n+m)
       时间复杂度为O(n*n*m+n*m*m)如果n==m为O(n^3)
       勉强能接受

#include<iostream>
#include<vector>
#include <numeric>
#include<set>
#include <queue>
#include <unordered_map> 
#include<unordered_set>
#include<math.h> 
#include<algorithm>
#include<stack>
#include<string>
#include<map>
#define PI acos(-1) 
using namespace std;
typedef long long ll;
const ll INF = -1;
const ll mod = 1e9 + 7;
int n, m, k;
int main() { 
	cin >> n >> m >> k;
	vector<vector<int>>v(n + 1, vector<int>(m + 1));
	vector<vector<int>>pre(n + 1, vector<int>(m + 1));
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> v[i][j];
			pre[i][j] = v[i][j] + pre[i][j - 1] + pre[i - 1][j] - pre[i - 1][j - 1];
		}
	}
	ll ans = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {  //枚举右下角
			//枚举边界 
			int r = j;
			int x = 1;
			int y = r;
			while (y <= r && x <= i) {
				if (y == 0) { //说明遍历到的地方全部满足
					ans += (i - x + 1) * r;
					break;
				}
				// 这个点不满足
				if (pre[i][j] - pre[x - 1][j] - pre[i][y - 1] + pre[x - 1][y - 1] > k) {
					ans += (i - x + 1) * (r - y);
					//注意 r 要左移
					r = y;
					//起点往下一格
					x++;
				}
				else y--;
			}
		}
	}
	cout << ans;
}

挂了一个测试点

百思不得其解，服务器有那么垃圾吗？500*500*500不过125000000真的跑不完？

后面又想了一种优化，还是挂了，甚至挂更多(应该不是优化不给力，比较差异的话，就是新版中多了一个vector多维数组)

呵呵，猜是vector的问题

换成以下代码

#include<iostream>
#include<vector>
#include <numeric>
#include<set>
#include <queue>
#include <unordered_map> 
#include<unordered_set>
#include<math.h> 
#include<algorithm>
#include<stack>
#include<string>
#include<map>
#define PI acos(-1) 
using namespace std;
typedef long long ll;
const ll INF = -1;
const ll mod = 1e9 + 7;
int n, m, k;
int pre[505][505];
int v[505][505];
int main() { 
	cin >> n >> m >> k; 
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			cin >> v[i][j];
			pre[i][j] = v[i][j] + pre[i][j - 1] + pre[i - 1][j] - pre[i - 1][j - 1];
		}
	}
	ll ans = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {  //枚举右下角
			//枚举边界 
			int r = j;
			int x = 1;
			int y = r;
			while (y <= r && x <= i) {
				if (y == 0) { //说明遍历到的地方全部满足
					ans += (i - x + 1) * r;
					break;
				}
				// 这个点不满足
				if (pre[i][j] - pre[x - 1][j] - pre[i][y - 1] + pre[x - 1][y - 1] > k) {
					ans += (i - x + 1) * (r - y);
					//注意 r 要左移
					r = y;
					//起点往下一格
					x++;
				}
				else y--;
			}
		}
	}
	cout << ans;
}

AC了

该死的vector，泪目，以此篇记录当菜鸟debug的日常。。。

当然还能优化

顺序遍历右下角会发现有很多重复运算

而逆序遍历会告诉我们更多信息

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

例如以右下角为例，如果已知i=1时，j=2成立，那么对于11或者8，j=2必定满足

我们新一轮的遍历就不用傻傻的以j为r了
所以我们要记录每个点的每行的最小j
对于(i,j)取(i+1,j)或者(i,j+1) 或j的最小值

以下是对应部分的代码

for (int i = n; i >= 1; i--) {
		for (int j = m; j >= 1; j--) {
			int x = 1;
			int r = j;
			int y = min({ j,q[i][j + 1][x] ,q[i + 1][j][x] });
			while (y <= r && x <= i) {
				if (y == 0) { //说明遍历到的地方全部满足
					ans += (i - x + 1) * r;
					q[i][j][x] = 0;
					break;
				}
				// 这个点不满足
				if (pre[i][j] - pre[x - 1][j] - pre[i][y - 1] + pre[x - 1][y - 1] > k) {
					ans += (i - x + 1) * (r - y);
					//记录在该行的最左端点
					q[i][j][x] = y;
					//注意 r 要左移
					r = y;
					//起点往下一行
					x++;
					//并且y要进行移位
					y = min({ y,q[i][j + 1][x] ,q[i + 1][j][x] });
				}
				else y--;
			}
		}
	}