HDU-2845 Beans（两次线性dp）

Beans

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5308    Accepted Submission(s): 2451

Problem Description

Bean-eating is an interesting game, everyone owns an M*N matrix, which is filled with different qualities beans. Meantime, there is only one bean in any 1*1 grid. Now you want to eat the beans and collect the qualities, but everyone must obey by the following rules: if you eat the bean at the coordinate(x, y), you can’t eat the beans anyway at the coordinates listed (if exiting): (x, y-1), (x, y+1), and the both rows whose abscissas are x-1 and x+1.


Now, how much qualities can you eat and then get ?

 

Input

There are a few cases. In each case, there are two integer M (row number) and N (column number). The next M lines each contain N integers, representing the qualities of the beans. We can make sure that the quality of bean isn't beyond 1000, and 1<=M*N<=200000.

 

Output

For each case, you just output the MAX qualities you can eat and then get.

 

Sample Input

  
  

   
   4 6
11 0 7 5 13 9
78 4 81 6 22 4
1 40 9 34 16 10
11 22 0 33 39 6
  
  

 

Sample Output

  
  

   
   242
  
  

#include <bits/stdc++.h>
using namespace std;
int a[2001][2001], dp[2001][2], cnt[2001][2];
int main(){
	int r, c;
	while(scanf("%d %d", &r, &c) != EOF){
		for(int i = 1; i <= r; ++i){
			for(int j = 1; j <= c; ++j){
				scanf("%d", &a[i][j]);
			}
		}
		dp[0][0] = dp[0][1] = 0;
		for(int i = 1; i <= r; ++i){
			cnt[0][0] = cnt[0][1] = 0;
			for(int j = 1; j <= c; ++j){
				cnt[j][0] = max(cnt[j - 1][0], cnt[j - 1][1]);
				cnt[j][1] = cnt[j - 1][0] + a[i][j];
			}
			dp[i][1] = dp[i - 1][0] + max(cnt[c][0], cnt[c][1]);
			dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
		}
		printf("%d\n", max(dp[r][0], dp[r][1]));
	}
}

/*
题意：
一个网格，每个格子上有一个豆子，豆子有一个价值，如果拿走这个豆子，那么其所在行的
上下行的豆子都不能拿，且其左右两个格子上的豆子也不能拿。问最多可以得到多少价值的豆子。

思路：
分两层线性dp，显然对于每一行，每一列格子上的豆子取不取的最大价值只和前一列取不取有关，
所以可以有cnt[i][0]表示第i列不取时的最大价值，cnt[i][1]表示取的最大价值。
现在转移方程可以是cnt[i][0] = max(cnt[i - 1][1], cnt[i - 1][0]), cnt[i][1] = cnt[i - 1][0] + a[i][j];
这样可以计算出每一行有格子取时的最大价值。对于每一行，其取不取的最大价值只和前一行取不取有关，
那么可以有dp[i][0] = max(dp[i - 1][1], dp[i - 1][0]); dp[i][1] = dp[i - 1][0] + w。w为第i行取的最大价值。
*/