【BZOJ1005】【HNOI2008】明明的烦恼

最新推荐文章于 2020-11-20 00:15:38 发布
最新推荐文章于 2020-11-20 00:15:38 发布
阅读量374 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 【OJ】BZOJ 【类型】做题记录 【算法】数学 【算法】树的Prufer序列 【算法】高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/79254330
本文介绍了HNOI2004树的计数问题的解决方案，利用Prufer序列将问题转化为组合数学题。通过避免除法运算，使用高精度计算方法，实现了O(N²)的时间复杂度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

【题目链接】

【双倍经验链接】

【思路要点】

  • 考虑树的Prufer序列。
  • 树的Prufer是一个长度为\(N-2\)的序列，其中每一个元素为一个\(1\)到\(N\)的整数。
  • 每一个这样的序列对应了一棵确定的\(N\)个节点的树，并且每一棵\(N\)个节点的树对应了一个这样的序列。换而言之，Prufer序列和树一一对应。
  • Prufer序列存在性质：一个节点\(i\)在树上的的度数等于其在Prufer序列中出现的次数\(+1\)。
  • 那么问题就变成了简单的组合数学题，稍加分析即可轻松解决，在此不再赘述。
  • 问题不要求取模，因此需要高精度运算。
  • 直接实现除法的代价较高，可以采取记录各个质因数的个数来避免除法运算。
  • 时间复杂度\(O(N^{2})\)

【代码】

/*Program till line 174*/
#include<bits/stdc++.h>
using namespace std;
#define MAXL	4005
#define MAXN	1005
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct INT {int len, value[MAXL]; };
INT operator + (INT a, INT b) {
	INT res;
	res.len = max(a.len, b.len);
	memset(res.value, 0, sizeof(res.value));
	for (int i = 0; i <= res.len; i++)
		res.value[i] = a.value[i] + b.value[i];
	for (int i = 0; i <= res.len; i++) {
		res.value[i + 1] += res.value[i] / 10;
		res.value[i] %= 10;
	}
	if (res.value[res.len + 1]) res.len++;
	return res;
}
INT operator - (INT a, INT b) {
	INT res;
	res.len = a.len;
	memset(res.value, 0, sizeof(res.value));
	for (int i = 0; i <= res.len; i++)
		res.value[i] = a.value[i] - b.value[i];
	for (int i = 0; i <= res.len; i++)
		if (res.value[i] < 0) {
			res.value[i] += 10;
			res.value[i + 1]--;
		}
	while (res.len != 1 && res.value[res.len] == 0) res.len--;
	return res;
}
INT operator * (INT a, INT b) {
	INT res;
	res.len = a.len + b.len;
	for (int i = 0; i <= res.len; i++)
		res.value[i] = 0;
	for (int i = 1; i <= a.len; i++)
	for (int j = 1; j <= b.len; j++)
		res.value[i + j - 1] += a.value[i] * b.value[j];
	for (int i = 0; i <= res.len; i++) {
		res.value[i + 1] += res.value[i] / 10;
		res.value[i] %= 10;
	}
	while (res.len != 1 && res.value[res.len] == 0) res.len--;
	return res;
}
INT number(int x) {
	INT res;
	res.len = 0;
	if (x == 0) res.len = 1, res.value[1] = 0;
	memset(res.value, 0, sizeof(res.value));
	while (x) {
		res.value[++res.len] = x % 10;
		x /= 10;
	}
	return res;
}
INT ten(int x) {
	INT res;
	res.len = x + 1;
	res.value[res.len] = 1;
	for (int i = 0; i < res.len; i++)
		res.value[i] = 0;
	return res;
}
bool operator >= (INT a, INT b) {
	if (a.len > b.len) return true;
	if (a.len < b.len) return false;
	for (int i = a.len; i >= 1; i--) {
		if (a.value[i] > b.value[i]) return true;
		if (a.value[i] < b.value[i]) return false;
	}
	return true;
}
INT operator / (INT a, INT b) {
	INT res, tmp;
	res.len = a.len - b.len + 1;
	for (int i = res.len; i >= 1; i--) {
		tmp = ten(i - 1) * b;
		while (a >= tmp) {
			res.value[i]++;
			a = a - tmp;
		}
	}
	while (res.len != 1 && res.value[res.len] == 0) res.len--;
	return res;
}
INT operator ^ (INT a, int b) {
	if (b == 0) return number(1);
	INT res = a ^ (b / 2);
	if (b % 2 == 0) return res * res;
	else return res * res * a;
}
void print(INT x) {
	for (int i = x.len; i >= 1; i--)
		printf("%d", x.value[i]);
	printf("\n");
}
int tot, prime[MAXN], f[MAXN], a[MAXN], num[MAXN];
void add(int x) {
	while (x != 1) {
		a[num[f[x]]]++;
		x /= f[x];
	}
}
void dec(int x) {
	while (x != 1) {
		a[num[f[x]]]--;
		x /= f[x];
	}
}
int main() {
	int n; read(n);
	for (int i = 2; i <= n; i++) {
		if (f[i] == 0) {
			prime[++tot] = f[i] = i;
			num[i] = tot;
		}
		for (int j = 1; j <= tot && prime[j] <= f[i]; j++) {
			int tmp = i * prime[j];
			if (tmp > n) break;
			f[tmp] = prime[j];
		}
	}
	for (int i = 1; i <= n - 2; i++)
		add(i);
	int cnt = 0, lft = n - 2;
	for (int i = 1; i <= n; i++) {
		int x; read(x);
		if (x == 0 || x <= -2) {
			writeln(0);
			return 0;
		}
		if (x == -1) cnt++;
		else {
			x--;
			if (x > lft) {
				writeln(0);
				return 0;
			}
			lft -= x;
			for (int i = 1; i <= x; i++)
				dec(i);
		}
	}
	for (int i = 1; i <= lft; i++)
		dec(i);
	static INT ans = number(1), tmp;
	for (int i = 1; i <= tot; i++)
		ans = ans * (number(prime[i]) ^ a[i]);
	if (cnt == 0) tmp = number(1);
	else tmp = number(cnt);
	ans = ans * (tmp ^ lft);
	print(ans);
	return 0;
}
/*Original program, TLE with large constant but clearer*/
#include<bits/stdc++.h>
using namespace std;
#define MAXL    4005
#define MAXN    1005
template <typename T> void read(T &x) {
    x = 0; int f = 1;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
    x *= f;
}
template <typename T> void write(T x) {
    if (x < 0) x = -x, putchar('-');
    if (x > 9) write(x / 10);
    putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
    write(x);
    puts("");
}
struct INT {int len, value[MAXL]; } a[MAXN];
INT operator + (INT a, INT b) {
    INT res;
    res.len = max(a.len, b.len);
    memset(res.value, 0, sizeof(res.value));
    for (int i = 0; i <= res.len; i++)
        res.value[i] = a.value[i] + b.value[i];
    for (int i = 0; i <= res.len; i++) {
        res.value[i + 1] += res.value[i] / 10;
        res.value[i] %= 10;
    }
    if (res.value[res.len + 1]) res.len++;
    return res;
}
INT operator - (INT a, INT b) {
    INT res;
    res.len = a.len;
    memset(res.value, 0, sizeof(res.value));
    for (int i = 0; i <= res.len; i++)
        res.value[i] = a.value[i] - b.value[i];
    for (int i = 0; i <= res.len; i++)
        if (res.value[i] < 0) {
            res.value[i] += 10;
            res.value[i + 1]--;
        }
    while (res.len != 1 && res.value[res.len] == 0) res.len--;
    return res;
}
INT operator * (INT a, INT b) {
    INT res;
    res.len = a.len + b.len;
    for (int i = 0; i <= res.len; i++)
        res.value[i] = 0;
    for (int i = 1; i <= a.len; i++)
    for (int j = 1; j <= b.len; j++)
        res.value[i + j - 1] += a.value[i] * b.value[j];
    for (int i = 0; i <= res.len; i++) {
        res.value[i + 1] += res.value[i] / 10;
        res.value[i] %= 10;
    }
    while (res.len != 1 && res.value[res.len] == 0) res.len--;
    return res;
}
INT ten(int x) {
    INT res;
    res.len = x + 1;
    res.value[res.len] = 1;
    for (int i = 0; i < res.len; i++)
        res.value[i] = 0;
    return res;
}
bool operator >= (INT a, INT b) {
    if (a.len > b.len) return true;
    if (a.len < b.len) return false;
    for (int i = a.len; i >= 1; i--) {
        if (a.value[i] > b.value[i]) return true;
        if (a.value[i] < b.value[i]) return false;
    }
    return true;
}
INT operator / (INT a, INT b) {
    INT res, tmp;
    res.len = a.len - b.len + 1;
    for (int i = res.len; i >= 1; i--) {
        tmp = ten(i - 1) * b;
        while (a >= tmp) {
            res.value[i]++;
            a = a - tmp;
        }
    }
    while (res.len != 1 && res.value[res.len] == 0) res.len--;
    return res;
}
INT number(int x) {
    INT res;
    res.len = 0;
    if (x == 0) res.len = 1, res.value[1] = 0;
    memset(res.value, 0, sizeof(res.value));
    while (x) {
        res.value[++res.len] = x % 10;
        x /= 10;
    }
    return res;
}
void print(INT x) {
    for (int i = x.len; i >= 1; i--)
        printf("%d", x.value[i]);
    printf("\n");
}
int main() {
    int n; read(n);
    a[0] = number(1);
    for (int i = 1; i <= n; i++)
        a[i] = a[i - 1] * number(i);
    static INT tmp = number(1);
    int cnt = 0, lft = n - 2;
    for (int i = 1; i <= n; i++) {
        int x; read(x);
        if (x == 0 || x <= -2) {
            writeln(0);
            return 0;
        }
        if (x == -1) cnt++;
        else {
            x--;
            if (x > lft) {
                writeln(0);
                return 0;
            }
            lft -= x;
            tmp = tmp * a[x];
        }
    }
    tmp = tmp * a[lft];
    static INT ans = a[n - 2] / tmp;
    if (cnt == 0) tmp = number(1);
    else tmp = number(cnt);
    for (int i = 1; i <= lft; i++)
        ans = ans * tmp;
    print(ans);
    return 0;
}

BZOJ 2001 Hnoi2010 城市建设 分治+LCT
世界
11-13 3842
题目大意：给定一张带权无向图，每次改变一条边的边权并询问最小生成树，不强制在线日狗我为什么要写这个JB算法。。。对时间进行分治，每条边的存在时间为一个区间，拆成loglog个； 带着LCT把分治结构DFS一遍，一个节点入栈时用上面的所有边扔进LCT动态维护最小生成树，出栈时还原所有操作时间复杂度O(nlog2n)O(nlog^2n)如果没有特殊的卡常技巧请不要写这个算法#include <cstd
BZOJ1009: [HNOI2008]GT考试
MirrorGray的博客
04-12 920
挖坑系列…#include<cstdio> #include<cstring> #include<iostream> #include<algorithm> //by:MirrorGray using namespace std; const int N=22; char s[N]; int mod,m,nxt[N],ret[N][N];int MOD(int x){ while(x>=mo
【bzoj1005】 HNOI2008—明明的烦恼
MashiroSky的博客
08-07 633
http://www.lydsy.com/JudgeOnline/problem.php?id=1005 (题目链接)题意：给出标号为1到N的点,以及某些点最终的度数，允许在任意两点间连线，可产生多少棵度数满足要求的树？Solution 　　prufer编码。关于prufer，有一篇博客写得很好，还运用组合数学求出了公式，可惜代码是java。这道题还要写高精度，高精度除法太麻烦了，因为组合数一定是
【树】【数论】[BZOJ1005][HNOI2008]明明的烦恼
weixin_30701521的博客
02-02 157
题目描述 自从明明学了树的结构,就对奇怪的树产生了兴趣…… 给出标号为1到N的点,以及某些点最终的度数,允许在任意两点间连线,可产生多少棵度数满足要求的树? 样例输入 3 1 -1 -1 样例输出 2 题目解析 首先我们根据prufer数列可以知道任意一棵无根树可以表示为任意一个长度为n−2的串并且有以下的性质任意一点的度为di那么该数字将会在数...
HYSBZ/BZOJ 1005 [HNOI2008] 明明的烦恼 - Prufer编码&组合数学&高精度 此乃神题！
weixin_30659829的博客
02-02 136
题目描述 分析&Solution： hzw大神的blog JMJST大神的blog Matrix67对Prufer编码的理解 再结合题解，才终于理解怎么回事，大赞hzw大神的blog。 #include<cstdio> #include<algorithm> #include<cmath> #include<cs...
[HNOI2008] 明明的烦恼
Virgil's Blog
07-24 454
[BZOJ1005][HNOI2008] 明明的烦恼 给出一棵树中所有节点的度数（ −1-1 代表无限制），求可能的树的种类数。0≤N≤10000
[HNOI2008]明明的烦恼
青烟绕指柔的博客
11-20 383
题目链接：[HNOI2008]明明的烦恼 如果按照树形态dp，是不可做的。 我们直接按照purfer序列组合数求即可。看成一个 n-2 长度的序列。 对于固定的度，相当于盒子中放球，然后剩下的未定的，相当于从剩下位置中随便放。 因为要高精度，所以用的py AC代码： fac=[1]*(1010) def C(n,m): return fac[n]//fac[m]//fac[n-m] def main(): n=int(input()) a=[1]*(n+10) fac[0
bzoj 1005 HNOI2008 明明的烦恼
weixin_34163741的博客
09-11 104
这题做的我欲哭无泪啊…… 我已经没心情多说啥了…… 高精度T啊！我太弱啊！改了一天啊！还不如滚粗啊！ 想好式子在写啊！ 能用高精度乘单精度就不要用高精度乘高精度啊！ 能用高精度除单精度就不要用高精度除高精度啊！ T成翔啊！ 简单的组合计数问题啊！ 题解在这里=_= :http://www.cnblogs.co...
bzoj1008: [HNOI2008]越狱 题解
Unlimited的博客
01-08 677
1008: [HNOI2008]越狱 Description 　　监狱有连续编号为1…N的N个房间，每个房间关押一个犯人，有M种宗教，每个犯人可能信仰其中一种。如果 相邻房间的犯人的宗教相同，就可能发生越狱，求有多少种状态可能发生越狱 Input 　　输入两个整数M，N.1&amp;lt;=M&amp;lt;=10^8,1&amp;lt;=N&amp;lt;=10^12 Output 　　...
bzoj1009【HNOI2008】GT考试
AaronPolaris
05-11 2913
KMP+矩阵乘法
bzoj4541【HNOI2016】矿区
AaronPolaris
06-14 2723
平面图转对偶图+DFS树
【BZOJ 1005】明明的烦恼
YG爱木木
06-16 235
1.题目链接。和BZOJ 1211类似，但是这只是给出了部分点的度数，其实是一样的，因为序列的程度是n-2.假设我们已经知道了有cnt个点的度数，那么这每个点一定会在Prufer序列中出现的d[i]-1次。所有n-2个位置就会被占据sum(di-1)个。那么我们首先在这n-2个位置中选出sum个：C(n-2,sum).然后这sum个数做排列，多重集合的排列，之前说过。排列好之后，剩下n-cnt个点...
BZOJ 1005 明明的烦恼（Prufer数列）
Dreamer_WishSky的专栏
06-09 595
题意：给出一棵树的某些节点的度数d，有些未给。问满足这个条件的树有多少种？ 思路：（1）Prufer数列是无根树的一种数列。由一棵树可以构造出一个Prufer数列，Prufer数列可转化为原来的树。由树生成Prufer的一种简单方法是每次找出标号最小的叶子节点将其父节点添加到Prufer数列并将该叶子节点删除。直到最后只剩下两个节点时结束。比如下面的这个树按照我们刚才的方法生成P
[BZOJ1005][HNOI2008]明明的烦恼（prufer序列+组合数学+高精度）
zyf2000
05-22 1656
一个人至少拥有一个梦想，有一个理由去坚强。
bzoj 1005 [HNOI2008] 明明的烦恼 题解
阿蒋的专栏
03-31 3271
转载请注明出处： 【原题】 1005: [HNOI2008]明明的烦恼 Time Limit: 1 Sec  Memory Limit: 162 MB Submit: 1963  Solved: 768 [Submit][Status] Description 自从明明学了树的结构,就对奇怪的树产生了兴趣...... 给出标号为1到N的点,以及某些点最终的度数,允许在任意
【LOJ2320】「清华集训 2017」生成树计数
cz_xuyixuan的博客
06-24 1884
【题目链接】点击打开链接【思路要点】由于场。时间复杂度\(O(DC^2+D^2+TD^2LogN)\)，其中\(C=165,D=146\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXM = 65; const int MAXN = 262144; const int MAXLOG = 20; const ...
【LOJ2983】「WC2019」数树
cz_xuyixuan的博客
03-31 688
【题目链接】 点击打开链接 【思路要点】 op=0op=0op=0 ，算一算两棵树的公共边数即可。 时间复杂度 O(N)O(N)O(N) 或 O(NLogN)O(NLogN)O(NLogN) 。 op=1op=1op=1 ，考虑枚举蓝树上的一个边集 SSS ，强制红树上同样存在这些边，计算将剩余 N−∣S∣N-|S|N−∣S∣ 个联通块连成一棵树的方案数，更新答案。 上述算法中，枚举蓝...
【省内训练2019-06-28】Islands
cz_xuyixuan的博客
06-28 503
【思路要点】 考虑一个子问题，即本题 K=NK=NK=N 时的情况。 选择 1,2,…,M1,2,\dots,M1,2,…,M 作为关键点，最后将答案乘以 (NM)\binom{N}{M}(MN​) 。 按照如下方式定义森林的 PruferPruferPrufer 序列：找到最大的叶子节点 xxx ，记录下与 xxx 直接相连的点的标号，然后将 xxx 删去，直到只剩下 1,2,…,M1,2,...
【BZOJ1430】小猴打架
cz_xuyixuan的博客
02-05 446
【题目链接】 点击打开链接 【思路要点】 显然，问题是求不同的树的形态乘以\((N-1)!\)。由Prufer序列，显然不同的树的形态有\(N^{N-2}\)种，故答案为\((N-1)!*N^{N-2}\)。时间复杂度\(O(N)\)。 【代码】 #include using namespace std; #define MAXN 5005
bzoj 1040 zjoi2008 骑士 树形dp
08-08
题目描述 有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值