HDU 5957 线段树 附数据生成器

最新推荐文章于 2019-07-12 23:18:54 发布
最新推荐文章于 2019-07-12 23:18:54 发布
阅读量954 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/53004562
版权

题目大意：

给一个树，然后再随便再多连一条边，形成一个带一个环的树。


一开始，所有树的节点的权重为0


有2个操作。


操作1： 距离结点u距离小于k的所有节点，权重+D

操作2：询问距离节点u距离小于k的所有节点的权重之和。


思路： 先假设题目的图只是一棵树，找一个根节点，BFS一下，dfn[i]表示i节点的BFS时间序列。 可以看出，每个节点的所有儿子的BFS时间序列是连续的，这就可以考虑到线段树来维护了。  并且，用线段树维护还挺好想的。


回到原题，这多一个环，把环弄出来（拓扑排序，最后度为2的点都是环上的）。


环上的点，视为若干个树的根。现在是好多棵树，每棵树的根彼此相连，依旧用线段树来解决，只不过在操作的时候，要多考虑一些东西~细节的话自己考虑一下就行了。


AC CODE:

#include <bits/stdc++.h>
using namespace std;

const int maxn =100000 + 100;
vector<int>g[maxn];
int n;

void init()
{
	scanf("%d", &n);
	for (int i = 0; i <= n; ++ i)
	{
		g[i].clear();
	}
	for (int i = 1; i <= n; ++ i)
	{
		int s, t;
		scanf("%d%d", &s, &t);
		g[s].push_back(t);
		g[t].push_back(s);
	}
}

const int maxnode = 6*maxn;

struct node
{
	int lson, rson;
	int val;//区间权重
	int change;//区间修改值,为0表示没有需要传递的
}tree[maxnode];
int tail;


char input[20];
int du[maxn];
queue<int>q;
int dfn[maxn], dfncnt;
bool vis[maxn];

vector<int>root[maxn];//作为根的节点的朋友节点


void bfs(int arg)
{
	//du[i]==2表示为一个root

	//root[arg]可以知道arg作为根的时候，和哪些点直接连接
	root[arg].clear();
	for (auto will : g[arg])
		if (du[will] == 2)
			root[arg].push_back(will);


	//vis数组，是为了避免找儿子的时候，找到父亲了
	vis[arg] = true;
	q.push(arg);
	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		dfn[now] = ++dfncnt;
		for (auto will : g[now])
		{
			if (du[will] == 2)	continue;
			if (vis[will])	continue;
			q.push(will);
			vis[will] = true;
		}
	}
}

int minson[maxn], maxson[maxn];//最小最大的儿子编号
int mingrandson[maxn], maxgrandson[maxn];//最小最大的孙子编号
int pre[maxn];//父节点

//dfs是找出自己儿子层的数字，和孙子层的数字
void dfs(int now, int fa)
{
	pre[now]=fa;
	minson[now] = mingrandson[now] = 0x7fffffff;
	maxson[now] = maxgrandson[now] = -1;
	for (auto will : g[now])
	{
		if (will == fa)	continue;
		if (du[will] == 2)	continue;
		dfs(will, now);
		if (dfn[will] > maxson[now])	maxson[now] = dfn[will];
		if (dfn[will] < minson[now])	minson[now] = dfn[will];
		if (minson[will] < mingrandson[now])	mingrandson[now] = minson[will];
		if (maxson[will] > maxgrandson[now])	maxgrandson[now] = maxson[will];
	}
}

//#define pr(x)	cout<<#x<<" = "<<x<<" "
//#define prln(x)	cout<<#x<<" = "<<x<<endl
#define pr(x)	x
#define prln(x)	x

void predoit()
{
	memset(du,0,sizeof(du));
	memset(pre,-1,sizeof(pre));
	for (int i = 1; i <= n; ++ i)
	{
		du[i] = g[i].size();
		if (du[i] == 1)	
		{
			//prln(i);
			q.push(i);
		}
	}

	while (!q.empty())
	{
		int now = q.front();
		q.pop();
		for (auto will : g[now])
		{
			du[will]--;
			if (du[will] == 1)
			{
				q.push(will);
			}
		}
	}
	//for (int i = 1; i <= n; ++ i)
	//if (du[i] == 2)	prln(i);

	memset(vis, 0, sizeof(vis));//访问标记
	memset(dfn, 0, sizeof(dfn));//BFS时间戳
	dfncnt = 0;//BFS时间戳记录器

	for (int i = 1; i <= n; ++ i)
		if (du[i] == 2)
		{
			bfs(i);
			dfs(i, -1);
		}
	for (int i = 1; i <= n;++i)
		pr(i),prln(dfn[i]);
}

int ql, qr, qans;
#define LSON tree[o].lson,L, M
#define RSON tree[o].rson, M + 1 , R
#define SELF o,L,R
#define lc tree[o].lson
#define rc tree[o].rson

void build(int o, int L, int R)
{
	tree[o].change = 0;
	tree[o].val = 0;
	if (L== R)
	{
		tree[o].val = 0;
		return ;
	}
	tree[o].lson = ++ tail;
	tree[o].rson = ++ tail;
	int M = L + (R - L) / 2;
	build(LSON);
	build(RSON);
}

void push_down(int o, int L, int R)//向下传递标记
{
	if (tree[o].change && L < R)
	{
		tree[lc].change += tree[o].change;
		tree[rc].change += tree[o].change;
		tree[o].change = 0;
	}
}

void maintain(int o, int L, int R)//把o的儿子的信息，归到o节点
{
	if (L < R)
	{
		int M = L+(R-L)/2;
		tree[o].val = tree[lc].val + tree[rc].val + tree[lc].change * (M-L+1) + tree[rc].change * (R-M);
	}
}

int query(int o, int L, int R)
{
	if (ql <= L && R <= qr)
	{
		return tree[o].val + tree[o].change * (R-L+1);//因为根节点的传递标记一直都在
	}
	push_down(SELF);
	int M = L + (R - L) / 2;
	int ret = 0;
	if (ql <= M)	ret += query(LSON);
	else maintain(LSON);
	if (qr > M)	ret += query(RSON);
	else maintain(RSON);
	maintain(SELF);
	return ret;
}

void update(int o, int L, int R)
{
	if (ql <= L && R <= qr)
	{
		tree[o].change += qans;
		return;
	}else
	{
		push_down(SELF);
		int M = L + (R-L)/2;
		if (ql <= M)	update(LSON);
		else maintain(LSON);
		if (qr > M)	update(RSON);
		else maintain(RSON);
	}
	maintain(SELF);
}

vector<int>sb;

void UD(int u, int k, int d)
{
	//一会儿赋值下QU，然后略改一下参数即可
	qans=d;
	if (!k)
	{
		ql = dfn[u], qr = dfn[u];
		update(0, 1, n);
		pr(ql),prln(qr);
	}
	else if (k==1)
	{
		ql = minson[u],	qr = maxson[u];

		update(0, 1, n);
		pr(ql),prln(qr);

		if (du[u]!=2)//u非根
		{
			ql = qr = dfn[pre[u]];
			update(0, 1, n);
			pr(ql),prln(qr);

			ql = qr = dfn[u];
			update(0, 1, n);
			pr(ql),prln(qr);
		}else
		{
			//u为根
			for (auto will : root[u])
			{
				ql = qr = dfn[will];
				update(0, 1, n);
				pr(ql),prln(qr);
			}
			ql = qr = dfn[u];
			update(0, 1, n);
			pr(ql),prln(qr);
		}
	}
	else//也就是k==2
	{
		ql = minson[u], qr = maxson[u];
		update(0, 1, n);
		pr(ql),prln(qr);

		ql = mingrandson[u], qr = maxgrandson[u];
		update(0, 1, n);
		pr(ql),prln(qr);
		if (du[u]!=2)
		{
			int fa = pre[u];
			ql = minson[fa], qr = maxson[fa];
			update(0, 1, n);
			pr(ql),prln(qr);

			ql = dfn[fa], qr = dfn[fa];
			update(0, 1, n);
			pr(ql),prln(qr);


			if (du[fa] != 2)//依旧没到环上
			{
				fa = pre[fa];
				ql = dfn[fa], qr = dfn[fa];
				update(0, 1, n);
				pr(ql),prln(qr);
			}
			else
			{
				for (auto will : root[fa])
				{
					ql = qr = dfn[will];
					update(0, 1, n);
					pr(ql),prln(qr);
				}
			}
		}
		else
		{
			sb.clear();
			for (auto will : root[u])
			{
				sb.push_back(will);

				ql = minson[will], qr = maxson[will];
				update(0, 1, n);
				pr(ql),prln(qr);
				for (auto x : root[will])
					sb.push_back(x);
			}
			sort(sb.begin(), sb.end());
			sb.erase(unique(sb.begin(),sb.end()),sb.end());
			for (auto will : sb)
			{
				ql = qr = dfn[will];
				update(0, 1, n);
				pr(ql),prln(qr);
			}
		}
	}
}

void QU(int u, int k)
{
	//一会儿赋值下QU，然后略改一下参数即可
	int sum = 0;
	if (!k)
	{
		ql = dfn[u], qr = dfn[u];
		sum += query(0, 1, n);
		pr(ql),prln(qr);
	}
	else if (k==1)
	{
		ql = minson[u],	qr = maxson[u];

		sum += query(0, 1, n);
		pr(ql),prln(qr);

		if (du[u]!=2)//u非根
		{
			ql = qr = dfn[pre[u]];
			sum += query(0, 1, n);
			pr(ql),prln(qr);

			ql= qr = dfn[u];
			sum += query(0, 1, n);
			pr(ql),prln(qr);


		}else
		{
			//u为根
			for (auto will : root[u])
			{
				ql = qr = dfn[will];
				sum += query(0, 1, n);
				pr(ql),prln(qr);
			}
			ql = qr = dfn[u];
			sum += query(0, 1, n);
			pr(ql),prln(qr);
		}
	}
	else//也就是k==2
	{
		ql = minson[u], qr = maxson[u];
		sum += query(0, 1, n);
		pr(ql),prln(qr);

		ql = mingrandson[u], qr = maxgrandson[u];
		sum += query(0, 1, n);
		pr(ql),prln(qr);
		if (du[u]!=2)
		{
			int fa = pre[u];
			ql = minson[fa], qr = maxson[fa];
			sum += query(0, 1, n);
			pr(ql),prln(qr);

			ql = dfn[fa], qr = dfn[fa];
			sum += query(0, 1, n);
			pr(ql),prln(qr);


			if (du[fa] != 2)//依旧没到环上
			{
				fa = pre[fa];
				ql = dfn[fa], qr = dfn[fa];
				sum += query(0, 1, n);
				pr(ql),prln(qr);
			}
			else
			{
				for (auto will : root[fa])
				{
					ql = qr = dfn[will];
					sum += query(0, 1, n);
					pr(ql),prln(qr);
				}
			}
		}
		else
		{
			sb.clear();
			for (auto will : root[u])
			{
				sb.push_back(will);

				ql = minson[will], qr = maxson[will];
				sum += query(0, 1, n);
				pr(ql),prln(qr);
				for (auto x : root[will])
					sb.push_back(x);
			}
			sort(sb.begin(), sb.end());
			sb.erase(unique(sb.begin(),sb.end()),sb.end());
			for (auto will : sb)
			{
				ql = qr = dfn[will];
				sum += query(0, 1, n);
				pr(ql),prln(qr);
			}
		}
	}
	printf("%d\n", sum);
}

void doit()
{
	int T;
	int u, k, d;
	tail=0;
	//root为0
	build(0,1,n);
	//for (int o = 0; o <= tail; ++ o)
	//pr(lc),pr(rc),pr(tree[o].val),prln(tree[o].change);

	scanf("%d", &T);
	while (T--)
	{
		scanf("%s", input);
		if (input[0]=='M')
		{
			scanf("%d%d%d", &u, &k, &d);
			UD(u,k,d);
			for (int o = 0; o <= tail; ++ o)
			pr(o),pr(lc),pr(rc),pr(tree[o].val),prln(tree[o].change);
			prln("\n\n"),prln("\n\n");
		}else
		{
			scanf("%d%d", &u, &k);
			QU(u, k);
			for (int o = 0; o <= tail; ++ o)
			pr(o),pr(lc),pr(rc),pr(tree[o].val),prln(tree[o].change);
			prln("\n\n"),prln("\n\n");
		}
	}
}

int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		init();
		predoit();
		for (int i = 1; i <= n; ++ i)
			pr(minson[i]),pr(maxson[i]),pr(mingrandson[i]),prln(maxgrandson[i]);
		doit();
		//break;//暂且只测一组数据
	}
	return 0;
}

data maker: 

#include <cstdio>
#include <cstring>
#include <vector>
#include <ctime>
#include <iostream>
#include <cstdlib>
using namespace std;

int g[500][500];

int main()
{
	srand(time(0));
	int T = 5;
	cout<<T<<endl;
	while (T--)
	{
		memset(g,0,sizeof(g));
		int n = rand() % 10 + 3;
		cout<<n<<endl;
		for (int i = 2; i <= n; ++ i)
		{
			int a = i, b = rand()%(i-1)+1;
			g[a][b]=g[b][a]=1;
			cout << a <<" " << b<<endl;
		}
		while (1)
		{
			int a = rand()%n+1;
			int b = rand()%n+1;
			if (a!=b && !g[a][b])
			{
				cout<<a<<" "<<b<<endl;
				break;
			}
		}
		int ask=rand()%3+1;
		cout<<ask<<endl;
		while (ask --)
		{
			string a[2];
			a[0]="MODIFY";
			a[1]="QUERY";
			int flag = rand()%2;
			if (flag)
			{
				cout<<a[0]<<" "<<rand()%n+1<<" "<<rand()%2+1<<" "<<rand()%5<<endl;
			}
			else
			{
				cout<<a[1]<<" "<<rand()%n+1<<" "<<rand()%2+1<<endl;
			}
		}
	}
	return 0;
}
/*
2
6
2 1
3 2
4 2
5 1
6 2
4 5
2
QUERY 6 2
MODIFY 6 2 3
7
2 1
3 1
4 1
5 2
6 3
7 2
6 1
2
MODIFY 2 1 4
QUERY 2 2

*/


CMTM4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[BFS序+线段树]HDU 5957Query on a graph 题解
Wflower的Blog //What are you waiting for?
10-12 226
题目大意 给出一个n个点n条边的图，有两种操作： 1.Uptate x k d 将所有距离x距离不超过k的所有节点加d 2.Query x k 统计所有距离x距离不超过k的所有节点 n≤105,0≤k≤2n\le 10^5,0\le k \le 2n≤105,0≤k≤2 解题分析 基环树常用套路：将整个环当做一个根节点，然后建树。 然后用BFS建树的时候可以得到一个进队列的顺序，称之为BFS序（相...
hdu acm1166线段树
05-03
hdu 1166线段树代码
HDU - 5957 Query on a graph （bfs序 + 线段树 + 分类大讨论）
Lee_w_j__的博客
12-14 247
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5957 题目大意：给出一个n个点n条边的图，保证图中没有自环和重边，图中的结点的初始权值为0。接下来进行q次操作，每次操作有以下两种： MODIFY u k d:将与点u的距离小于等于k的点的权值加上d； QUERY u k:查询所有与点u的距离小于等于k的点的权值和。 题目思路：由于给出的图是...
HDU-5957 Query on a graph（线段树+树剖）
十分残念的博客
07-13 881
Query on a graph Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 325    Accepted Submission(s): 73 Problem Description You are given a
【HDU】5957 Query on a graph【分类讨论+bfs序线段树】
poursoul
10-30 1271
题目链接：Query on a graph水题#include <bits/stdc++.h> using namespace std ;typedef long long LL ; typedef pair < int , int > pii ; typedef unsigned long long ULL ;#define clr( a , x ) memset ( a , x , sizeof
Query on a graph HDU - 5957
sunyutian1998的博客
10-24 168
http://acm.hdu.edu.cn/showproblem.php?pid=5957 好想但是难写 先求个生成树 并把多余边记下来 跑个bfs序并用线段树维护 bfs序和dfs序略有不同 对一个节点 遍历一遍其所有子节点并取最小最大值会得到其一级子节点在bfs序中的区间 再跑一遍就会得到二级子节点在bfs序中的区间 依此类推 然后就是恶心的分类讨论 写了一屏都没写完。。索性把所有要...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj...(4)End(4)End(4)End 表示结束，这条命令在每组数据最后出现;
hdu 1166线段树
07-02
hdu 1166线段树
ACM hdu 线段树题目+源代码
06-19
Hdu 1698 Just a Hook 是另一个典型的线段树题目，题目要求我们实现一个数据结构来维护一个数组的区间信息。 Hdu 3584 Cube Hdu 3584 Cube 是一个三维线段树题目，题目要求我们实现一个三维线段树来维护一个三维...
线段树入门学习(兼解HDU1754)
04-14
线段树是一种数据结构，主要用于高效地处理区间查询与修改问题。在计算机科学中，它在动态规划、算法竞赛等领域有着广泛的应用。这篇博客“线段树入门学习(兼解HDU1754)”旨在帮助初学者理解线段树的基本概念，并...
HDU5957 Query on a graph
forezxl的博客
10-06 239
线段树 BFS序 题目传送门 **题目大意：**一个基环树，有点权。有询问和修改操作。修改有三个参数u,k,du,k,du,k,d，表示把距离uuu不超过kkk（包括自己，下同）的点都加上ddd。查询有两个参数u,ku,ku,k，表示求距离uuu不超过kkk的点权和。n≤1e5,k≤2n\leq 1e5,k\leq 2n≤1e5,k≤2。 先别管那条非树边。当k=1k=1k=1的时候是维护它爸爸和...
Query on a graph HDU5957 沈阳ICPC重现赛
SUNSET
08-17 603
Query on a graph Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 369    Accepted Submission(s): 81 Problem Description You are give
HDU5957 Query on a graph（拓扑找环，BFS序，线段树更新，分类讨论）
buerdepepeqi的CSDN博客
12-17 159
传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5957 题意:D(u,v)是节点u和节点v之间的距离，S(u,v)是一系列满足D(u,x)&lt;=k的点的集合，操作1：将S(u,k)内节点权值增加或者减小，操作2：查询S(u,k)内节点的权值和 题解:因为题目说了查询和更新的距离小于等于k，k最大为2，所以很显然要分情况讨论k为0、1、2的...
hdu5957 ICPC-2016 沈阳 I bfs序+线段树+分类讨论
执子之手,与子偕老
10-22 204
题面 思路： 用线段树维护bfs序，因为同一层的儿子的bfs序连续 很久没有写过分类讨论了 细节错误很多： 1. k == 2时要判在不在环上，环够不够长，fa[x]在不在环上 2. bfs序只保证所有儿子在连续区间，而层与层之间是不连续的。开始竟然天真的以为是连续的 调了 1h多 还写了 30多min 代码能力要加强！ #include &lt;bits/stdc++.h&gt; #defin...
hdu 5957 Query on a graph
qq_18869763的博客
07-12 115
题解： 毒瘤题......首先bfs跑一遍图，生成一棵树，则只有一条边没有用上而且这条边链接的两个点在该树上的深度差为<=1，即深度差为-1,0,1三种情况（因为深度差大于2的话，bfs就会选这跳边当做树边了）。 做完bfs序后就可以直接上线段树了，因为每一层的数刚好是连续了，分情况讨论，k=0，k=1的情况比较好写，但k=2的时候情况很多。。。。 特殊边的点跟查找的...
[bfs序 线段树] HDU5957. Query on a graph
CE玩家
11-29 348
求出bfs序那么一个点的儿子和孙子都是在bfs序上连续的一段记一下这个区间，然后线段树维护一下因为有环，那么肯定有多出来的一条边，给这条边的两个端点以及这两个端点连出去的点打个标记就好了细节贼多#include <cstdio> #include <iostream> #include <algorithm> #include <queue>using namespace std;typedef l
[环套树 bfs序] ICPC 2016 Shenyang J & HDU5957 Query on a graph
雯舞
03-29 668
按层建线段树，或者说是bfs序。 然后修改的一定是不超过5层里面的连续的段，可以在线段树上直接修改。 对于环+树，把环抠出来之后按树的方法做。代码丑#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std; typedef long long ll;inline char nc(){ static c
acm_随机算法
Yishui_lovely
05-12 854
使用姿势 1：向Judgers宣战！随机生成结果，对评测姬进行恐怖袭击，疯狂提交，这种做法很容易导致工作人员拿着40m砍刀走过来。极度不推荐。使用姿势 2：凌茫然万顷举个栗子，一片huge荒漠的中心有着绝世大秘宝，作为一个寻宝者，该采取怎样的策略呢？ 策略A：徒步前行。 策略B：空降。 关于策略A，显然不明智。路途迢迢，寻宝者肯定会发出哀吾生须臾的感慨。 关于策略B，如果有空降指挥部，那复杂
HDU-5956 The Elder(树型dp+斜率优化)
十分残念的博客
07-13 1310
Once upon a time, in the mystical continent, there is a frog kingdom, ruled by the oldest frog, the Elder. The kingdom consists of N cities, numbered from east to west. The 1-th city, which is located

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值