HDU 4301 Divide Chocolate(找规律，DP）

Divide Chocolate

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

Problem Description

It is well known that claire likes dessert very much, especially chocolate. But as a girl she also focuses on the intake of calories each day. To satisfy both of the two desires, claire makes a decision that each chocolate should be divided into several parts, and each time she will enjoy only one part of the chocolate. Obviously clever claire can easily accomplish the division, but she is curious about how many ways there are to divide the chocolate.

To simplify this problem, the chocolate can be seen as a rectangular contains n*2 grids (see above). And for a legal division plan, each part contains one or more grids that are connected. We say two grids are connected only if they share an edge with each other or they are both connected with a third grid that belongs to the same part. And please note, because of the amazing craft, each grid is different with others, so symmetrical division methods should be seen as different.

 

Input

First line of the input contains one integer indicates the number of test cases. For each case, there is a single line containing two integers n (1<=n<=1000) and k (1<=k<=2*n).n denotes the size of the chocolate and k denotes the number of parts claire wants to divide it into.

 

Output

For each case please print the answer (the number of different ways to divide the chocolate) module 100000007 in a single line.�

 

Sample Input

2 2 1 5 2

 

Sample Output

1 45

 

Author

BUPT

 

Source

2012 Multi-University Training Contest 1

 

Recommend

zhuyuanchen520

 

 

题意：

给定一个2*n的矩形，求把这个矩形分割为k部分的方法，且对称的切割方法视为不同，输出时模上100000007。

(1<=n<=1000,1<=k<=2*n)

解法：

看到这个题目，很容易想到DP。

状态表示 f[i][0][j]:前i行已经出现了j部分且第i行的两个格子属于同一部分的方法数

         f[i][1][j]:前i行已经出现了j部分且第i行的两个格子属于不同部分的方法数

初始条件 f[1][0][1]=f[1][1][2]=1

状态转移 f[i+1][0][j]=(f[i+1][0][j]+f[i][0][j]+f[i][1][j]*2)%mod;

         f[i+1][0][j+1]=(f[i+1][0][j+1]+f[i][0][j]+f[i][1][j])%mod;

         f[i+1][1][j]=(f[i+1][1][j]+f[i][1][j])%mod;

         f[i+1][1][j+1]=(f[i+1][1][j+1]+f[i][0][j]*2+f[i][1][j]*2)%mod;

         f[i+1][1][j+2]=(f[i+1][1][j+2]+f[i][0][j]+f[i][1][j])%mod;

共12种不同的状态转移（见下图）

 

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
const int MOD=100000007;
const int MAXN=1010;
int f[MAXN][2][MAXN*2];
//f[i][0][j]表示i行分成j块，而且最后一行的两个是合起来的
//f[i][1][j]表示i行分成j块，而且最后一行的两个是分开的

void init()//找出所有的组合情况，DP
{
    memset(f,0,sizeof(f));
    f[1][0][1]=1;
    f[1][1][2]=1;
    for(int i=2;i<MAXN;i++)
      for(int j=1;j<=2*i;j++)
      {
          if(j==1)
          {
              f[i][0][1]=1;
              f[i][1][1]=0;
          }
          else
          {
                f[i][0][j]+=f[i-1][0][j];
                f[i][0][j]%=MOD;

                f[i][0][j]+=f[i-1][0][j-1];
                f[i][0][j]%=MOD;

                f[i][0][j]+=f[i-1][1][j-1];
                f[i][0][j]%=MOD;


                f[i][0][j]+=f[i-1][1][j];//
                f[i][0][j]%=MOD;

                f[i][0][j]+=f[i-1][1][j];//
                f[i][0][j]%=MOD;




                f[i][1][j]+=f[i-1][0][j-2];//
                f[i][1][j]%=MOD;
                f[i][1][j]+=f[i-1][1][j-1];//
                f[i][1][j]%=MOD;
                f[i][1][j]+=f[i-1][1][j-1];//
                f[i][1][j]%=MOD;

                f[i][1][j]+=f[i-1][1][j];
                f[i][1][j]%=MOD;


                f[i][1][j]+=f[i-1][0][j-1];//
                f[i][1][j]%=MOD;

                f[i][1][j]+=f[i-1][0][j-1];//
                f[i][1][j]%=MOD;

                f[i][1][j]+=f[i-1][1][j-2];//
                f[i][1][j]%=MOD;
          }
      }
}
int main()
{
    init();
    int T;
    int n,k;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&k);
        printf("%d\n",(f[n][0][k]+f[n][1][k])%MOD);
    }
    return 0;
}