dp的简单递推笔记1

（1）转自rockZ的博文

　　

　　　　　　　　　　UVa 10328 - Coin Toss （递推）

题意：给你一个硬币，抛掷n次，问出现连续至少k个正面向上的情况有多少种。

原题中问出现连续至少k个H的情况，很难下手。我们可以试着将问题转化一下。

设dp[i][j]表示抛掷i个硬币出现连续至多j个H的情况种数。

实际上原题中的出现连续至少k个H，即出现连续k个H，k+1个H，...n个H的并集，等价于dp[n][n]-dp[n][k-1],即从连续至多n个H的情况（其实这就是所有的抛掷情况种数）减去连续至多（k-1）个H的情况，这保证得到的所有情况一定至少有k个连续的H。

现在问题就变成了怎么求dp[i][j]。

考虑当i<=j的时候，dp[i][j]=dp[i-1][j]*2，即从上一阶段得到的抛掷序列后面增加正和反两种情况，如果出现连续的H个数大于j个，这种情况是非法的，但很显然此时不会出现这种情况。

当i>j时，如果继续用dp[i][j]=dp[i-1][j]*2就不行了。因为如果 从i-j到第i-1全部都是H ，那么这时候在第i个位置再加一个H，就会出现连续的H个数大于j个的非法状态，所以我们需要减掉 从i-j到第i-1全部都是H 的这种情况。那么这种情况有多少种呢。我们考虑该状态是如何转移而来的。试想第i-j-1个位置应该是什么呢。很明显应该是F。如果是H那就会出现非法状态了。那在第i-j-1之前的位置呢。无论H和F都可以，只要不出现连续的H个数大于j的非法状态即可，这就是dp[i-j-2][j]。

那么这样，dp[i][j]=dp[i-1][j]*2-dp[i-j-2][j]。

但这还是不够的。我们之前的推导都是基于第i-j-1个位置一定存在的前提下（i>j不能保证第i-j-1个位置一定存在），那如果第i-j-1个位置不存在，第i-j-2个位置也就不存在，上述方程也就不成立了。但这种情况很好想，此时一定是i==j+1，从第1个位置到第j个位置全部都是H，只有这一种情况，所以方程变成dp[i][j]=dp[i-1][j]*2-1。

综上：

dp[i][j]表示抛掷i个硬币出现连续至多j个H的情况种数

dp[0][j]=1

i<=j:dp[i][j]=dp[i-1][j]*2

i>j :i==j+1:dp[i][j]=dp[i-1][j]*2-1

else: dp[i][j]=dp[i-1][j]*2-dp[i-j-2][j]

ans=dp[n][n]-dp[n][k-1]

需要用到大数。

（2）转accagin的博客：http://blog.csdn.net/cc_again/article/details/24841249

题目链接：

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5170

Attack on Titans

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

Over centuries ago, mankind faced a new enemy, the Titans. The difference of power between mankind and their newfound enemy was overwhelming. Soon, mankind was driven to the brink of extinction. Luckily, the surviving humans managed to build three walls: Wall Maria, Wall Rose and Wall Sina. Owing to the protection of the walls, they lived in peace for more than one hundred years.

But not for long, a colossal Titan appeared out of nowhere. Instantly, the walls were shattered, along with the illusory peace of everyday life. Wall Maria was abandoned and human activity was pushed back to Wall Rose. Then mankind began to realize, hiding behind the walls equaled to death and they should manage an attack on the Titans.

So, Captain Levi, the strongest ever human being, was ordered to set up a special operation squad of N people, numbered from 1 to N. Each number should be assigned to a soldier. There are three corps that the soldiers come from: the Garrison, the Recon Corp and the Military Police. While members of the Garrison are stationed at the walls and defend the cities, the Recon Corps put their lives on the line and fight the Titans in their own territory. And Military Police serve the King by controlling the crowds and protecting order. In order to make the team more powerful, Levi will take advantage of the differences between the corps and some conditions must be met.

The Garrisons are good at team work, so Levi wants there to be at least M Garrison members assigned with continuous numbers. On the other hand, members of the Recon Corp are all elite forces of mankind. There should be no more than K Recon Corp members assigned with continuous numbers, which is redundant. Assume there is unlimited amount of members in each corp, Levi wants to know how many ways there are to arrange the special operation squad.

Input

There are multiple test cases. For each case, there is a line containing 3 integers N (0 < N < 1000000), M (0 < M < 10000) and K (0 < K < 10000), separated by spaces.

Output

One line for each case, you should output the number of ways mod 1000000007.

Sample Input

3 2 2

Sample Output

5

Hint

Denote the Garrison, the Recon Corp and the Military Police as G, R and P. Reasonable arrangements are: GGG, GGR, GGP, RGG, PGG.

题目意思：

给n个士兵排队，每个士兵三种G、R、P可选，求至少有m个连续G士兵，最多有k个连续R士兵的排列的种数。

解题思路：

dp递推。

先把问题都转化成至多连续的情况：至多k个连续R,至多n个连续G情况 【减去】至多k个连续R，至多（m-1）个连续G情况。

至多的情况比较好考虑，至少的情况比较复杂，比赛的时候一直落在至少的圈子里，没想到用递推。

//dp[i][0]表示第i个为G，至多有u个连续G，至多有v个连续R的个数  //这里的u和v固定

//dp[i][1]表示第i个为R，....

 //d[i][2]表示第i个为P，....

当第i个为P的情况很好考虑不会对连续的R和G产生影响，dp[i][2]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];

当第i个为G时

如果i<=u 时 无论怎么放都不会超过u个连续的G这个限制条件 所以dp[i][0]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];

如果i=u+1时，要排除前u个都放了G的情况，dp[i][0]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-1;

如果i>u+1时，要排除从i-1到i-u位置都放了G的情况，dp[i][0]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-dp[i-u-1][1]-dp[i-u-1][2];

当第i个为R时

如果i<=v 时 无论怎么放都不会超过u个连续的G这个限制条件 所以dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];

如果i=v+1时，要排除前v个都放了G的情况，dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-1;

如果i>v+1时，要排除从i-1到i-v位置都放了G的情况，dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2]-dp[i-v-1][0]-dp[i-v-1][2];

//#include<CSpreadSheet.h>  

#include<iostream>
#include<cmath>
#include<cstdio>
#include<sstream>
#include<cstdlib>
#include<string>
#include<string.h>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<ctime>
#include<bitset>
#include<cmath>
#define eps 1e-6
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define ll __int64
#define LL long long
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
#define M 1000000007
//#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;  

#define Maxn 1100000  

LL dp[Maxn][]; //dp[i][0]表示第i个为G，至多有u个连续G，至多有v个连续R的个数
                //dp[i][1]表示第i个为R，....
                //dp[i][2]表示第i个为P，....
LL n,m,k,u,v;  

LL Cal()
{
    dp[][]=; //初始状态
    dp[][]=;
    dp[][]=;  

    for(int i=;i<=n;i++)
    {
       LL sum=(dp[i-][]+dp[i-][]+dp[i-][])%M;
       dp[i][]=sum;  

       if(i<=u)
            dp[i][]=sum;
       else if(i==u+)
            dp[i][]=(sum-)%M;
       else
            dp[i][]=(sum-dp[i-u-][]-dp[i-u-][])%M;  

       if(i<=v)
            dp[i][]=sum;
       else if(i==v+)
            dp[i][]=(sum-)%M;
       else
            dp[i][]=(sum-dp[i-v-][]-dp[i-v-][])%M;  

       //printf("u:%lld v:%lld i:%d %lld %lld %lld\n",u,v,i,dp[i][0],dp[i][1],dp[i][2]);
       //system("pause");  

    }
    return (dp[n][]+dp[n][]+dp[n][])%M;
}  

int main()
{
   //freopen("in.txt","r",stdin);
   //freopen("out.txt","w",stdout);
   while(~scanf("%lld%lld%lld",&n,&m,&k))
   {
       LL ans;
       u=n,v=k;
       ans=Cal();  

       //printf(":%lld\n",ans);
       //system("pause");  

       u=m-,v=k;
       //printf(":%lld\n",Cal());
       //system("pause");
       ans=((ans-Cal())%M+M)%M;
       printf("%lld\n",ans);  

   }
   return ;
}