bzoj1005 [HNOI2008]明明的烦恼

1005: [HNOI2008]明明的烦恼

Time Limit: 1 Sec Memory Limit: 162 MB
Submit: 3032 Solved: 1209

Description

自从明明学了树的结构,就对奇怪的树产生了兴趣...... 给出标号为1到N的点,以及某些点最终的度数,允许在任意两点间连线,可产生多少棵度数满足要求的树?

Input

第一行为N(0 < N < = 1000),接下来N行,第i+1行给出第i个节点的度数Di,如果对度数不要求,则输入-1

Output

一个整数,表示不同的满足要求的树的个数,无解输出0

Sample Input

3
1
-1
-1

Sample Output

HINT

两棵树分别为1-2-3;1-3-2

Source

大意：给出n个点的度数限制，问这些点能组成多少棵树

分析:

首先介绍一种数列Purfer Code：

这种数列是这样子的：对于一棵树（这棵树是不存在根的），每次在数列中加入编号最小的孩子节点（即为度数为1的节点）所对应的父亲节点，并在树中删除此点，不断重复此操作，知道这棵树只剩下两个点

如：

/ \

2 3

/ \

4 5

所对应的PurferCode就是：1 2 2

因为第一次删掉3，第二次删掉1，第三次删掉4

剩下2、5两个节点

可以发现，每个PurferCode对应的树是唯一的

我们也可以从PurferCode得到一棵树

首先由PurferCode计算出每点的度数（出现的次数+1），

然后每次（第 i 次）选择度数最少（度数大于1）的点（度数相同时编号较小的优先）与数列第 i 个点连边，然后这两个点的度数都-1，

这样不断操作，会最后的到两个度数为1的点，将这两点相连，即的原来的树

设度数有限制的点的个数为Cnt，度数-1之和为Sum（即为数列中这些点要占的个数），第 i 个点的度数为di

那么可以根据组合数学：

从数列n-2个点中选择Sum个点有C(Sum, n-2)

这Sum个点中组合C(d1-1， Sum)*C(d2-1, Sum-(d1-1))*C(d3-1, Sum-(d1-1)-(d2-1))*........*C(dn - 1, dn - 1)

剩下的n-2-Sum个位置由其余n-Cnt个点组合，有(n-Cnt)^(n-2-Sum)种方案

所以Ans = C(Sum, n-2)*C(d1-1， Sum)*C(d2-1, Sum-(d1-1))*C(d3-1, Sum-(d1-1)-(d2-1))*........*C(dn - 1, dn - 1)*(n-Cnt)^(n-2-Sum)

因为C(Sum, n-2) = (n-2)!/(Sum!*(n-2-Sum)!),

C(d1-1， Sum) = Sum!/（(d1-1)!*(Sum-(d1-1))!）

C(d2-1, Sum-(d1-1)) = (Sum-(d1-1))!/（（d2-1)!*(Sum-(d1-1)-(d2-1))！）

.........

相乘时加粗部分可以相消

最终可得：

Ans = [ (n-2)!*((n-Cnt)^(n-2-Sum)) ] / [(n-2-Sum)!*(d1-1)!*(d2-1)!*.....*(dn-1)!]

写程序时，乘除都会很大，高精度除法和高精度乘高精度都很麻烦，所以可以分解质因数，最终可以只写单精度乘高精度即可。

关于分解x！的质因数

x = p^a * k（即x可以整除p^a）

a = x div p + x div p^2 + x div p^3 + ..... + x div p^m (p^m为p的阶乘中小于x的最大阶乘，即: p^m <= x, p^(m+1) > x)

那么 x！= p1^x1 * p2^x2 * p3^x3 * ...... * pn^xn

这个是显然的，大家写写就知道

关于分解质因数，可以用O(n)筛素数，这个不讲

综上所述，本题得解

 #include <cstdio>

 #include <cstring>

 #include <cstdlib>

 #include <cmath>

 #include <deque>

 #include <vector>

 #include <queue>

 #include <iostream>

 #include <algorithm>

 #include <map>

 #include <set>

 #include <ctime>

 using namespace std;

 typedef long long LL;

 #define For(i, s, t) for(int i = (s); i <= (t); i++)

 #define Ford(i, s, t) for(int i = (s); i >= (t); i--)

 #define MIT (2147483647)

 #define INF (1000000001)

 #define MLL (1000000000000000001LL)

 #define sz(x) ((bnt) (x).size())

 #define clr(x, y) memset(x, y, sizeof(x))

 #define puf push_front

 #define pub push_back

 #define pof pop_front

 #define pob pop_back

 #define ft first

 #define sd second

 #define mk make_pair

 inline void SetIO(string Name) {

     string Input = Name+".in",

     Output = Name+".out";

     freopen(Input.c_str(), "r", stdin),

     freopen(Output.c_str(), "w", stdout);

 }

 const int N = , LEN = , M = ;

 int Prime[N], p;

 bool Visit[N];

 int n, D[N], Cnt, Sum;

 int P1[N], P2[N];

 int Ans[LEN], Len;

 inline void Input() {

     scanf("%d", &n);

     For(i, , n) scanf("%d", &D[i]);

 }

 inline void EXIT(int Ans) {

     printf("%d\n", Ans);

     exit();

 }

 inline void BuildPrime() {

     clr(Visit, ), p = ;

     For(i, , n){

         if(!Visit[i]) Prime[++p] = i;

         For(j, , p) {

             if(i*Prime[j] > n) break;

             Visit[i*Prime[j]] = ;

             if(i%Prime[j] == ) break;

         }

     }

 }

 inline void FenJie(int A, int *P) {

     For(i, , p) {

         int x = Prime[i];

         while(x <= A) {

             P[i] += A/x;

             x *= Prime[i];

         }

     }

 }

 inline void Mul(int x) {

     For(i, , Len) Ans[i] *= x;

     For(i, , Len) {

         Ans[i+] += Ans[i]/M;

         Ans[i] %= M;

     }

     while(Ans[Len+]) {

         Len++;

         Ans[Len+] += Ans[Len]/M;

         Ans[Len] %= M;

     }

 }

 inline void Solve() {

     //Check

     if(n == ) {

         if(D[] ==  || D[] == -) EXIT();

         EXIT();

     }

     For(i, , n)

         if(D[i] == ) EXIT();

     Cnt = Sum = ;

     For(i, , n)

         if(D[i] > ) Cnt++, Sum += D[i]-;

     if(Sum > n- || (Sum < n- && n == Cnt)) EXIT();

     //Work

     BuildPrime();

     clr(P1, ), clr(P2, );

     FenJie(n-, P1);

     FenJie(n--Sum, P2);

     For(i, , n)

         if(D[i] > ) FenJie(D[i]-, P2);

     int m = n-Cnt;

     For(i, , p) {

         if(m <= ) break;

         int t = , k = Prime[i];

         while(!(m%k)) m /= k, t++;

         P1[i] += t*(n--Sum);

     }

     For(i, , p) P1[i] -= P2[i];

     Ans[] = , Len = ;

     For(i, , p)

         For(j, , P1[i]) Mul(Prime[i]);

     printf("%d", Ans[Len]);

     Ford(i, Len-, ) printf("%04d", Ans[i]);

     cout<<endl;

 }

 int main() {

     SetIO("");

     Input();

     Solve();

     return ;

 }

下面聊聊用线性筛素数法求欧拉函数

欧拉函数有两个定理

1、当m，n互质时，phi(m*n) = phi(m)*phi(n);

2、phi(p^k) = (p-1)*p^(k-1)

因为1-p^k间只有p的倍数不与其互质，这样的数有p^k/p个，即p^(k-1)个，即phi(p^k) = p^k - p^(k-1) = (p-1)*p^(k-1)

那么当n%p == 0 （显然不互质，p为质数）时，

设n = m * p^k（m与p互质）

phi(n) = phi(m)*phi(p^k) = phi(m)*(p-1)*p^(k-1)

phi(n*p) = phi(m*p^(k+1)) = phi(m)*(p-1)*p^k = phi(n)*p

所以可以得求欧拉函数代码

 for(int i=;i<N;i++)  {

     if(!vis[i]) {

         prime[++cnt]=i;

         phi[i]=i-;

     }

     for(int k=;k<=cnt&&prime[k]*i<N;k++) {

         x=prime[k]*i;

         vis[x]=true;

         if(i%prime[k]==) {

             phi[x]=phi[i]*prime[k];

             break;

         }

         else phi[x]=phi[i]*(prime[k]-);

     }

 }