• BZOJ1005明明的烦恼 Prufer + 分解質因數 + 高精度


    @[高精度, Prufer, 質因數分解]

    Description

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

    Input

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

    Output

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

    Sample Input

    3
    1
    -1
    -1
    

    Sample Output

    2
    

    HINT

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

    Solution

    Prufer編碼的簡單應用.
    Prufer是無根樹的一種編碼, 可以和無根樹之間形成一一對應關係. 生成Prufer編碼的方法很簡單, 大致過程如下(這都不是重點)

    一种生成Prufer序列的方法是迭代删点,直到原图仅剩两个点。对于一棵顶点已经经过编号的树T,顶点的编号为{1,2,...,n},在第i步时,移去所有叶子节点(度为1的顶点)中标号最小的顶点和相连的边,并把与它相邻的点的编号加入Prufer序列中,重复以上步骤直到原图仅剩2个顶点。以右边的树为例子,首先在所有叶子节点中编号最小的点是2,和它相邻的点的编号是3,将3加入序列并删除编号为2的点。接下来删除的点是4,5被加入序列,然后删除5,1,此时原图仅剩两个点,Prufer序列构建完成,为{3,5,1,3}
    enter image description here

    重點在於: 在Prufer編碼中, $$一個節點出現的次數 = 該點的度 - 1$$
    有了這個性質, 這題就可以簡單地轉化為求Prufer編碼的排列組合數量.

    【思考】怎么计算呢?就用排列组合的原理。我们先考虑不是-1的点。一共有N-2个格子,设当前的点要求为a1(已经减1了),我们可以放的总数是:C(N-2,a1)。这样占了a1个格子。下一个a2的情况就是C(N-2-a1,a2)。依次类推。
    然后是-1的情况,我想了很长时间。
    原来是这样想的:设最后还有K个格子,且有SUM个-1。我们用DP思路。f[i][j]表示放到最后K个格子中的第i个格子时,放第j种颜色(注意颜色是不下降的,最后只需乘上阶乘即可)的情况数。但是因为要用高精,DP会很麻烦。
    感谢HHD大牛的指导:其实就是SUM^K。为什么?对于每一个格子,我们都可以放SUM种情况~~~~。
    【优化】为了不超时,用质数表来优化。

    實際上就是用分解質因數的方法來優化, 然後再用高精度計算最終答案.

    #include<cstdio>
    #include<cctype>
    #include<cstring>
    using namespace std;
    inline int read()
    {
    	int x = 0, flag = 1;
    	char c;
    	while(! isdigit(c = getchar()))
    		if(c == '-')
    			flag *= - 1;
    	while(isdigit(c))
    		x = x * 10 + c - '0', c = getchar();
    	return x * flag;
    }
    void println(int x)
    {
        if(x < 0)
            putchar('-'), x *= - 1;
        if(x == 0)
            putchar('0');
        int ans[10], top = 0;
        while(x)
            ans[top ++] = x % 10, x /= 10;
        for(; top; top --)
            putchar(ans[top - 1] + '0');
        putchar('
    ');
    }
    const int N = 1 << 10;
    int top;
    int isprime[N], prime[N];
    void get_prime()
    {
    	memset(isprime, - 1, sizeof(isprime));
    	top = 0;
    	for(int i = 2; i < N; i ++)
    		if(isprime[i] == - 1)
    		{
    			isprime[i] = 1, prime[top ++] = i;
    			for(int j = i << 1; j < N; j += i)
    				isprime[j] = 0;
    		}
    }
    int ans[N];
    void C(int n, int m)
    {
    	for(int i = n; i > n - m; i --)
    	{
    		int p = i;
    		for(int j = 0; j < top; j ++)
    			while(! (p % prime[j]))
    				ans[j] ++, p /= prime[j];
    	}
    	for(int i = m; i; i --)
    	{
    		int p = i;
    		for(int j = 0; j < top; j ++)
    			while(! (p % prime[j]))
    				ans[j] --, p /= prime[j];
    	}
    }
    struct Giant
    {
    	int dig[1 << 20];
    	int top;
    	Giant()
    	{
    		top = 1;
    		memset(dig, 0, sizeof(dig));
    		dig[0] = 1;
    	}
    };
    void operator *(Giant &x, int y)
    {
    	for(int i = 0; i < x.top; i ++)
    		x.dig[i] *= y;
    	for(int i = 0; i < x.top; i ++)
    		if(x.dig[i] > 9)
    			x.dig[i + 1] += x.dig[i] / 10, x.dig[i] %= 10;
    	while(x.dig[x.top])
    		x.dig[x.top + 1] = x.dig[x.top] / 10,
    		x.dig[x.top] %= 10,
    		x.top ++;
    }
    void println(Giant &x)
    {
    	for(int i = x.top; i; i --)
    		putchar(x.dig[i - 1] + '0');
    	putchar('
    ');
    }
    Giant Ans; 
    int main()
    {
    	#ifndef ONLINE_JUDGE
    	freopen("BZOJ1005.in", "r", stdin);
    	freopen("BZOJ1005.out", "w", stdout);
    	#endif
    	get_prime();
    	int n = read();
    	int len = 0, cnt = 0;	
    	//len記錄prufer序列已經佔用的長度, cnt記錄尚未確定度的點數 
    	for(int i = 0; i < n; i ++)
    	{
    		int D = read();
    		if((! D) || (D - 1 + len > n - 2))
    		{
    			println(0);
    			return 0;
    		}
    		if(D == - 1)
    			cnt ++;
    		if(D > 0)
    			C(n - 2 - len, D - 1), len += D - 1;
    	}
    	if(len < n - 2)
    	{
    		for(int i = 0; i < top; i ++)
    			while(! (cnt % prime[i]))
    				ans[i] += n - 2 - len, cnt /= prime[i];
    	}
    	for(int i = 0; i < top; i ++)
    		for(int j = 0; j < ans[i]; j ++)
    			Ans * prime[i];
    	println(Ans);
    }
    
  • 相关阅读:
    Java 图片处理——如何生成高清晰度而占有磁盘小的缩略图
    Java文件IO操作应该抛弃File拥抱Paths和Files
    什么是内存(一):存储器层次结构
    mysql 锁
    Mysql索引面试题
    node.js中对同步,异步,阻塞与非阻塞的理解
    mysql 快照读 当前度
    mysql 联合索引
    redis 分布式锁(单机)
    docker 环境搭建redis集群相关问题
  • 原文地址:https://www.cnblogs.com/ZeonfaiHo/p/6483041.html
Copyright © 2020-2023  润新知