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

2

HINT

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

Source

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

分析:

首先介绍一种数列Purfer Code：

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

如：

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]-);
     }
 }