Robberies 点击打开链接

背包;第一次做的时候把概率当做背包(放大100000倍化为整数):在此范围内最多能抢多少钱  最脑残的是把总的概率以为是抢N家银行的概率之和… 把状态转移方程写成了f[j]=max{f[j],f[j-q[i].v]+q[i].money}(f[j]表示在概率j之下能抢的大洋);

 正确的方程是:f[j]=max(f[j],f[j-q[i].money]*q[i].v)  当中,f[j]表示抢j块大洋的最大的逃脱概率,条件是f[j-q[i].money]可达,也就是之前抢劫过;

 始化为:f[0]=1,其余初始化为-1  (抢0块大洋肯定不被抓嘛)

/*
因为眼下实力有限,所以仅仅能看讨论板里的说法 本题题意:实际就是一个01背包,去抢银行,可是他母亲须要測试一下是否安全,測试方法就是 找到一些银行的 被盗金额和盗取该金额的被抓的概率。求他在给定的安全概率下能抢的最多的钱 我们能够从相反的样例来探讨,就是讨论他逃跑的概率 所以每一次抢劫一次钱的逃跑概率就是P=1-P; 我们须要得到他不被抓的概率下的最大金额,dp[i]就是他的不被抓的概率 由初中的知识能够知道要想两个时间同一时候发生如果事件A发生的概率为p(A),b发生的概率为p(b),则两事件同一时候发生的概率为p(A)*p(b); 所以我们得到状态方程为 dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]*w[j]);//须要解释一下这个地方, 我们须要找出本题的背包容量 本题另一个重要的地方就是要注意精度问题,float; 补充一下 0 1背包的概念就是当前事件的决策,做还是不做。 一般的0 1背包问题的状态方程为dp[i]=max(dp[i],dp[i-m[i]]);
*/
#include<iostream>
#include<cstring>
#include<cstdio>
#define max(a,b) (a>b?a:b)
using namespace std;
int main()
{
int t,i,j,n,m[110];
float P,p[110],dp[10010];
scanf("%d",&t);
while(t--)
{
memset(dp,0,sizeof(dp));
int sum=0;
cin>>P>>n;
P=1-P;
for(i=1;i<=n;i++)
{
cin>>m[i]>>p[i];
sum+=m[i];
p[i]=1-p[i];
}
dp[0]=1;
for(i=1;i<=n;i++)
{
for(j=sum;j>=m[i];j--)
{
dp[j]=max(dp[j],dp[j-m[i]]*p[i]);
}
}
for(i=sum;i>=0;i--)
{
if(dp[i]>=P)
{
break;
}
}
cout<<i<<endl;
}
return 0;
}

最大报销额

又一个背包问题,对于每张发票,要么报销,要么不报销,0-1背包,张数即为背包;

    转移方程:f[j]=max(f[j],f[j-1]+v[i]);

    恶心地方:有这种输入数据 3 A:100 A:200 A:300点击打开链接

    

最大连续子序列 点击打开链接

无力再吐槽我的编码能力有多弱了,真伤不起啊,一样的公式,仅仅是加了一些限制条件,并且关键就是杭电上的測试例子给的非常清楚了。

上我的代码吧:

#include<iostream>
#include<cstring>
#define max(a,b) a>b?a:b
using namespace std;
int main(int i)
{
int t,ans,step=1; int start,end,k;
int n,data[100001],sum[100001];
//cin>>t;
//while(t--)
//{ while(cin>>n&&n)
{
int out=0;
end=start=k=1;
ans=0;
for(i=1;i<=n;i++)
cin>>data[i];
for(i=1;i<=n;i++)
{
sum[i]=max(sum[i-1]+data[i],data[i]);
if(sum[i]>ans||(sum[i]>=ans&&sum[i]==0))
{
ans=sum[i];
start=k;
end=i;
}
if(sum[i]<0)
{
sum[i]=0;
k=i+1;
}
}
for(i=1;i<=n;i++)
{
if(data[i]>=0)
out=1;
}
if(!out)
{
start=1;
end=n;
}
//if(step!=1)
// cout<<endl;
// cout<<"Case "<<step<<":"<<endl;
cout<<ans<<" "<<data[start]<<" "<<data[end]<<endl;
//step++;
}
return 0;
}

状态方程:sum[i]=max(sum[i-1]+a[i],a[i]);最后从头到尾扫一边

    也能够写成:

                Max=a[0];

                Current=0;                for(i=0;i<n;i++)

                {                    if(Current<0)

                        Current=a[i];                    else

                        Current+=a[i];                    if(Current>Max)

                        Max=Current;

                }

    

max sum 点击打开链接

我先用不是动态规划的方法给个代码:

#include<iostream>
using namespace std;
int main(int i)
{
int t,sum,k,step=1;
int start,end;
int data[100000],n,m;
cin>>t;
while(t--)
{
k=1;
int max=-99999;
sum=0;
cin>>n;
for(i=1;i<=n;i++)
cin>>data[i];
for(i=1;i<=n;i++)
{
sum+=data[i];
if(max<sum)
{
max=sum;
start=k;
end=i;
}
if(sum<0)
{
sum=0;
k=i+1;
}
}
if(step!=1)
cout<<endl;
cout<<"Case "<<step<<":"<<endl;
cout<<max<<" "<<start<<" "<<end<<endl;
step++;
}
return 0; }

这是用dp写的,感觉都差点儿相同。

#include<iostream>
#include<cstring>
#define max(a,b) a>b?a:b
using namespace std;
int main(int i)
{
int t,ans,step=1;
int start,end,k;
int n,data[100001],sum[100001];
cin>>t;
while(t--)
{
end=start=k=1;
ans=-999999;
cin>>n;
for(i=1;i<=n;i++)
cin>>data[i];
for(i=1;i<=n;i++)
{
sum[i]=max(sum[i-1]+data[i],data[i]);
if(sum[i]>ans)
{
ans=sum[i];
start=k;
end=i;
}
if(sum[i]<0)
{
sum[i]=0;
k=i+1;
}
}
if(step!=1)
cout<<endl;
cout<<"Case "<<step<<":"<<endl;
cout<<ans<<" "<<start<<" "<<end<<endl;
step++;
}
return 0;
}

同上,最大连续子序列    

    

Largest Rectangle点击打开链接

对于每一块木板,Area=height[i]*(j-k+1)  当中,j<=x<=k,height[x]>=height[i];找j,k成为关键,一般方法肯定超时,利用动态规划,假设它左边高度大于等于它本身,那么它左边的左边界一定满足这个性质,再从这个边界的左边迭代下去    for(i=1;i<=n;i++)

        {                        while(a[l[i]-1]>=a[i])

                l[i]=l[l[i]-1];

                

        }        for(i=n;i>=1;i--)

        {            while(a[r[i]+1]>=a[i])

                r[i]=r[r[i]+1];

        }

    

City Game 点击打开链接

1506的加强版,把2维转换化成以每一行底,组成的最大面积;(注意处理连续与间断的情况);

    

Bone Collector 点击打开链接

简单0-1背包,状态方程:f[j]=max(f[j],f[j-v[i]]+w[i])

    

Super Jumping  点击打开链接

最大递增子段和,状态方程:sum[j]=max{sum[i]}+a[j]; 当中,0<=i<=j,a[i]<a[j]

这道题就是要找到的最大的递增的子序列,我们能够知道关键条件就是递增并且要

达到和最大,不是必需递增,能够得到它的状态方程sum[i]=max(sum[i]+a[i]);这个动态方程通俗的讲就是当你找到一个递增子序列以后,你要求出它们的和,并且它的和必须最大

<pre name="code" class="cpp">#include<iostream>
using namespace std;
int sum[100010],a[100010];
int main()
{ int maxn;
int m,n,i,j,k;
while(cin>>m&&m)
{ for(i=0;i<m;i++)
{
cin>>a[i];
}
maxn=sum[0]=a[0];
for(i=0;i<m;i++)
{
sum[i]=a[i];
for(j=0;j<i;j++)
{
if(a[i]>a[j])
{ sum[i]=max(sum[j]+a[i],sum[i]);//假设将sum[i]换成a[i]则将变成求最大连续递增子序列之和 } }
maxn=max(maxn,sum[i]);
}
cout<<maxn<<endl;
}
return 0;
}

命运点击打开链接

设 map[ i ][ j ] 表示走到坐标为(i, j)的格子时最大的幸运值。

      状态转移方程:

      map[ i ][ j ] = max { map [ i - 1][ j ], map [ i ] [ j - 1], map [ i ][ k ], k 为 j 的除去 j 的约数} + map[ i ][ j ] (注意边界的处理!)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define max(a,b) a>b?a:b
const int oo=2147483647;
int map[25][1100];
int main(int i,int j)
{
int C;
int n,m;
int hold;
cin>>C;
while(C--)
{
cin>>n>>m;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)
cin>>map[i][j];
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
{
hold=-oo;
if(i==1&&j==1)
continue;
if(i>1)
hold=max(hold,map[i-1][j]);
if(j>1)
hold=max(hold,map[i][j-1]);
for(int k=2;k<=(int)sqrt((double)j);k++)
if(j%k==0)
{
hold=max(hold,map[i][k]);
hold=max(hold,map[i][j/k]);
}
if(j!=1)
hold=max(hold,map[i][1]);
map[i][j]=hold+map[i][j]; }
}
cout<<map[n][m]<<endl;
}
return 0;
}

Monkey And Banana    点击打开链接

有一堆箱子,有长宽高,x,y,z。  规定:放在上面的箱子,不管长和宽都要比以下的箱子大,仅仅有一边大是不行的。

箱子的方向能够随意放。 这样,x,y,z就有六种组合。事实上也能够说是三种。

由于要和上面的箱子比較,这里为了计算方便,直接写成六种。

求的是最大高度。

这个题事实上和super jupming差点儿相同吧,仅仅只是要把他们进行排序,然后优化处理掉他们的相等的案例。

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
struct point
{
int x,y,z;
}blocks[100001]; int opt[100];
int a,b,c;
bool cmp(point a,point b)
{
if(a.x==b.x)
return a.y>b.y;
else
return a.x>b.x; }
int main()
{
int t;
int i;
int a,b,c;
int sum;
int cnt=0;
while(cin>>t&&t)
{
cnt++;
for(i=0;i<6*t;i+=6)
{
cin>>a>>b>>c;
/*
六种组合方式,将他们按从大到小排好
*/
blocks[i+1].x=b;
blocks[i+1].y=a;
blocks[i+1].z=c; blocks[i+2].x=c;
blocks[i+2].y=b;
blocks[i+2].z=a; blocks[i].x=a;
blocks[i].y=b;
blocks[i].z=c; blocks[i+3].x=a;
blocks[i+3].y=c;
blocks[i+3].z=b; blocks[i+4].x=b;
blocks[i+4].y=c;
blocks[i+4].z=a; blocks[i+5].x=c;
blocks[i+5].y=a;
blocks[i+5].z=b;
}
sort(blocks,blocks+6*t,cmp);
for(i=0;i<6*t;i++)
{
opt[i]=blocks[i].z;
for(int j=0;j<i;j++)
{
if((blocks[i].x<blocks[j].x&&blocks[i].y<blocks[j].y))//推断是否是按从大到小进行的排序
{
if(opt[i]<opt[j]+blocks[i].z)//动态方程
{
opt[i]=opt[j]+blocks[i].z;
}
}
}
}
int max=0;
for(int i=0;i<6*t;i++)
{
if(opt[i]>max)
max=opt[i];
}
cout<<"Case "<<cnt<<": maximun height ="<<max<<endl;
}
return 0;
}

状态方程:f[j]=max{f[i]}+v[j];当中,0<=i<=j,w[i]<w[j],h[i]<h[j]    

    

Big Event in HDU点击打开链接

一维背包,逐个考虑每一个物品带来的影响,对于第i个物品:if(f[j-v[i]]==0) f[j]=0;

    当中,j为逆序循环,且j>=v[i]    

    

数塔点击打开链接

自底向上:dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+v[i][j];    

    

免费馅饼点击打开链接

简单数塔

    自底向上计算:dp[i][j]=max(dp[i+1][j-1],dp[i+1][j],dp[i+1][j+1])+v[i][j];处理边界

    

I Need A Offer 点击打开链接

简单0-1背包,题目要求的是至少收到一份Offer的最大概率,我们得到得不到的最小概率就可以,状态转移方程:f[j]=min(f[j],f[j-v[i]]*w[i]);当中,w[i]表示得不到的概率,(1-f[j])为花费j元得到Offer的最大概率    

    

FATE 点击打开链接

二维全然背包,第二层跟第三层的要顺序循环;(0-1背包逆序循环);状态可理解为,在背包属性为 {m(忍耐度), s(杀怪个数)} 里最多能得到的经验值,之前的背包牺牲体积,这个背包牺牲忍耐度跟个数

    注意: 最后扫的时候 外层循环为忍耐度,内层循环为杀怪个数,由于题目要求出剩余忍耐度最大,没有约束杀怪个数,一旦找到经验加满的即为最优解;

    状态转移方程为: f[j][k]=max(f[j][k],f[j-v[i]][k-1]+w[i]); w[i]表示杀死第i个怪所得的经验值,v[i]表示消耗的忍耐度

    

How To Type 点击打开链接

用两个a,b数组分别记录Caps Lock开与关时打印第i个字母的最少操作步骤;

    而对于第i个字母的大写和小写还要分开讨论:

    Ch[i]为小写: a[i]=min(a[i-1]+1,b[i-1]+2);不开灯直接字母,开灯则先关灯再按字母,最后保持不开灯;    b[i]=min(a[i-1]+2,b[i-1]+2);不开灯则先按字母再开灯,开灯则Shift+字母(比关灯,按字母再开灯节省步数),最后保持开灯;

    Ch[i]为大写: a[i]=min(a[i-1]+2,b[i-1]+2); b[i]=min(a[i-1]+2,b[i-1]+1)

    

    最后,b[len-1]++,关灯嘛O(∩_∩)O~     

    

Coins点击打开链接

类似于HDU1171 Big Event In HDU,一维DP,可达可不达    

    

Beans点击打开链接

横竖分别求一下不连续的最大子段和;

    状态方程: Sum[i]=max(sum[j])+a[i];当中,0<=j<i-1;    

    

Largest Submatrix 点击打开链接

枚举a,b,c 最大全然子矩阵,类似于HDU1505 1506    

    

Matrix Swapping II点击打开链接

最大全然子矩阵,以第i行为底,能够构成的最大矩阵,由于该题能够随意移动列,所以仅仅要大于等于height[i]的都能够移动到一起,求出height>=height[i]的个数就可以,这里用hash+滚动,先求出height[i]出现的次数,然后逆序扫一遍hash[i]+=hash[i+1];    

    

最少拦截系统点击打开链接

两种做法,一是贪心,从后往前贪;二是DP;    if(v[i]>max{dp[j]})  (0<=j<len)

    dp[len++]=v[i];

用动态规划的话就是要求它的最大递增子序列,题目能理解就能做出来属于入门级的:

#include<iostream>
#include<cstring>
using namespace std;
#define max(a,b) a>b?a:b
int dp[100010],a[100010];
int main()
{
int i,j;
int n;
int maxn;
while(cin>>n&&n)
{
maxn=-99999;
//memset(dp,1,sizeof(dp));
for(i=0;i<n;i++)
{
cin>>a[i];
dp[i]=1;
}
for(i=1;i<n;i++)
{
for(j=0;j<i;j++)
if(a[i]>a[j])
dp[i]=max(dp[i],dp[j]+1);
maxn=max(maxn,dp[i]);
}
cout<<maxn<<endl;
}
return 0;
}

Common Subsequence点击打开链接

经典DP,最长公共子序列

    Len[i][j]={len[i-1][j-1]+1,(a[i]==b[j]); max(len[i-1][j],len[i][j-1])}

    初始化的优化:     for(i=0;i<a;i++)            for(j=0;j<b;j++)

                len[i][j]=0;        for(i=1;i<=a;i++)             for(j=1;j<=b;j++)                 if(ch1[i-1]==ch2[j-1]) 

                    len[i][j]=len[i-1][j-1]+1;                else 

                    len[i][j]=max(len[i-1][j],len[i][j-1]);    

    

★ 搬寝室点击打开链接

状态Dp[i][j]为前i件物品选j对的最优解

    当i=j*2时,仅仅有一种选择即 Dp[i-2][j-1]+(w[i]-w[i-1])^2

    当i>j*2时,Dp[i][j] = min(Dp[i-1][j],Dp[i-2][j-1]+(w[j]-w[j-1])^2)    

    

★ Humble Numbers点击打开链接

假设一个数是Humble Number,那么它的2倍,3倍,5倍,7倍仍然是Humble Number

    定义F[i]为第i个Humble Number

    F[n]=min(2*f[i],3*f[j],5*f[k],7*f[L]), i,j,k,L在被选择后相互移动

    (通过此题理解到数组有序特性)    

    

★ Doing Homework Again 点击打开链接

这题为贪心,经典题;

    切题角度,对于每一个任务要么在截至日期前完毕要么被扣分;所以考虑每一个人物的完毕情况就可以;由于每天仅仅能完毕一个任务,所以优先考虑分值较大的任务,看看该任务能不能完毕,仅仅要能完毕,即使提前完毕,占了其它任务的完毕日期也没关系,由于当前任务的分值最大嘛,而对于能完毕的任务能拖多久就拖多久,以便腾出很多其它时间完毕其它任务;    

    

How Many Ways 点击打开链接

两种D法,一是对于当前的点,那些点可达;二是当前点可达那些点;

    明显另外一种方法高,由于第一种方法有一些不是必需的尝试;

    Dp[i][j]+=Dp[ii][jj]; (map[ii][jj]>=两点的曼哈顿距离)

    值得优化的地方,每两点的曼哈顿距离可能不止求一次,所以预处理一下直接读取    

    

珍惜如今 感恩生活点击打开链接

直接转换成0 1背包

#include<cstdio>
#include<cstring>
#include<iostream>
#define max(a,b) a>b?a:b
using namespace std;
int c[105],v[105],cnt[105],dp[105];
int main()
{
int t,n,m,i,j,k;
cin>>t;
while(t--)
{
memset(dp,0,sizeof(dp));
cin>>n>>m;
for(i=1;i<=m;i++)
cin>>c[i]>>v[i]>>cnt[i];
for(i=1;i<=m;i++)
for(k=1;k<=cnt[i];k++)
for(j=n;j>=c[i];j--)
dp[j]=max(dp[j],dp[j-c[i]]+v[i]);
cout<<dp[n]<<endl;
}
return 0;
}

每一个物品最多可取n件,多重背包;

    利用二进制思想,把每种物品转化为几件物品,然后就成为了0-1背包    

    

Piggy-Bank 点击打开链接

全然背包;常规背包是求最大值,这题求最小值;

    仅仅须要改动一下初始化,f[0]=0,其它赋值为+∞就可以;

    状态转移方程:f[i][V]=max{f[i-1][V],f[i-1][V-k*v[i]]+k*w[i]},当中0<=k*v[i]<=V

    

★ Max Sum Plus Plus点击打开链接

1. 对于前n个数, 以v[n]为底取m段: 

    当n==m时,Sum[m][n]=Sum[m-1][n-1]+v[n],第n个数独立成段;

当n>m时, Sum[m][n]=max{Sum[m-1][k],Sum[m][n-1]}+v[n]; 当中,m-1<=k<j,解释为,v[n]要么加在Sum[m][n-1],段数不变,要么独立成段接在前n-1个数取m-1段所能构成的最大值后面2. 空间的优化:

        通过状态方程能够看出,取m段时,仅仅与取m-1段有关,所以用滚动数组来节省空间

    

FatMouse’s Speed 点击打开链接

要求:体重严格递增,速度严格递减,原始顺序不定

    按体重或者速度排序,即顺数固定后转化为最长上升子序列问题

    Dp[i]表示为以第i项为底构成的最长子序列,Dp[i]=max(dp[j])+1,当中0<=j<i , w[i]>w[j]&&s[i]<s[j] 用一个index数组构造最优解:记录每一项接在哪一项后面,最后用max找出最大的dp[0…n],dex记录下标,回溯输出就可以    

    

Cstructing Roads点击打开链接

以p或者r按升序排列以后,问题转化为最长上升子序列

    题目数据量比較大,仅仅能採取二分查找,n*log(n)的算法

用一个数组记录dp[]记录最长的子序列,len表示长度,假设a[i]>dp[len], 则接在后面,len++; 否则在dp[]中找到最大的j,满足dp[j]<a[i],把a[i]接在dp[j]后面;    

    

FatMouse Chees 点击打开链接

Dp思想,用记忆化搜索;简单题,处理好边界;    

    

To the Max 点击打开链接

最大子矩阵

    把多维转化为一维的最大连续子序列;(HDU1003)    

    

龟兔赛跑点击打开链接

未总结    

    

★ Employment Planning 点击打开链接

状态表示:    Dp[i][j]为前i个月的留j个人的最优解;Num[i]<=j<=Max{Num[i]};

                j>Max{Num[i]}之后无意义,无谓的浪费 记Max_n=Max{Num[i]};

    Dp[i-1]中的每一项都可能影响到Dp[i],即使Num[i-1]<<Num[i]

    所以利用Dp[i-1]中的全部项去求Dp[i];

    对于Num[i]<=k<=Max_n,    当k<j时, 招聘;

                            当k>j时, 解雇  然后求出最小值

    Dp[i][j]=min{Dp[i-1][k…Max_n]+(招聘,解雇,工资);    

    

Dividing 点击打开链接

一维Dp  Sum为偶数的时候推断Dp[sum/2]可不可达    

    

Human Gene Factions点击打开链接

状态转移方程:

f[i][j]=Max(f[i-1][j-1]+r[a[i]][b[j]], f[i][j-1]+r[‘-‘][b[j]],f[i-1][j]+r[a[i]][‘-‘]);



★ Doing Homework 点击打开链接

这题用到位压缩;

    那么任务全部的状态有2^n-1种

    状态方程为:Dp[next]=min{Dp[k]+i的罚时} 当中,next=k+(1<<i),k要取完满足条件的值 k>>i的奇偶性决定状态k

详细实现为: 对每种状态遍历n项任务,假设第i项没有完毕,则计算出Dp[next]的最优解    

    

Free DIY Tour 点击打开链接

简单的数塔Dp,考察的是细节的处理;

    Dp[i]=Max{Dp[j]}+v[i]  当中j->i为通路;

    v[n+1]有没有初始化,Dp数组有没有初始化

    这题不能用想当然的”最长路”来解决,这好像是个NP问题 解决不了的

    

    

重温世界杯点击打开链接

这题的状态不难理解,状态表示为,假设上一个城市剩下的钱不为负,也就是没有被赶回杭电,则再考虑它对下一个城市的影响;假设上一个城市剩下的前加上当前城市的前大于当前城市的生活费,那么Dp[i]=Dp[i-1]+1;

值得注意的而是这题的数据为100000;不可能以每一个城市为起点来一次Dp,时间复杂度为n^2;足已超时;

我是这样处理的,在保存的数据后面再接上1…n的数据,这样扫描一遍的复杂度为n;再加一个优化,当Dp[i]==n时,也就是能所有游完所有城市的时候,直接break;



Pearls 点击打开链接

Dp[i]=min{Dp[j]+V},  0<=j<i, V为第j+1类珠宝到第i类所有以i类买入的价值;    

    

Zipper点击打开链接

Dp[i][j]=     

    

★Fast Food 点击打开链接

这里须要一个常识:在i到j取一点使它到区间每一点的距离之和最小,这一点为(i+j)/2用图形就可以证明;

    Dp[i][j]=max{Dp[i-1][k]+cost[k+1][j]  当中,(i-1)<=k<j状态为前j个position建i个depots    

    

Warcraft 点击打开链接

比赛的时候这道DP卡到我网络中心停电!!! 卧槽~ 

    由于你没有回血效应,所以你挂掉的时间是一定的;

    用Dp[i][j]表示第i秒剩余j个单位的MP时怪物所剩的血量; 注意必须是剩余,也就是说,初始化的时候,DP[0][100]=100;  其它Dp[0]状态都不合法,由于没有开战的时候你的MP是满的

    状态转移方程为:

    Dp[i+1][j-sk[k].mp+x]=min(Dp[i+1][j-sk[k].mp+x],Dp[i][j]+sk[k].at; 释放第K种技能,物理攻击能够看成是at=1,mp=0 的魔法;

    

Regular Words 点击打开链接

F[a][b][c]=F[a-1][b][c]+F[a][b-1][c]+F[a][b][c-1];

    a>=b>=c;    

    

Advanced Fruits 点击打开链接

最长公共子序列的加强版

杭电dp题集,附链接还有解题报告!!!!!的更多相关文章

  1. HDU/杭电2013多校第三场解题报告

    今天悲剧了,各种被虐啊,还是太年轻了 Crime 这道题目给的时间好长,第一次就想到了暴力,结果华丽丽的TLE了. 后来找了一下,发现前24个是1, 2, 6, 12, 72, 72, 864, 17 ...

  2. 高手看了,感觉惨不忍睹——关于“【ACM】杭电ACM题一直WA求高手看看代码”

    按 被中科大软件学院二年级研究生 HCOONa 骂为“误人子弟”之后(见:<中科大的那位,敢更不要脸点么?> ),继续“误人子弟”. 问题: 题目:(感谢 王爱学志 网友对题目给出的翻译) ...

  3. Help Johnny-(类似杭电acm3568题)

    Help Johnny(类似杭电3568题) Description Poor Johnny is so busy this term. His tutor threw lots of hard pr ...

  4. 杭电oj2093题,Java版

    杭电2093题,Java版 虽然不难但很麻烦. import java.util.ArrayList; import java.util.Collections; import java.util.L ...

  5. 杭电ACM题单

    杭电acm题目分类版本1 1002 简单的大数 1003 DP经典问题,最大连续子段和 1004 简单题 1005 找规律(循环点) 1006 感觉有点BT的题,我到现在还没过 1007 经典问题,最 ...

  6. acm入门 杭电1001题 有关溢出的考虑

    最近在尝试做acm试题,刚刚是1001题就把我困住了,这是题目: Problem Description In this problem, your task is to calculate SUM( ...

  7. 数位dp题集

    题集见大佬博客 不要62 入门题,检验刚才自己有没有看懂 注意一些细节. 的确挺套路的 #include<bits/stdc++.h> #define REP(i, a, b) for(r ...

  8. Codeforces Round #378 (Div. 2) D题(data structure)解题报告

    题目地址 先简单的总结一下这次CF,前两道题非常的水,可是第一题又是因为自己想的不够周到而被Hack了一次(或许也应该感谢这个hack我的人,使我没有最后在赛后测试中WA).做到C题时看到题目情况非常 ...

  9. 【第40套模拟题】【noip2011_mayan】解题报告【map】【数论】【dfs】

    目录:1.潜伏者 [map] 2.Hankson的趣味题[数论]3.mayan游戏[dfs] 题目: 1. 潜伏者(spy.pas/c/cpp)[问题描述]R 国和S 国正陷入战火之中,双方都互派间谍 ...

随机推荐

  1. Spark里边:Worker源代码分析和架构

    首先由Spark图表理解Worker于Spark中的作用和地位: watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYW56aHNvZnQ=/font/5a6L ...

  2. web即时通讯2--基于Spring websocket达到web聊天室

    如本文所用,Spring4和websocket要构建web聊天室,根据框架SpringMVC+Spring+Hibernate的Maven项目,后台使用spring websocket进行消息转发和聊 ...

  3. 经FreeMarkerclasspath加载方式生成静态页面

    package htmlskin; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundExc ...

  4. (初稿)SQL Server 复制(Replication)系列(2)——事务复制搭建

    原文:(初稿)SQL Server 复制(Replication)系列(2)--事务复制搭建 本文演示如何搭建最基本的事务复制. 环境准备: 虚拟机2台: 服务器名分别为RepA和RepB,RepA为 ...

  5. 《学习opencv》笔记——矩阵和图像处理——cvMax,cvMaxS,cvMerge,cvMin and cvMinS

    矩阵和图像操作 (1)cvMax函数 其结构 void cvMax(//比較两个图像取最大值 const CvArr* src1,//图像1 const CvArr* src2,//图像2 CvArr ...

  6. 定制Attribute

    目录 Attribute是什么 自定义Attribute 一.Attribute是什么 将一些附加信息与制定目标相关联的方式.编译器在元数据中生成这些额外的信息.也叫做特性. 比如之前文章中提到的:枚 ...

  7. JUnit实战(2) - JUnit核心(使用Suite来组合测试)

    创建Java Project项目:ch02-internals MasterTestSuite.java package com.manning.junitbook.ch02.internals; i ...

  8. swift学习笔记(七)自己主动引用计数

    与Object-c一样,swift使用自己主动引用计数来跟踪并管理应用使用的内存.当实例不再被使用时,及retainCount=0时,会自己主动释放是理所占用的内存空间. 注:引用计数仅适用于类的实例 ...

  9. hadoop-mapreduce在maptask执行分析

    MapTask执行通过执行.run方法: 1.生成TaskAttemptContextImpl实例,此实例中的Configuration就是job本身. 2.得到用户定义的Mapper实现类,也就是m ...

  10. ViewGroup可实现上下、各地跑马灯效果滚动

    先上效果图: watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdGFuZ25lbmd3dQ==/font/5a6L5L2T/fontsize/400/fill ...