9.23 p.m小结

最新推荐文章于 2023-12-07 08:56:14 发布

Penguin_Wang

最新推荐文章于 2023-12-07 08:56:14 发布

阅读量109

点赞数 2

分类专栏：信息学竞赛文章标签：算法

本文链接：https://blog.csdn.net/Penguin_Wang/article/details/120458839

版权

信息学竞赛专栏收录该内容

46 篇文章 1 订阅

订阅专栏

T1：问题 A: 祖孙询问

题目描述

已知一棵 n 个节点的有根树。有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。

输入

输入第一行包括一个整数 n 表示节点个数；
接下来 n 行每行一对整数对 a 和 b 表示 a 和 b 之间有连边。如果 b 是 -1，那么 a 就是树的根；
第 n+2 行是一个整数 m 表示询问个数；
接下来 m 行，每行两个正整数 x 和 y，表示一个询问。

输出

对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖先则输出 2，否则输出 0。

样例输入

234 -1

12 234

13 234

14 234

15 234

16 234

17 234

18 234

19 234

233 19

234 233

233 12

233 13

233 15

233 19

样例输出

提示

对于 30% 的数据，1≤n,m≤103 ；

对于 100% 的数据，1≤n,m≤4×104 ，每个节点的编号都不超过 4×104 。

题解

这道题是一道求LCA的板题，有3种方法。这里介绍树链剖分的方法。

参考代码

#include<cstdio>
using namespace std;
struct tree
{
	int nxt,to;
}tr[100100];
int head[100100],cnt=0,n,root,m;
int son[100100],fa[100100],dep[100100];
int size[100100],top[100100];
int swap1(int & a,int & b)
{ int c=a;a=b;b=c; }
void build_tree(int u,int v)
{
	tr[++cnt].nxt=head[u];
	tr[cnt].to=v;
	head[u]=cnt;
}
void dfs1(int k,int f)
{
	size[k]=1;
	for(int i=head[k];i;i=tr[i].nxt)
	{
		int to=tr[i].to;
		if(to==f) continue;
		fa[to]=k;
		dep[to]=dep[k]+1;
		dfs1(to,k);
		size[k]+=size[to];
		if(size[to]>size[son[k]])
		son[k]=to;
	}
}
void dfs2(int k,int f)
{
	if(son[k])
	{
		top[son[k]]=top[k];
		dfs2(son[k],k);
	}
	for(int i=head[k];i;i=tr[i].nxt)
	{
		int to=tr[i].to;
		if(to==f) continue;
		if(!top[to])
		{
			top[to]=to;
			dfs2(to,k);
		}
	}
}
int LCA(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])
		swap1(x,y);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap1(x,y);
	return x;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		int a,b;
		scanf("%d%d",&a,&b);
		if(b==-1) root=a;
		else
		{
			build_tree(a,b);
			build_tree(b,a);
		}
	}
	fa[root]=top[root]=root;
	dep[root]=1;
	dfs1(root,-1);dfs2(root,-1);
	scanf("%d",&m);
	while(m--)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		int lc=LCA(x,y);
		if(lc==x) printf("1\n");
		else if(lc==y) printf("2\n");
		else printf("0\n");
	}
	return 0;
}

T2：问题 B: 软件包管理器

题目描述

Linux 用户和 OSX 用户一定对软件包管理器不会陌生。通过软件包管理器，你可以通过一行命令安装某一个软件包，然后软件包管理器会帮助你从软件源下载软件包，同时自动解决所有的依赖（即下载安装这个软件包的安装所依赖的其它软件包），完成所有的配置。Debian/Ubuntu 使用的 apt-get，Fedora/CentOS 使用的 yum，以及 OSX 下可用的 Homebrew 都是优秀的软件包管理器。

你决定设计你自己的软件包管理器。不可避免地，你要解决软件包之间的依赖问题。如果软件包 A 依赖软件包 B，那么安装软件包 A 以前，必须先安装软件包 B。同时，如果想要卸载软件包 B，则必须卸载软件包 A。现在你已经获得了所有的软件包之间的依赖关系。而且，由于你之前的工作，除 0 号软件包以外，在你的管理器当中的软件包都会依赖一个且仅一个软件包，而 0 号软件包不依赖任何一个软件包。依赖关系不存在环（若有 m (m≥2) 个软件包A1 ,A2 ,A3 ,…,Am ，其中 A1 依赖 A2 ，A2 依赖A3 ，A3 依赖 A4 ，……，Am−1 依赖 Am ，而 Am 依赖 A1 ，则称这 m 个软件包的依赖关系构成环），当然也不会有一个软件包依赖自己。

现在你要为你的软件包管理器写一个依赖解决程序。根据反馈，用户希望在安装和卸载某个软件包时，快速地知道这个操作实际上会改变多少个软件包的安装状态（即安装操作会安装多少个未安装的软件包，或卸载操作会卸载多少个已安装的软件包），你的任务就是实现这个部分。注意，安装一个已安装的软件包，或卸载一个未安装的软件包，都不会改变任何软件包的安装状态，即在此情况下，改变安装状态的软件包数为 0。

输入

输入的第 1 行包含 1 个正整数 n，表示软件包的总数。软件包从 0 开始编号。
随后一行包含 n−1 个整数，相邻整数之间用单个空格隔开，分别表示 1,2,3,…,n−2,n−1 号软件包依赖的软件包的编号。
接下来一行包含一个正整数 q，表示询问的总数。
之后 q 行，每行一个询问。询问分为两种：
install x：表示安装软件包 x
uninstall x：表示卸载软件包 x

你需要维护每个软件包的安装状态，一开始所有的软件包都处于未安装状态。对于每个操作，你需要输出这步操作会改变多少个软件包的安装状态，随后应用这个操作（即改变你维护的安装状态）。

输出

输出包括 q 行。

输出的第 i 行输出一个整数，为第 i 步操作中改变安装状态的软件包数。

样例输入

0 0 0 1 1 5

install 5

install 6

uninstall 1

install 4

uninstall 0

样例输出

提示

【样例解释】

一开始所有的软件包都处于未安装状态。

安装 5 号软件包，需要安装 0,1,5 三个软件包。

之后安装 6 号软件包，只需要安装 6 号软件包。此时安装了 0,1,5,6 四个软件包。

卸载 1 号软件包需要卸载 1,5,6 三个软件包。此时只有 0 号软件包还处于安装状态。

之后安装 4 号软件包，需要安装 1,4 两个软件包。此时 0,1,4 处在安装状态。

最后，卸载 0 号软件包会卸载所有的软件包。

【数据范围与提示】

对于所有数据，n≤100000, q≤100000。

题解

这道就是典型的线段树+数列剖分了。首先注意两个操作，安装和卸载。首先来看安装，需要从根节点开始到当前节点都赋值为1，与之前的状态相比增加的1就是答案，可用线段树区间修改解决。再来看卸载，需要把当前节点的子树给全部清为0，减少的1就是答案。这一步需要注意的是，当前节点在线段树中的位置+size[k]-1就是子树中编号最大的那个节点，然后只需要直接在线段树中进行区间赋值就可以了（不用经过数剖）。最重要的一点，为了不死循环，千万不要让根节点为0，全部+1，否则会出现一些莫名其妙的问题（我也说不清）。最后，用了个快读快写来了个小优化。

参考代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#define lc (x<<1)
#define rc (x<<1|1)
#define MAXN 200100
#define LL long long
using namespace std;
struct tree
{
	int nxt,to;
}tr[MAXN];
int head[MAXN],cnt=0,n,m,tot=0;
int seg[MAXN*4],rev[MAXN*4];
int son[MAXN],fa[MAXN],dep[MAXN],size[MAXN];
int top[MAXN];
char s[100];
template <typename T>inline void in(T &x){
	T ch = getchar(), xx = 1; x = 0;
	while(!isdigit(ch)) xx = ch == '-' ? -1 : xx, ch = getchar();
	while(isdigit(ch)) x = (x<<3) + (x<<1) + ch - '0', ch = getchar();
	x *= xx;
}
template <typename T>inline void prt(T x){
	if(x < 0) putchar('-'), x = -x;
	if(x > 9) prt(x / 10);
	putchar(x % 10 + '0');
}
struct tree2
{
	int l,r,sum,lazy;
}ask[MAXN*4];
void make_tree(int x,int l,int r)
{
	ask[x].l=l;ask[x].r=r;
	ask[x].lazy=-1;
	if(l==r)
	{
		ask[x].sum=0;
		return;
	}
	int mid=(l+r)/2;
	make_tree(lc,l,mid);
	make_tree(rc,mid+1,r);
	ask[x].sum=ask[lc].sum+ask[rc].sum;
}
void pushdown(int x)
{
	if(ask[x].lazy!=-1)
	{
		ask[lc].lazy=ask[x].lazy;
		ask[lc].sum=ask[x].lazy*(ask[lc].r-ask[lc].l+1);
		ask[rc].lazy=ask[x].lazy;
		ask[rc].sum=ask[x].lazy*(ask[rc].r-ask[rc].l+1);
		ask[x].lazy=-1;
	}
}
void update(int x,int l,int r,int k)
{
	if(ask[x].l>r||ask[x].r<l) return;
	if(ask[x].l>=l&&ask[x].r<=r)
	{
		ask[x].lazy=k;
		ask[x].sum=k*(ask[x].r-ask[x].l+1);
		return;
	}
	pushdown(x);
	update(lc,l,r,k);
	update(rc,l,r,k);
	ask[x].sum=ask[lc].sum+ask[rc].sum;
}
int query(int x,int l,int r)
{
	if(ask[x].l>r||ask[x].r<l) return 0;
	if(ask[x].l>=l&&ask[x].r<=r) return ask[x].sum;
	pushdown(x);
	return query(lc,l,r)+query(rc,l,r);
}
int swap1(int & a,int & b)
{ int c=a;a=b;b=c; }
void build_tree(int u,int v)
{
	tr[++cnt].nxt=head[u];
	tr[cnt].to=v;
	head[u]=cnt;
}
void dfs1(int k,int f)
{
	size[k]=1;
	for(int i=head[k];i;i=tr[i].nxt)
	{
		int to=tr[i].to;
		if(to==f) continue;
		fa[to]=k;
		dep[to]=dep[k]+1;
		dfs1(to,k);
		size[k]+=size[to];
		if(size[to]>size[son[k]])
		son[k]=to;
	}
}
void dfs2(int k,int f)
{
	rev[++tot]=k;
	seg[k]=tot;
	if(son[k])
	{
		top[son[k]]=top[k];
		dfs2(son[k],k);
	}
	for(int i=head[k];i;i=tr[i].nxt)
	{
		int to=tr[i].to;
		if(to==f) continue;
		if(!top[to])
		{
			top[to]=to;
			dfs2(to,k);
		}
	}
}
int LCA(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])
		swap1(x,y);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap1(x,y);
	return x;
}
void change(int x,int y,int k)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])
		swap1(x,y);
		update(1,seg[top[x]],seg[x],k);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap1(x,y);
	update(1,seg[x],seg[y],k);
}
int query_sum(int x,int y)
{
	int ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])
		swap1(x,y);
		ans+=query(1,seg[top[x]],seg[x]);	
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap1(x,y);
	ans+=query(1,seg[x],seg[y]);
	return ans;
}
int main()
{
	in(n);
	for(int i=2;i<=n;i++)
	{
		int k;in(k);k++;
		build_tree(i,k);
		build_tree(k,i);
	}
	top[1]=fa[1]=1;
	dep[1]=1;
	dfs1(1,0);dfs2(1,0);
	make_tree(1,1,n+1);
	in(m);
	while(m--)
	{
		scanf("%s",s);
		int k,ans=0;in(k);k++;
		if(s[0]=='i')
		{
			ans=query_sum(k,1);
			change(k,1,1);
			ans=query_sum(k,1)-ans;	
		}
		else
		{
			ans=query(1,seg[k],seg[k]+size[k]-1);
			update(1,seg[k],seg[k]+size[k]-1,0);
		}
		prt(ans);
		putchar('\n');
	}
	return 0;
}

T3：问题 D: 数列极差

题目描述

在黑板上写了N个正整数作成的一个数列，进行如下操作：每一次擦去其中的两个数a和b，然后在数列中加入一个数a*b+1，如此下去直至黑板上剩下一个数，在所有按这种操作方式最后得到的数中，最大的max，最小的为min，则该数列的极差定义为M=max-min。

输入

第一行，一个数为N;

0＜＝N＜＝50000

第二行，N个数。每个数都小于20000

输出

输出极差。

样例输入

1 2 3

样例输出

题解

这道题纯粹就是数据恶心吧。写unsigned long long都过不了，结果int反而过了，最后直接define ULL int，有点恶心……这道题用贪心的思想，如果求最小值，就用优先队列每次取出最小的两个，然后操作后入队，能得到min。同理用另一个优先队列取最大的两个来得到max，最后max-min就是答案了。至于这是为什么，则需要用严格的数学公式结合反证法写出矛盾式（结合哈夫曼树的思想），或者就考虑3个数来找规律。由于篇幅过长且无意义，此处略过。

参考代码

#include<cstdio>
#include<queue>
#define ULL int
using namespace std;
priority_queue<ULL>q1;
priority_queue<ULL,vector<ULL>,greater<ULL> >q2;
int n;ULL k,max1,min1;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&k);
		q1.push(k);
		q2.push(k);
	}
	while(!q1.empty())
	{
		ULL hr=q1.top();q1.pop();
		if(q1.empty())
		{
			max1=hr;break;
		}
		ULL pt=q1.top();q1.pop();
		q1.push(hr*pt+1ll);
	}
	while(!q2.empty())
	{
		ULL hr=q2.top();q2.pop();
		if(q2.empty())
		{
			min1=hr;break;
		}
		ULL pt=q2.top();q2.pop();
		q2.push(hr*pt+1ll);
	}
	printf("%d",min1-max1);
	return 0;
}

Penguin_Wang

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
9.23 p.m小结

T1：问题 A: 祖孙询问题目描述已知一棵 n 个节点的有根树。有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。输入输入第一行包括一个整数 n 表示节点个数；接下来 n 行每行一对整数对 a 和 b 表示 a 和 b 之间有连边。如果 b 是 -1，那么 a 就是树的根；第 n+2 行是一个整数 m 表示询问个数；接下来 m 行，每行两个正整数 x 和 y，表示一个询问。输出对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖
复制链接

扫一扫