HDU-5642 King's Order

                                                                        Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
                                                                                           Total Submission(s): 642    Accepted Submission(s): 369

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

hint:
All the order that  has length 2 are legal. So the answer is 26*26.

For the order that has length 4. The illegal order are : "aaaa" , "bbbb"…….."zzzz" 26 orders in total. So the answer for n == 4 is 26^4-26 = 456950
  
  

        题意：有T组测试数据，每组输入一个整数n（n：由26个小写字母组成的字符串长度为n），求连续相同字符数不超过3的组合方案数(结果对 1000000007 取摸)。

数位dp

     dp[i][j][k] ：前i个以字符（j-1+'a'）结尾，且最后一个字符重复k次的数量。

 So：

  打表（i）1  ->  20000;

          （j）1  ->   26;

          （l）1 ->    26;      

     如果枚举的字符与结尾字符相同     ->   dp[i][l][2]+=dp[i-1][j][1];

                                                                         dp[i][l][3]+=dp[i-1][j][2];

                              ...........不相同的         ->   dp[i][l][1]+=dp[i-1][j][1];

                                                                         dp[i][l][1]+=dp[i-1][j][2];

                                                                         dp[i][l][1]+=dp[i-1][j][3];

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
const LL Mod=1000000007LL;
LL dp[2150][30][5];
void init()
{
    for(int i=1; i<=26; i++)
        dp[1][i][1]=1;
//
    for(int i=2; i<=2000; i++)
        for(int j=1; j<=26; j++)
            for(int l=1; l<=26; l++)
            {
                if(l==j)
                {
                    dp[i][l][2]=(dp[i][l][2]+dp[i-1][j][1])%Mod;
                    dp[i][l][3]=(dp[i][l][3]+dp[i-1][j][2])%Mod;
                }
                else
                {
                    dp[i][l][1]=(dp[i][l][1]+dp[i-1][j][1])%Mod;
                    dp[i][l][1]=(dp[i][l][1]+dp[i-1][j][2])%Mod;
                    dp[i][l][1]=(dp[i][l][1]+dp[i-1][j][3])%Mod;
                }
            }
}
int main()
{
    int T;
    init();
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        LL ans=0LL;
        for(int i=1;i<=26;i++)
        {
            ans=(ans+dp[n][i][1])%Mod;
            ans=(ans+dp[n][i][2])%Mod;
            ans=(ans+dp[n][i][3])%Mod;
        }
        printf("%I64d\n",ans);
    }

}