hdu-5642 King's Order(数位dp)

Posted 2020-06-21 LittlePointer

题目链接：

King‘s Order

Time Limit: 2000/1000 MS (Java/Others)  

  Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 101    Accepted Submission(s): 59

Problem Description

After the king‘s speech , everyone is encouraged. But the war is not over. The king needs to give orders from time to time. But sometimes he can not speak things well. So in his order there are some ones like this: "Let the group-p-p three come to me". As you can see letter ‘p‘ repeats for 3 times. Poor king!

Now , it is war time , because of the spies from enemies , sometimes it is pretty hard for the general to tell which orders come from the king. But fortunately the general know how the king speaks: the king never repeats a letter for more than 3 times continually .And only this kind of order is legal. For example , the order: "Let the group-p-p-p three come to me" can never come from the king. While the order:" Let the group-p three come to me" is a legal statement.

The general wants to know how many legal orders that has the length of n

To make it simple , only lower case English Letters can appear in king‘s order , and please output the answer modulo 1000000007

We regard two strings are the same if and only if each charactor is the same place of these two strings are the same.

 

 

Input

The first line contains a number T(T≤10)——The number of the testcases.

For each testcase, the first line and the only line contains a positive number n(n≤2000).

 

 

Output

For each testcase, print a single number as the answer.

 

 

Sample Input

2

2

4

 

 

Sample Output

676

456950

题意：

国王演讲后士气大增，但此时战争还没有结束，国王时不时要下发命令。

由于国王的口吃并没有治愈，所以传令中可能出现：“让第三军-军-军，到前线去” 这样的命令。由于大洋国在军队中安插了间谍 ， 战事紧急，很多时候前线的指挥官不能分清哪些命令真正来自国王。但国王的命令有一个特点，他每次连续重复的字符最多 33 次. 所以说他的命令中没有：“让第三军-军-军-军 ， 到前线去”，但是可以有 ：“让第三军-军 ， 到前线去” 。

此时将军找到了你，你需要告诉他，给定命令的长度长度为 nn，有多少种不同的命令可以是国王发出的 。（也就是求长度为 nn 的合格字符串的个数）当然，国王可能说出一句话没有犯任何口吃，就像他那次演讲一样。

为了简化答案，国王的命令中只含有小写英文字母，且对答案输出模 1000000007。

我们认为两个命令如果完全相同那么这两个字符串逐个比较就完全相同。

思路：dp[i][j][k]  i为字符串的第i个字符,‘a‘+j为结尾的字符,k为结尾的字符出现了几次,具体的转移方程看代码;
AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const long long mod=1e9+7;
long long dp[2004][26][5];
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<26;i++)
        {
                dp[1][i][1]=1;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<=25;j++)//枚举结尾的字符
            {
                for(int k=0;k<26;k++)//枚举新加的字符
                {
                    if(k==j)
                    {
                        for(int x=1;x<=3;x++)
                        dp[i][j][x]+=dp[i-1][j][x-1],dp[i][j][x]%=mod;//相等的话加一块
                    }
                    else
                    {
                            for(int x=1;x<=3;x++)
                            dp[i][j][1]+=dp[i-1][j][x],dp[i][j][1]%=mod;//不等的话x不加
                    }

                }
            }
        }
        long long ans=0;
        for(int i=0;i<26;i++)
        {
            for(int j=1;j<=3;j++)
            ans+=dp[n][i][j],ans%=mod;
        }
        cout<<ans<<"\n";
    }
    return 0;
}