HDOJ 5296 Annoying problem LCA+数据结构

dfs一遍得到每一个节点的dfs序,对于要插入的节点x分两种情况考虑:

1,假设x能够在集合中的某些点之间,找到左边和右边距离x近期的两个点,即DFS序小于x的DFS序最大点,和大于x的DFS序最小的点......

2.假设x在集合中的点某一側,则找距离x的dfs序最小和最大的点

将x插入这个集合最少要走的距离为 dist[x]-dist[LCA(left,x)]-dist[LCA(right,x)]+dist[LCA(left,right)]

删除同理

Annoying problem

Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 334    Accepted Submission(s): 95

Problem Description

Coco has a tree, whose nodes are conveniently labeled by 1,2,…,n, which has n-1 edge。each edge has a weight. An existing set S is initially empty.

Now there are two kinds of operation:

1 x: If the node x is not in the set S, add node x to the set S

2 x: If the node x is in the set S,delete node x from the set S

Now there is a annoying problem: In order to select a set of edges from tree after each operation which makes any two nodes in set S connected. What is the minimum of the sum of the selected edges’ weight ?

Input

one integer number T is described in the first line represents the group number of testcases.( T<=10 )

For each test:

The first line has 2 integer number n,q(0<n,q<=100000) describe the number of nodes and the number of operations.

The following n-1 lines each line has 3 integer number u,v,w describe that between node u and node v has an edge weight w.(1<=u,v<=n,1<=w<=100)

The following q lines each line has 2 integer number x,y describe one operation.(x=1 or 2,1<=y<=n)

Output

Each testcase outputs a line of "Case #x:" , x starts from 1.

The next q line represents the answer to each operation.

Sample Input

1
6 5
1 2 2
1 5 2
5 6 2
2 4 2
2 3 2
1 5
1 3
1 4
1 2
2 5

Sample Output

Case #1:
0
6
8
8
4

Author

FZUACM

Source

2015 Multi-University Training Contest 1

/* ***********************************************
Author        :CKboss
Created Time  :2015年07月21日 星期二 21时06分11秒
File Name     :HDOJ5296.cpp
************************************************ */

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <queue>
#include <set>
#include <map>

using namespace std;

typedef long long int LL;

const int maxn=120100;
const int INF=0x3f3f3f3f;

struct Edge
{
	int to,next,cost;
}edge[maxn*2];

int Adj[maxn],Size;
void init() { memset(Adj,-1,sizeof(Adj)); Size=0; }

void Add_Edge(int u,int v,int c)
{
	edge[Size].to=v; edge[Size].cost=c;
	edge[Size].next=Adj[u];
	Adj[u]=Size++;
}

int n,q;
int dist[maxn],ti[maxn],cnt;

void dfs(int len,int u,int fa)
{
	dist[u]=len; ti[u]=cnt;
	for(int i=Adj[u];~i;i=edge[i].next)
	{
		int to=edge[i].to;
		int cost=edge[i].cost;
		if(to==fa) continue;
		cnt++;
		dfs(len+cost,to,u);
	}
}

/********************** LCA **********************************/

const int DEG=20;
int fa[maxn][DEG];
int deg[maxn];

void BFS(int root)
{
	queue<int> q;

	memset(deg,0,sizeof(deg));
	memset(fa,0,sizeof(fa));

	deg[root]=0;
	fa[root][0]=root;
	q.push(root);
	while(!q.empty())
	{
		int u=q.front(); q.pop();
		for(int i=1;i<DEG;i++)
		{
			fa[u][i]=fa[fa[u][i-1]][i-1];
		}
		for(int i=Adj[u];~i;i=edge[i].next)
		{
			int v=edge[i].to;
			if(v==fa[u][0]) continue;
			deg[v]=deg[u]+1;
			fa[v][0]=u;
			q.push(v);
		}
	}
}

int LCA(int u,int v)
{
	if(deg[u]>deg[v]) swap(u,v);
	int hu=deg[u],hv=deg[v];
	int tu=u,tv=v;
	for(int det=hv-hu,i=0;det;i++,det=det/2)
	{
		if(det&1) tv=fa[tv][i];
	}
	if(tu==tv) return tu;
	for(int i=DEG-1;i>=0;i--)
	{
		if(fa[tu][i]==fa[tv][i]) continue;
		tu=fa[tu][i]; tv=fa[tv][i];
	}
	return fa[tu][0];
}

struct Node
{
	int val,cnt;
	bool operator<(const Node& nd) const { return cnt<nd.cnt; }
	bool operator==(const Node& nd) const { return val==nd.val; }
	bool operator!=(const Node& nd) const { return val!=nd.val; }
};

set<Node> st;

int CL(int flag,Node ND)
{
	if(flag==0) st.erase(ND);

	set<Node>::iterator it1,it2;
	int x=ND.val;
	it2=st.upper_bound(ND);
	it1=it2; it1--;

	/// check if in mid
	if(it1->val!=0&&it2->val!=n+10) /// in mid
	{
		int left=it1->val;
		int right=it2->val;

		if(flag) st.insert(ND);
		return dist[x]-dist[LCA(x,left)]-dist[LCA(x,right)]+dist[LCA(left,right)];
	}
	else // in side
	{
		if(it2->val==n+10) /// all in left
		{
			it2=st.begin(); it2++;
			int left=it2->val;
			int right=it1->val;
			if(flag) st.insert(ND);
			return dist[x]-dist[LCA(x,left)]-dist[LCA(x,right)]+dist[LCA(left,right)];
		}
		else if(it1->val==0) /// all in right
		{
			int left=it2->val;
			it1=st.end();
			it1--; it1--;
			int right=it1->val;

			if(flag) st.insert(ND);
			return dist[x]-dist[LCA(x,left)]-dist[LCA(x,right)]+dist[LCA(left,right)];
		}
	}
}

/// return change val of solve
int solve(int kind,int x)
{
	Node ND = (Node){x,ti[x]};

	/// if in mid find nearst point
	set<Node>::iterator it1,it2;

	if(kind==1) // add
	{
		if(st.count(ND)==1) return 0;
		if(st.size()==2)
		{
			st.insert(ND);
			return 0;
		}
		else if(st.size()==3)
		{
			it1=st.begin(); it1++;
			int v=it1->val;
			st.insert(ND);
			return dist[x]+dist[v]-2*dist[LCA(v,x)];
		}
		else
		{
			return CL(1,ND);
		}
	}
	else if(kind==2) // remove
	{
		if(st.count(ND)==0) return 0;
		if(st.size()==3)
		{
			st.erase(ND);
			return 0;
		}
		else if(st.size()==4)
		{
			it1=st.begin();
			it1++;

			int v=it1->val;
			it1++;

			int u=it1->val;
			st.erase(ND);
			return dist[u]+dist[v]-2*dist[LCA(u,v)];
		}
		else
		{
			return CL(0,ND);
		}
	}
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);

	int T_T,cas=1;
	scanf("%d",&T_T);
	while(T_T--)
	{
		scanf("%d%d",&n,&q);
		init();
		for(int i=0,u,v,c;i<n-1;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			Add_Edge(u,v,c); Add_Edge(v,u,c);
		}
		cnt=1; st.clear();
		st.insert((Node){0,-INF});
		st.insert((Node){n+10,INF});
		dfs(0,1,1); BFS(1);

		int all=0;
		printf("Case #%d:\n",cas++);
		while(q--)
		{
			int k,x;
			scanf("%d%d",&k,&x);

			if(k==1) all+=solve(k,x);
			else if(k==2) all-=solve(k,x);

			printf("%d\n",all);
		}
	}

    return 0;
}
时间: 2024-10-23 06:54:34

HDOJ 5296 Annoying problem LCA+数据结构的相关文章

HDU 5296 Annoying problem LCA+树状数组

题解链接 Annoying problem Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 480    Accepted Submission(s): 146 Problem Description Coco has a tree, whose nodes are conveniently labeled by 1,2,-,n, w

HDU 5296 Annoying Problem 树链剖分 LCA 倍增法

HDU 5296 Annoying Problem 题目链接:hdu 5296 题意:在一棵给定的具有边权的树,一个节点的集合S(初始为空),给定Q个操作,每个操作增加或删除S中的一个点,每个操作之后输出使集合S中所有点联通的最小子树的边权和. 思路:最小子树上的节点的充要条件: 节点为(S集合中所有点的LCA)的子节点: 节点有一个子孙为S集合中的点. 那么我们给每个节点都开一个标记数组,初始为零,每加入一个节点,就把从这个节点到根节点路径上的点的值都+1,反之-1,这样通过对每个单节点值的查

HDU 5296 Annoying problem(LCA模板+树的dfs序心得)

Problem Description Coco has a tree, whose nodes are conveniently labeled by 1,2,-,n, which has n-1 edge,each edge has a weight. An existing set S is initially empty. Now there are two kinds of operation: 1 x: If the node x is not in the set S, add n

hdu5296(2015多校1)--Annoying problem(lca+一个公式)

Annoying problem Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 483    Accepted Submission(s): 148 Problem Description Coco has a tree, whose nodes are conveniently labeled by 1,2,-,n, which

【HDOJ】5296 Annoying problem

LCA+RMQ.挺不错的一道题目. 思路是如何通过LCA维护费用.当加入新的点u是,费用增量为dis[u]-dis[lca(u, lower_u)] - dis[lca(u, greater_u)] + dis[lca(lower_u, greater_u)].若beg[u]大于当前最大值或小于最小值,lower_u=min of current, greater_u = max of current. 1 /* 5296 */ 2 #include <iostream> 3 #include

【LCA】HDU 5296 Annoying problem

通道:http://acm.hdu.edu.cn/showproblem.php?pid=5296 题意:给一棵n个节点的树,再给q个操作,初始集合S为空,每个操作要在一个集合S中删除或增加某些点,输出每次操作后:要使得集合中任意两点互可达所耗最小需要多少权值.(记住只能利用原来给的树边.给的树边已经有向.10万个点,10万个操作) 思路: 代码: 1 #pragma comment(linker, "/STACK:102400000,102400000") 2 #include &l

[HDU 5296] Annoying problem (DFS序性质+LCA)

HDU - 5296 一棵树上有若干个点,每条边有一个边权 给一个初始为空的集合,每次向集合内添加一个点或者删除一个点 问每次操作结束后,将集合内所有点连起来的边权和为多少 假设集合内已经有一些点,那么再加一个点所增加的边权 将会是这个点到某一条链的距离 但是这条链不能随便挑选,否则可能会经过已经选择的边 挑选策略就是,找到集合内dfs序比当前点大和小的两个点组成的链 换句话来说,就是集合内dfs序最靠近当前点的两个点 设当前点 x,这样选链,选出的链是 (u,v),并且设dfsn[u]<dfs

HDU 5296 Annoying problem

http://acm.hdu.edu.cn/showproblem.php?pid=5296 实际上问题可以转化为点到一个连通子树的最短距离.. //Hello. I'm Peter. #pragma comment(linker, "/STACK:102400000,102400000") #include<cstdio> #include<iostream> #include<sstream> #include<cstring> #i

HDU5296 Annoying problem(LCA)

1 //#pragma comment(linker, "/STACK:1677721600") 2 #include <map> 3 #include <set> 4 #include <stack> 5 #include <queue> 6 #include <cmath> 7 #include <ctime> 8 #include <vector> 9 #include <cstdio>