Hdu 4187 Alphabet Soup (数学_Polya(KMP))

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4187

题目大意：给定一个圆环上的n个点，圆环被分成360000度，点的位置由角度确定。然后用m种材料来填充这些点，某方案与它旋转的方案同构，问不同构的方案数。m <= 1000,n <= 360000

解题思路：外国佬的题目晦涩难懂,看了好多遍才能理解%70的题意，然后敲了一遍交wa掉了。尔后又看了好多遍，终于大彻大悟。

      Polya的核心是求置换。这题和普通的项链计数不同，难点是如何旋转，因为给的角度不一定等分整个圆环，等分的话就有n个置换和普通的项链计数一样，那么有些情况就只有一种置换，就是不变置换，比如10000，20000，40000，这三个怎么旋转都不会同构。上面的情况是最特殊的两种情况，再考虑一种情况 45000 90000 225000 270000，这时候是有两个置换，一个是不变置换，一个是旋转180度的。

      通过写几组特殊数据会发现其实这些点可以分成若干陀设为cnt陀（1<=cnt<=n)，如果这若干陀经过旋转能和原来的重合，那么他们就是同构的。每一陀个数为len = n / cnt，这len个点一共有m^len种填充方案。这时候问题转换为一个有cnt个点的圆环，要用m^len种颜色填充，旋转后的方案与它原来的方案同构，问不同的方案数,这种解法见这篇解题报告Here。

      最后问题就是怎么找cnt陀，再仔细想想会发现这其实和找一个字符串的最小覆盖、循环节数问题一样，可以通过求next数组来确定循环节数，cnt = n - next[n]。这个结论很优美，证明看Here。

      这题不小心就跑了3s，不小心就成了Rank1.     

测试数据：

Input:
2 4
0
120000
180000
270000
2 4
0
90000
180000
270000
100 5
0
45000
90000
180000
270000
2 4
45000
90000
225000
270000

OutPut:
16
6
99999307
10

C艹代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define INF 360000
#define MAX 400000
#define MOD 100000007
#define int64 long long
//#define int64 __int64


int64 ans;
int n, m, angle[MAX];
int dist[MAX],next[MAX];


void Get_Next() {
    //获取next数组
    int i,j,k;
    i = 0; j = -1;
    next[0] = -1;


    while (i < n) {

        if (j == -1 || dist[i] == dist[j])
            i++,j++,next[i] = j;
        else j = next[j];
    }
}
int Get_NextLen() {
    //len是循环节长度，cnt是循环节个数
    int cnt = n;
    int len = n - next[n];
    if (n % len == 0)
        cnt = n / len;
    return cnt;
}
int Gcd(int x, int y) {
    //返回最小公约数
    int r = x % y;
    while (r) {

        x = y, y = r;
        r = x % y;
    }
    return y;
}
int64 Eular(int64 n) {
    //欧拉函数，返回小于n大于0与n互质的个数
    int64 ans = n, i;
    for (i = 2; i * i <= n; i++) {

        if (n % i == 0) {

            ans -= ans / i;
            while (n % i == 0)
                n /= i;
            if (n == 1) break;
        }
    }


    if (n != 1) ans -= ans / n;
    return ans % MOD;
}
int64 Cal(int64 n, int64 k) {
    //二分快速幂
    int64 x = 1;
    while (k) {

        if (k & 1) x = (x * n) % MOD;
        n = (n * n) % MOD, k >>= 1;
    }
    return x;
}
int64 inv(int64 x) {
    //简洁版求逆元
    if (x == 1) return 1;
    return inv(MOD % x) * (MOD - MOD / x) % MOD;
}
int64 Polya_2B(int64 m,int64 n) {
    //优化后的方法，枚举循环节个数i
    int i, j, k;

    ans = 0;
    for (i = 1; i * i < n; ++i) //枚举循环节个数
        if (n % i == 0) {

            ans = (ans + Eular(n / i) * Cal(m, i) % MOD) % MOD;
            ans = (ans + Eular(i) * Cal(m, n / i) % MOD) % MOD;
        }


    if (i * i == n)
        ans = (ans + Eular(n / i) * Cal(m, i) % MOD) % MOD;
    return ans * inv(n) % MOD;
}
void input (int &a) {

    char c, f;
    while (((c = getchar()) < '0' || f > '9') );
    for (a = 0; c >= '0' && c <= '9'; c = getchar())a = a * 10 + c - '0';
}

int main()
{
    int i, j, k, t, cnt;


    while (scanf("%d%d", &m, &n), n + m >= 0) {

        for (i = 1; i <= n; ++i)
            input(angle[i]);//scanf("%d", &angle[i]);
        sort(angle+1,angle+1+n);
        for (i = 1; i < n; ++i)
            dist[i-1] = angle[i+1] - angle[i];
        dist[n-1] = INF - angle[n] + angle[1];


        Get_Next();
        cnt = Get_NextLen();
        ans = Polya_2B(Cal(m,n/cnt),cnt);
        printf("%I64d\n", ans);
    }
}

本文ZeroClock原创，但可以转载，因为我们是兄弟。