URAL 1586. Threeprime Numbers

如果一个数种任意连续的三位都是一个三位的素数，则这个数就是所谓的Threeprime Numbers 。

dp[ i ][ j ] += dp[ a ][ j-1 ] （prime[a]%100 + b == prime[i]  && b == 1,3,5,7,9 ）。

公式没多长时间就推出来，本来想着能 1 A 的来着，结果两个for循环写错位置了。 。 。。 凄凉的调试了一下午。。。。

感觉动规更像是对暴力穷举的优化，在枚举了所有状态之后，你所得到的答案肯定是正确的或者说是最有的。所以没有必要去证明公式的对错。

话说我最开始做DP的时候一直在纠结怎么去证明式子是对的。 。 。。 

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <stack>

#pragma comment(linker, "/STACK:1024000000");
#define LL long long int
#define ULL unsigned long long int
#define _LL __int64
#define INF 0x3f3f3f3f
#define Mod 1000000009

using namespace std;

bool Is_Prime[1010];

int site[1010];

_LL prime[150];

_LL dp[150][10010];

int main()
{
    int n,i,j,m;

   // freopen("asdfg.txt","w",stdout);

    memset(Is_Prime,false,sizeof(Is_Prime));

    for(i = 2; i <= 1000; ++i)
    {
        if(Is_Prime[i] == false)
        {
            for(j = i+i; j <= 1000; j += i)
            {
                Is_Prime[j] = true;
            }
        }
    }

    memset(site,-1,sizeof(site));

    for(n = 0,i = 100; i<= 1000; ++i)
    {
        if(Is_Prime[i] == false)
        {
            prime[n] = i;
            site[i] = n++;
        }
    }

    scanf("%d",&m);

    _LL sum;

    if(m == 3)
    {
        printf("%d\n",n);
    }
    else
    {
        memset(dp,0,sizeof(dp));

        for(i = 0;i < n; ++i)
        {
            dp[i][3] = 1;
        }

        _LL temp;

        for(j = 4;j <= m; ++j)
        {
            for(i = 0;i < n; ++i)
            {
                {
                    temp = (prime[i]%100)*10 + 1;

                    if(temp >= 100 && temp <= 999 && Is_Prime[temp] == false)
                    {
                        dp[site[temp]][j] += dp[i][j-1];
                        dp[site[temp]][j] %= Mod;
                    }

                    temp += 2;
                    if(temp >= 100 && temp <= 999 && Is_Prime[temp] == false)
                    {
                        dp[site[temp]][j] += dp[i][j-1];
                        dp[site[temp]][j] %= Mod;
                    }

                    temp += 2;
                    if(temp >= 100 && temp <= 999 && Is_Prime[temp] == false)
                    {
                        dp[site[temp]][j] += dp[i][j-1];
                        dp[site[temp]][j] %= Mod;
                    }

                    temp += 2;
                    if(temp >= 100 && temp <= 999 && Is_Prime[temp] == false)
                    {
                        dp[site[temp]][j] += dp[i][j-1];
                        dp[site[temp]][j] %= Mod;
                    }

                    temp += 2;
                    if(temp >= 100 && temp <= 999 && Is_Prime[temp] == false)
                    {
                        dp[site[temp]][j] += dp[i][j-1];
                        dp[site[temp]][j] %= Mod;
                    }
                }
            }
        }

        for(sum = 0,i = 0;i < n; ++i)
        {
            sum += dp[i][m];
            sum %= Mod;
        }

        printf("%I64d\n",sum);
    }

    return 0;
}