UVA 11255 Necklace

UVA_11255

    应用burnside引理，关键在于对于每种置换求出不动方案的种数。

import java.math.BigInteger;

import java.util.Scanner;



public class Main {

    static int MAXD = 50;

    static Scanner cin = new Scanner(System.in);

    static int N, P, pn;

    static int[] a = new int[5], b = new int[5], prime = new int[MAXD], p = new int[MAXD];

    static boolean[] isprime = new boolean[MAXD];

    static BigInteger[] fac = new BigInteger[MAXD];

    static BigInteger ans;

    public static void main(String[] args) {

        prepare();

        int t = cin.nextInt();

        while(t != 0)

        {

            -- t;

            init();

            solve();

        }

    }

    static void prepare()

    {

        int i, j, k = 40;

        fac[0] = fac[1] = new BigInteger("1");

        for(i = 2; i <= k; i ++)

            fac[i] = fac[i - 1].multiply(BigInteger.valueOf(i));

        for(i = 0; i <= k; i ++)

            isprime[i] = true;

        P = 0;

        for(i = 2; i <= k; i ++)

            if(isprime[i])

            {

                prime[P ++] = i;

                for(j = i * i; j <= k; j += i)

                    isprime[i] = false;

            }

    }

    static void init()

    {

        int i;

        N = 0;

        for(i = 0; i < 3; i ++)

        {

            a[i] = cin.nextInt();

            N += a[i];

        }

        divide(N);

    }

    static void divide(int n)

    {

        int i;

        pn = 0;

        for(i = 0; i < P && prime[i] * prime[i] <= n; i ++)

            if(n % prime[i] == 0)

            {

                p[pn ++] = prime[i];

                while(n % prime[i] == 0)

                    n /= prime[i];

            }

        if(n > 1)

            p[pn ++] = n;

    }

    static int euler(int n)

    {

        int i, ans = n;

        for(i = 0; i < pn; i ++)

            if(n % p[i] == 0)

                ans = ans / p[i] * (p[i] - 1);

        return ans;

    }

    static void solve()

    {

        ans = new BigInteger("0");

        dfs(0, 1, N);

        if(N % 2 == 1)

        {

            for(int i = 0; i < 3; i ++)

            {

                for(int j = 0; j < 3; j ++)

                    b[j] = a[j];

                -- b[i];

                if(b[i] < 0)

                    continue;

                ans = ans.add(calculate(2).multiply(BigInteger.valueOf(N)));

            }

        }

        else

        {

            for(int i = 0; i < 3; i ++)

                b[i] = a[i];

            ans = ans.add(calculate(2).multiply(BigInteger.valueOf(N / 2)));

            for(int i = 0; i < 3; i ++)

                for(int j = 0; j < 3; j ++)

                {

                    for(int k = 0; k < 3; k ++)

                        b[k] = a[k];

                    -- b[i];

                    -- b[j];

                    if(b[i] < 0 || b[j] < 0)

                        continue;

                    ans = ans.add(calculate(2).multiply(BigInteger.valueOf(N / 2)));

                }

        }

        ans = ans.divide(BigInteger.valueOf(2 * N));

        System.out.println(ans);

    }

    static BigInteger calculate(int m)

    {

        int i, n = 0;

        BigInteger ans = new BigInteger("1");

        for(i = 0; i < 3; i ++)

        {

            if(b[i] % m != 0)

                return BigInteger.ZERO;

            b[i] /= m;

            n += b[i];

        }

        for(i = 0; i < 3; i ++)

        {

            ans = ans.multiply(comb(n, b[i]));

            n -= b[i];

        }

        return ans;

    }

    static void dfs(int cur, int v, int x)

    {

        int i, cnt = 0, t = 1;

        if(cur == pn)

        {

            for(i = 0; i < 3; i ++)

                b[i] = a[i];

            ans = ans.add(calculate(N / v).multiply(BigInteger.valueOf(euler(N / v))));

            return ;

        }

        while(x % p[cur] == 0)

        {

            ++ cnt;

            x /= p[cur];

        }

        for(i = 0; i <= cnt; i ++)

        {

            dfs(cur + 1, v * t, x);

            t *= p[cur];

        }

    }

    static BigInteger comb(int n, int m)

    {

        return fac[n].divide(fac[m]).divide(fac[n - m]);

    }

}