刷题记录:牛客NC20242[SCOI2005]最大子矩阵

传送门:牛客

题目描述:

这里有一个n*m的矩阵，请你选出其中k个子矩阵，使得这个k个子矩阵分值之和最大。
注意：选出的k个子矩阵 不能相互重叠
输入:
3 2 2
1 -3
2 3
-2 3
输出:
9
1
2
3
4
5
6
7
8
9

经典dp题,难度挺高.但是作为经典题,想不出来没关系最重要的的应该是记住这一类题目的解法

对于这道题,最重要的的是m的范围,我们发现m只有$1或者2两个$值可以选择.所以我们接下来就$m=1$和$m=2$分开来分析

对于m=1

我们此时只有一列,因此我们可以使用$dp[i][j][k]$记录前i行使用了j个矩阵并且当前矩阵是否使用的最大分值

那么我们考虑一下如何进行转移.首先假设我们当前的这一行是不取用的.那么显然的我们此时就直接沿用直接的即可,也就是
$dp[i][j][0]=max(dp[i-1][j][1],dp[i-1][j][0])$

假设我们当前这一行是取用的,那么有两种可能性,要么我们这一行用了新的一个矩阵,要么和 之前的那一个矩阵合成一个矩阵,有
$dp[i][j][1]=max(dp[i-1][j][1],dp[i-1][j-1][1],dp[i-1][j-1][0])+a[i][1]$

那么显然我们最后的答案就是$max(dp[n][k][1],dp[n][k][0])$

对于m=2

我们此时有两列了,所以显然是不能直接套用之前的模板了.但是我们此时可以类比之前的做法.此时我可以使用
$0状态记录这一行的两个数都不选$
$1状态记录这一行记录左边的数字$
$2状态记录右边的数字$
$3状态记录这一行选两个数字但是两个数字是在同一个矩阵里$
$4状态记录这一行选两个数字但是两个数字不在同一个矩阵里$

那么对于0状态,显然我们直接转移前面的那一行即可:

$dp[i][j][0]=max(dp[i-1][j][0/1/2/3/4])$

对于1状态,我们可以从前面的1,4状态进行转移也可以直接新开一个矩阵

$dp[i][j][1]=max(dp[i-1][j][1/4])+a[i][1]$

$dp[i][j][1]=max(dp[i-1][j-1][0/1/2/3/4])+a[i][1]$

对于2状态,我们可以从前面的2,4状态转移也可以直接新开一个矩阵

$dp[i][j][2]=max(dp[i-1][j][2/4])+a[i][2]$

$dp[i][j][2]=max(dp[i-1][j-1][0/1/2/3/4])+a[i][2]$

对于3状态,我们可以从状态3转移,也可以直接新开一个矩阵

$dp[i][j][3]=max(dp[i-1][j][3])+a[i][1]+a[i][2]$

$dp[i-1][j-1][3]=max(dp[i-1][j-1][0/1/2/3/4])+a[i][1]+a[i][2]$

对于4状态,我们可以从状态1,2,3进行转移,但是此时如果是1,2将需新开一个矩阵(因为我们此时只有一边是存在的),如果是4不用开矩阵,当然也可以新开一个矩阵

$dp[i][j][4]=max(dp[i-1][j][4],dp[i-1][j-1][1/2])+a[i][1]+a[i][2]$

$dp[i][j][4]=max(dp[i-1][j-2][0/1/2/3/4])$

至此,我们的dp方程结束了

下面是具体的代码部分:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
#define ll_maxn 0x3f3f3f3f3f3f3f3f
const double eps=1e-8;
int n,m,k;
int dp[200][200][10];
int a[200][200];
int main() {
	n=read();m=read();k=read();
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=m;j++) {
			a[i][j]=read();
		}
	}
	memset(dp,-0x3f,sizeof(dp));
	for(int i=1;i<=4;i++) dp[0][0][i]=0;
	if(m==1) {
		for(int i=1;i<=n;i++) {
			for(int j=0;j<=k;j++) {
				dp[i][j][0]=max(dp[i-1][j][0],dp[i-1][j][1]);
				if(j) dp[i][j][1]=max(dp[i-1][j][1],max(dp[i-1][j-1][0],dp[i-1][j-1][1]))+a[i][1];
			}
		}
		cout<<max(dp[n][k][0],dp[n][k][1])<<endl;
	}else {
		for(int i=1;i<=n;i++) {
			for(int j=0;j<=k;j++) {
				for(int q=0;q<=4;q++) dp[i][j][0]=max(dp[i][j][0],dp[i-1][j][q]);
				if(j) {
					dp[i][j][1]=max(dp[i][j][1],max(dp[i-1][j][1],dp[i-1][j][4]))+a[i][2];
					for(int q=0;q<=4;q++) dp[i][j][1]=max(dp[i][j][1],dp[i-1][j-1][q]+a[i][2]);
					dp[i][j][2]=max(dp[i][j][2],max(dp[i-1][j][2],dp[i-1][j][4]))+a[i][1];
					for(int q=0;q<=4;q++) dp[i][j][2]=max(dp[i][j][2],dp[i-1][j-1][q]+a[i][1]);
					dp[i][j][3]=max(dp[i][j][3],dp[i-1][j][3])+a[i][1]+a[i][2];
					for(int q=0;q<=4;q++) dp[i][j][3]=max(dp[i][j][3],dp[i-1][j-1][q]+a[i][1]+a[i][2]);
					if(j>1) {
						dp[i][j][4]=max(dp[i][j][4],max(max(dp[i-1][j-1][1],dp[i-1][j-1][2]),dp[i-1][j][4]))+a[i][1]+a[i][2];
						for(int q=0;q<=4;q++) dp[i][j][4]=max(dp[i][j][4],dp[i-1][j-2][q]+a[i][1]+a[i][2]);
					}
					
				}
			}
		}
		int ans=-inf;
		for(int i=0;i<=4;i++) ans=max(ans,dp[n][k][i]);
		cout<<ans<<endl;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71