题意:如图中所示,选一个数后,它左右两边的数   和   上下2行的数不能再选,问这样选出的数和的最大值思路:对每一行求出:这一行选数字的最大值(也就是 i行 做一个最大值dp[i] ,则这一行的最大值是 dp[i][m] )对列来求dp时 ,已知每一行的最值是 dp[i][m],则这里做一个小dp2mark#include #include #define N 2000in            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-08-13 13:40:28
                            
                                67阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            #include#define N 200100int f[N];int a[N],n;int main() {int m,j,i,suma,sumb,sumc,sumd;while(scanf("%d%d",&m,&n)!=EOF) { for(i=1;isumb) sumc=suma+f[(...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2013-11-06 18:28:00
                            
                                26阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            本来是很简单的一道题,却想了好长时间由于数据量比较大,所以逐行读入,逐行处理先处理每一行的不相邻元素和的最大值,记录在数组b中最后计算不相邻行的和的最大值二者的状态转移方程都类似:dp[j] = max(dp[j - 1], dp[j - 2] + a[j]); 1 //#define LOCAL ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2014-07-27 09:22:00
                            
                                64阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            链接:http://acm.hdu.edu.cn/showproblem.php?pid=2845  Beans  Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)   Total Submission(s): 973               
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2011-08-17 10:26:42
                            
                                418阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            思路:动态规划  对于一行来说,相邻的数不可同时取,容易得到状态转移方程:           dp[i]=max(dp[i-2]+a[i],dp[i-1]);  然后取每一行的最大得b[i] ,又可看作一行相同处理            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-03-03 12:42:43
                            
                                96阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            BeansTime Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1433Accepted Submission(s): 741Problem DescriptionBean-eating is an interesting game, everyone owns an M*N matrix, which is filled with different qualities beans. Meantime, there is only one bean            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-07-29 16:24:58
                            
                                42阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            BeansTime Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1819Accepted Submission(s): 921 Problem DescriptionBean-eating is an interesting game, everyone owns an M*N matrix, which is filled with different qualities beans. Meantime, there is only one be            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2013-03-24 22:56:00
                            
                                57阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2845分析:题目意思就是不能有任小,即c[i]=c[i]+max(c[i-2],c[i-3]);那么对于每一列也同样考虑.            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2013-05-10 21:24:00
                            
                                44阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Beans
Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3011    Accepted Submission(s): 1450
Problem Description
Bean-eating is an intere            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-04-24 08:36:42
                            
                                36阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Description
            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-02-03 10:02:07
                            
                                28阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Problem Description Bean-eating is an interesting game, everyone owns an M*N matrix, which is filled with different qualities beans. Meantime, there i            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2016-03-25 16:19:00
                            
                                57阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            
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 t            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2015-07-17 19:51:00
                            
                                51阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            小记:之前因为N*M<= 20W,所以我是使用            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-07-18 18:40:28
                            
                                48阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            思路:二维动态规划,先求每一行的最大和,组成新的一
#include
int r[200010][2],c[200010][2];
int max(int a,int b)
{
       if(a>b)
              return a;
       return b;
}
main()
{
	int i,j,R,C,s;
	            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-06-09 18:31:57
                            
                                64阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            BeansTime Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 2596Accepted Submission(s): 1279Problem Descr...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2015-10-11 17:45:00
                            
                                107阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            本文是一篇关于java独立的帖子BeansTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1945              
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2013-05-24 21:46:00
                            
                                66阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            原题链接: http://acm.hdu.edu.cn/showproblem.php?            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-12-06 19:16:17
                            
                                69阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            dp[i] = max ( dp[i-2] + num[i]  , dp[i-1] )没什么好解释的,经典模板题#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define MAX  200007
using namespace             
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-04-24 01:47:15
                            
                                45阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2845思路:对于一行来说,相邻的数不可同时取,容易得到状态转移方程:sum[i] = max (sum[i-2]+sum[i], sum[i-1]),其中sum[i]表示一行前i个数时的最大和;然后把sum[m]保存到另一个数组中,对于每一行都这么做,然后最后在对数组再次进行一边这样的操作就行了;View Code 1 #include<iostream> 2 const int N=200020; 3 using namespace std; 4 5 int a[N],b[N]; 6            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2013-03-12 21:42:00
                            
                                81阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            题目地址:点击打开链接
思路:参考了别人的思想,开了四个数组A了,想想其实开3个数组就行了,结果看大神的代码开了2个直接A了,没看懂。            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-08-04 14:09:37
                            
                                42阅读