Aizu 2164 CSUOJ 1436 Revenge of the Round Table

dp套一个burnside的壳子
核心还是dp
dp[i]表示有i个循环节时的染色方案数
注意在dp的时候，不需要考虑重构的问题
因为burnside会解决重构的问题
dpA[i][j]表示以A开头，长度为i，结尾为j个A的合法方案数
dpB[i][j]表示以B开头，长度为i，结尾为j个A的合法方案数
接下来我们用dpA,dpB来计算dp[i]
显然对于所有的dpB[i][1~k]都是满足dp[i]的
因为它表示以B开头，以A结尾的染色方案，且结尾没有超过k个
另外还有一部分就是以A开头的了
假设我们在整个串的最前面放p个A(p<=k)
在这串A后面放以B开头，以A结尾的串（也就是dpB表示的串）
那么结尾的A不能超过k-p个
也就是说，当我在整个串的最前面放p个A时，所有的
dpB[i-p][0],dpB[i-p][1],dpB[i-p][2]............dpB[i-p][k-p]
都是合法的，这里可以直接用一个前缀和来处理。
计算出dp[i]之后，剩下的就是套一个burnside的壳子了
注意n<=k的时候的处理，最后结果要+2

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1010;
const int mod = 1000003;
typedef long long LL;
int dpA[maxn][maxn],dpB[maxn][maxn],dp[maxn];
int n,k;
LL ans,all;

void DP(){
memset(dpA,0,sizeof(dpA));
memset(dpB,0,sizeof(dpB));
memset(dp,0,sizeof(dp));
int asum = 1,bsum = 0;
if(k >= n){
k = n-1;
all = 2;
}
dpA[1][1] = 1;
dpB[1][1] = 0;

for(int i = 2;i <= n;i++){
dpA[i][1] = bsum;
dpB[i][1] = asum;
swap(asum,bsum);
for(int j = 2;j <= min(n,k);j++){
dpA[i][j] = dpA[i-1][j-1];
asum = (asum+dpA[i][j])%mod;
dpB[i][j] = dpB[i-1][j-1];
bsum = (bsum+dpB[i][j])%mod;
}
}

for(int i = 1;i <= n;i++){
for(int j = 1;j <= min(n,k);j++){
dp[i] += dpB[i][j];
dp[i] %= mod;
}
}

for(int i = 1;i <= n;i++){
for(int j = 1;j < k;j++){
dpB[i][j+1] += dpB[i][j];
dpB[i][j+1] %= mod;
}
}

for(int i = 1;i <= n;i++){
for(int p = 1;p <= min(i,k);p++){
dp[i] += dpB[i-p][k-p];
dp[i] %= mod;
}
}
}

int gcd(int a,int b){
return b == 0 ? a : gcd(b,a%b);
}

LL pow_mod(LL a,LL n){
LL ret = 1;
while(n){
if(n&1) ret = ret*a%mod;
n >>= 1;
a = a*a%mod;
}
return ret;
}

int main()
{
while(scanf("%d%d",&n,&k) == 2){
ans = 0,all = 0;
DP();
for(int i = 0;i < n;i++){
ans += 2*dp[gcd(i,n)];
ans %= mod;
}
ans = ans*pow_mod(n,mod-2)%mod;
printf("%lld\n",(ans+all)%mod);
}
return 0;
}

View Code