dfs树与tarjan算法

标签（空格分隔）： 517coding problem solution dfs树 tarjan

Task 1

给出一幅无向图\(G\),在其中给出一个dfs树\(T\),选出\(G\)中的一个边集\(E\),使得在所有T-Simple-Circle（即最多有1条边不在\(T\)中的路径）包含至少一个\(E\)中的元素，最小化\(E\)中元素个数。

对于100%的数据 \(1 \leq n \leq 2 \times 10^3, 1 \leq m \leq 2\times 10^4\)

考虑到选取边一定是在\(T\)中，所以对于一个简单环构成的路径，连接着当前节点和它的祖先节点这一条树上的路径，这条路径上必须选择一条边被选择。

将边下放到其对应子节点，

考虑到一个贪心，只需要将这些链按照深度较浅的节点深度递减排序，每一次如果当前链没有被点覆盖，那么就将深度较浅的点覆盖，这样线段本身被覆盖然后对后续的线段有不低于放在深度较浅的点之下的点的效果。

虽然可以树链剖分达到\(O(n{ log_2 }^2 n)\)的复杂度，但没有必要。

最终复杂度是\(O(n^2)\)

  1. # include<bits/stdc++.h>
  2. using namespace std;
  3. const int N=2e3+10,M=2e4+10;
  4. struct rec{ int pre,to; }a[M<<1];
  5. struct node{ int u,v; }rec[N];
  6. int n,m,tot=1,g;
  7. int head[N],dep[N],pre[N];
  8. bool mark[N],inTree[M<<1];
  9. vector<node>V;
  10. void clear()
  11. {
  12. 	tot=1;
  13. 	memset(a,0,sizeof(a)); memset(rec,0,sizeof(rec));
  14. 	memset(dep,0,sizeof(dep)); memset(head,0,sizeof(head));
  15. 	memset(pre,0,sizeof(pre)); memset(mark,false,sizeof(mark));
  16. 	memset(inTree,false,sizeof(inTree)); V.clear();
  17. }
  18. void adde(int u,int v,bool flag)
  19. {
  20. 	a[++tot].pre=head[u];
  21. 	a[tot].to=v;
  22. 	head[u]=tot;
  23. 	if (flag) inTree[tot]=1;
  24. }
  25. void dfs(int u,int fa)
  26. {
  27. 	dep[u]=dep[fa]+1;
  28. 	for (int i=head[u];i;i=a[i].pre){
  29. 		int v=a[i].to; if (v==fa) continue;
  30. 		pre[v]=u; dfs(v,u);
  31. 	}
  32. }
  33. bool cmp(node x,node y){return dep[x.v]>dep[y.v];}
  34. bool check(int s,int t)
  35. {
  36. 	while (pre[s]!=t) {
  37. 		if (mark[s]) return true;
  38. 		s=pre[s];
  39. 	}
  40. 	if (mark[s]) return true;
  41. 	g=s;
  42. 	return false;
  43. }
  44. int main()
  45. {
  46. 	//freopen("data.in","r",stdin);
  47. 	while (true) {
  48. 		scanf("%d%d",&n,&m); if (!n&&!m) break;
  49. 		for (int i=1;i<n;i++) {
  50. 			int u,v; scanf("%d%d",&u,&v);
  51. 			adde(u,v,1); adde(v,u,1);
  52. 			rec[i]=(node){u,v};
  53. 		}
  54. 		dfs(1,0);
  55. 		for (int i=n;i<=m;i++) {
  56. 			int u,v; scanf("%d%d",&u,&v);
  57. 			adde(u,v,0); adde(v,u,0);
  58. 		}
  59. 		for (int i=1;i<n;i++) {
  60. 			int u=rec[i].u;
  61. 			for (int w=head[u];w;w=a[w].pre){
  62. 				int v=a[w].to; if (dep[v]>dep[u]||inTree[w]) continue;
  63. 				V.push_back((node){u,v});
  64. 			}
  65. 			u=rec[i].v;
  66. 			for (int w=head[u];w;w=a[w].pre){
  67. 				int v=a[w].to; if (dep[v]>dep[u]||inTree[w]) continue;
  68. 				V.push_back((node){u,v});
  69. 			}
  70. 		}
  71. 		sort(V.begin(),V.end(),cmp);
  72. 		int ans=0;
  73. 		for (int i=0;i<V.size();i++) {
  74. 			int s=V[i].u,t=V[i].v;
  75. 			if (check(s,t)) continue;
  76. 			else mark[g]=1,ans++;
  77. 		}
  78. 		printf("%d\n",ans);
  79. 		clear();
  80. 	}
  81. 	return 0;
  82. }

Task 2

在无向图\(G\)中取任意一个生成树，求出这些生成树必然会经过哪些边。

对于100%的数据$2 \leq N \leq 10^4, 1\leq M \leq 10^5 $

如果一条边是割边，那么它必然会出现在生成树中。

本题转化为求出所有的割边。

使用tarjan算法，其中dfn表示无向图的一棵dfs树中节点的dfs序编号，low表示节点经过一条不在dfs树上的边能连接到的节点中dfs序最小值。

显然，割边的判断条件是对于边\((u,v)是割边\),当且仅当$low_{v} > dfn_{u} $

如有重边，仍然可以处理，显然只需要记一下当前进入该节点的边编号（可以用成对变换）如果当前回到父亲节点的这条边不是来的那条边，就说明这两个节点直接含有重边了，一旦含有重边，那么子节点的low值就可以用父亲的dfs序值更新了。

这道题就做完了，\(O(n)\)

  1. # include<bits/stdc++.h>
  2. using namespace std;
  3. const int N=1e4+10,M=1e5+10;
  4. struct rec{ int pre,to; }a[M<<1];
  5. int dfn[N],low[N],n,m,head[N],tot=1;
  6. bool bridge[M<<1];
  7. void clear()
  8. {
  9. 	tot=1;
  10. 	memset(a,0,sizeof(a)); memset(dfn,0,sizeof(dfn));
  11. 	memset(low,0,sizeof(low)); memset(head,0,sizeof(head));
  12. 	memset(bridge,false,sizeof(bridge));
  13. }
  14. void adde(int u,int v)
  15. {
  16. 	a[++tot].pre=head[u];
  17. 	a[tot].to=v;
  18. 	head[u]=tot;
  19. }
  20. void tarjan(int u,int id)
  21. {
  22. 	low[u]=dfn[u]=++dfn[0];
  23. 	for (int i=head[u];i;i=a[i].pre) {
  24. 		int v=a[i].to;
  25. 		if (!dfn[v]) {
  26. 			tarjan(v,i);  low[u]=min(low[u],low[v]);
  27. 			if (low[v]>dfn[u]) bridge[i]=bridge[i^1]=1;
  28. 		} else if (i!=(id^1)) low[u]=min(low[u],dfn[v]);
  29. 	}
  30. }
  31. int main()
  32. {
  33. 	int T; scanf("%d",&T);
  34. 	while (T--) {
  35. 		scanf("%d%d",&n,&m);
  36. 		for (int i=1;i<=m;i++) {
  37. 			int u,v; scanf("%d%d",&u,&v);
  38. 			adde(u,v); adde(v,u);
  39. 		}
  40. 		tarjan(1,0); int cnt=0;
  41. 		for (int i=2;i<=tot;i+=2) if (bridge[i]) cnt++;
  42. 		printf("%d\n",cnt);
  43. 		for (int i=2;i<=tot;i+=2)
  44. 			if (bridge[i]) printf("%d%c",i>>1,(--cnt)==0?'\n':' ');
  45. 		if (T!=0) puts("");
  46. 		clear();
  47. 	}
  48. 	return 0;
  49.  }

Task 3

无向图找割点

我也不知道它的输入为什么这么复杂（是为了掩饰这道题水的本质吗？）

  1. # include <iostream>
  2. # include <cstdio>
  3. # include <cstring>
  4. # define min(a,b) ((a)<(b)?(a):(b))
  5. # define max(a,b) ((a)<(b)?(b):(a))
  6. using namespace std;
  7. const int N=105,M=N*N;
  8. struct rec{ int pre,to; }a[M<<1];
  9. bool cur[N];
  10. int dfn[N],low[N],head[N],root;
  11. int n,m,tot;
  12. void clear()
  13. {
  14. 	memset(a,0,sizeof(a)); memset(cur,false,sizeof(cur));
  15. 	memset(dfn,0,sizeof(dfn)); memset(low,0,sizeof(low));
  16. 	memset(head,0,sizeof(head)); tot=0;
  17. }
  18. void adde(int u,int v)
  19. {
  20. 	a[++tot].pre=head[u];
  21. 	a[tot].to=v;
  22. 	head[u]=tot;
  23. }
  24. void tarjan(int u)
  25. {
  26. 	dfn[u]=low[u]=++dfn[0];
  27. 	int flag=0;
  28. 	for (int i=head[u];i;i=a[i].pre) {
  29. 		int v=a[i].to;
  30. 		if (!dfn[v]){
  31. 			tarjan(v); low[u]=min(low[u],low[v]);
  32. 			if (low[v]>=dfn[u]) {
  33. 				flag++;
  34. 				if (u!=root || flag>1) cur[u]=1;
  35. 			}
  36. 		} else low[u]=min(low[u],dfn[v]);
  37. 	}
  38. }
  39. int main()
  40. {
  41. 	while (true) {
  42. 		scanf("%d",&n); if (!n) break;
  43. 		while (true) {
  44. 			int u; scanf("%d",&u); if (!u) break;
  45. 			while (getchar()!='\n') {
  46. 				int v; scanf("%d",&v);
  47. 				adde(u,v); adde(v,u);
  48. 			}
  49. 		}
  50. 		for (int i=1;i<=n;i++) if (!dfn[i]) tarjan(root=i);
  51. 		int ans=0;
  52. 		for (int i=1;i<=n;i++) if (cur[i]) ans++;
  53. 		printf("%d\n",ans);
  54. 		clear();
  55. 	}
  56. 	return 0;
  57. }

Task 4

有向图\(G\)中各节点都有一个权值，从\(s\)点出发到\(P\)个合法终点中的一个被认为是一条合法路径。选取一条路径，可以重复经过一些点(但是其权值只可以获得一次)，最大化经过路径权值和。

对于100%的数据$1 \leq P\leq n,m\leq 5 \times 10^5 $

考虑到如果有环的话，那么最优的走法就是绕一圈环获取所有权值。

于是我们采用了\(tarjan\)算法来缩点，然后问题就转化为在\(DAG\)`上从\(s\)点出发到任意点的最长路了。(环中节点答案是一样的)

可以使用dp做法，将\(DAG\)进行拓扑排序，按照拓扑序做动态规划。

如果某个缩点的拓扑序在\(s\)所在的拓扑序之前，那么\(s\)是不可能走到那里的。

设\(f_u\)表示从\(s\)点到\(u\)点的最长路，转移就是\(f_u=max\{f_{from} + \sum w_u\}\)

答案就是包含合法终点的缩点的最大值。

还要注意一些问题，比如说dp初值除了出发点，其他必须全部设为-inf

由于dp的时候是取max的，所以重边应该没什么问题。

  1. # include <iostream>
  2. # include <cstdio>
  3. # include <cstring>
  4. # include <vector>
  5. # include <stack>
  6. # include <queue>
  7. # include <algorithm>
  8. # define int long long
  9. using namespace std;
  10. const int N=5e5+10;
  11. struct rec{ int pre,to; }a[N<<1];
  12. stack<int>s; queue<int>q;
  13. bool ok[N],ins[N];
  14. int dfn[N],low[N],c[N],val[N],w[N],head[N],seq[N],in[N],f[N];
  15. vector<int>E[N],F[N];
  16. vector<int>scc[N];
  17. vector<pair<int,int> >Edge;
  18. int n,m,tot,cnt;
  19. void adde(int u,int v)
  20. {
  21.     a[++tot].pre=head[u];
  22.     a[tot].to=v;
  23.     head[u]=tot;
  24. }
  25. void tarjan(int u)
  26. {
  27.     dfn[u]=low[u]=++dfn[0];s.push(u);ins[u]=1;
  28.     for (int i=head[u];i;i=a[i].pre){
  29.         int v=a[i].to;
  30.         if (!dfn[v]) tarjan(v),low[u]=min(low[u],low[v]);
  31.         else if (ins[v]) low[u]=min(low[u],dfn[v]);
  32.     }
  33.     if (dfn[u]==low[u]) {
  34.         int v; ++cnt;
  35.         do {
  36.             v=s.top(); s.pop(); ins[v]=0;
  37.             c[v]=cnt; scc[cnt].push_back(v);
  38.             val[cnt]+=w[v];
  39.         } while (v!=u);
  40.     }
  41. }
  42. void toposort(int s)
  43. {
  44. 	if (!in[s]) q.push(s);
  45.     for (int i=1;i<=cnt;i++) if (!in[i] && i!=s) q.push(i);
  46.     while (!q.empty()) {
  47.         int u=q.front();q.pop();
  48.         seq[++seq[0]]=u;
  49.         for (int i=0;i<E[u].size();i++) {
  50.             int v=E[u][i];
  51. 			in[v]--; if (!in[v]) q.push(v);
  52.         }
  53.     }
  54. }
  55. signed main()
  56. {
  57.     scanf("%lld%lld",&n,&m);
  58.     for (int i=1;i<=m;i++) {
  59.         int u,v; scanf("%lld%lld",&u,&v);
  60.         adde(u,v);
  61.     }
  62.     for (int i=1;i<=n;i++) scanf("%lld",&w[i]);
  63.     int s,p; scanf("%lld%lld",&s,&p);
  64.     for (int i=1;i<=p;i++) { int t; scanf("%lld",&t); ok[t]=1;}
  65.     for (int i=1;i<=n;i++) if (!dfn[i]) tarjan(i);
  66.     for (int u=1;u<=n;u++)
  67.      for (int i=head[u];i;i=a[i].pre) {
  68.      	int v=a[i].to; if (c[u]==c[v]) continue;
  69. 		Edge.push_back(make_pair(c[u],c[v]));
  70.      }
  71. 	sort(Edge.begin(),Edge.end());
  72.     Edge.erase((unique(Edge.begin(),Edge.end())),Edge.end());
  73.     for (int i=0;i<Edge.size();i++) {
  74.     	int u=Edge[i].first,v=Edge[i].second;
  75.     	E[u].push_back(v); in[v]++;
  76.     	F[v].push_back(u);
  77. 	}
  78.     toposort(s);
  79.     int pt; for (int i=1;i<=cnt;i++) if (c[s]==seq[i]) { pt=i; break;}
  80.     memset(f,-0x3f,sizeof(f)); f[c[s]]=val[c[s]];
  81.     for (int w=pt+1;w<=cnt;w++) {
  82.         int u=seq[w];
  83.         for (int i=0;i<F[u].size();i++) {
  84.             int v=F[u][i];
  85.             f[u]=max(f[u],f[v]);
  86.         }
  87.         f[u]+=val[u];
  88.     }
  89.     int ans=0;
  90.     for (int i=1;i<=n;i++) if (ok[i]) ans=max(ans,f[c[i]]);
  91.     printf("%lld\n",ans);
  92.     return 0;
  93. }

Task 5

有向图\(G\)中至少需加多少条有向边才能使每个节点都能从节点\(s\)出发被访问到。

对于100%的数据 \(1\leq s \leq n,m \leq 5000\)

缩点以后，图变成了\(DAG\)上的问题。

做一遍$ dfs \(找出所有不能和\)s\(所在的点联通的块，对于每一个连通块至少需要一条边才能和\)s$所在的点连通。

考虑到每一个入度为0的连通块其必然会加一条边使得其连接到\(s\)所在的连通块或者其他连通块。

所以答案是 不在\(s\)缩点里的且入度为0的连通块个数。

复杂度\(O(n)\)

  1. # include <bits/stdc++.h>
  2. using namespace std;
  3. const int N=5005;
  4. struct rec{ int pre,to; }a[N<<1];
  5. stack<int>s;
  6. int low[N],dfn[N],head[N],c[N],in[N];
  7. bool ins[N],vis[N];
  8. int n,m,tot,cnt;
  9. vector<int>E[N];
  10. void adde(int u,int v)
  11. {
  12. 	a[++tot].pre=head[u];
  13. 	a[tot].to=v;
  14. 	head[u]=tot;
  15. }
  16. void tarjan(int u)
  17. {
  18. 	dfn[u]=low[u]=++dfn[0]; s.push(u); ins[u]=1;
  19. 	for (int i=head[u];i;i=a[i].pre){
  20. 		int v=a[i].to;
  21. 		if (!dfn[v]) tarjan(v),low[u]=min(low[u],low[v]);
  22. 		else if (ins[v]) low[u]=min(low[u],dfn[v]);
  23. 	}
  24. 	if (low[u]==dfn[u]) {
  25. 		int v; ++cnt;
  26. 		do {
  27. 			v=s.top();s.pop();ins[v]=0;
  28. 			c[v]=cnt;
  29. 		} while (v!=u);
  30. 	}
  31. }
  32. void dfs(int u)
  33. {
  34. 	vis[u]=1;
  35. 	for (int i=0;i<E[u].size();i++) {
  36. 		int v=E[u][i]; if (vis[v]) continue;
  37. 		dfs(v);
  38. 	}
  39. }
  40. int main()
  41. {
  42. 	int s; scanf("%d%d%d",&n,&m,&s);
  43. 	for (int i=1;i<=m;i++) {
  44. 		int u,v; scanf("%d%d",&u,&v);
  45. 		adde(u,v);
  46. 	}
  47. 	for (int i=1;i<=n;i++) if (!dfn[i]) tarjan(i);
  48. 	for (int u=1;u<=n;u++)
  49. 	 for (int i=head[u];i;i=a[i].pre) {
  50. 	 	int v=a[i].to; if (c[u]==c[v]) continue;
  51. 	 	E[c[u]].push_back(c[v]); in[c[v]]++;
  52. 	}
  53. 	dfs(c[s]); int ans=0;
  54. 	for (int i=1;i<=cnt;i++)  if (!vis[i] && !in[i] ) ans++;
  55. 	printf("%d\n",ans);
  56. 	return 0;
  57. }

tarjan算法 习题的更多相关文章

  1. 近期公共祖先(LCA)——离线Tarjan算法+并查集优化

    一. 离线Tarjan算法 LCA问题(lowest common ancestors):在一个有根树T中.两个节点和 e&sig=3136f1d5fcf75709d9ac882bd8cfe0 ...

  2. 有向图强连通分量的Tarjan算法

    有向图强连通分量的Tarjan算法 [有向图强连通分量] 在有向图G中,如果两个顶点间至少存在一条路径,称两个顶点强连通(strongly connected).如果有向图G的每两个顶点都强连通,称G ...

  3. 点/边 双连通分量---Tarjan算法

    运用Tarjan算法,求解图的点/边双连通分量. 1.点双连通分量[块] 割点可以存在多个块中,每个块包含当前节点u,分量以边的形式输出比较有意义. typedef struct{ //栈结点结构 保 ...

  4. 割点和桥---Tarjan算法

    使用Tarjan算法求解图的割点和桥. 1.割点 主要的算法结构就是DFS,一个点是割点,当且仅当以下两种情况:         (1)该节点是根节点,且有两棵以上的子树;         (2)该节 ...

  5. Tarjan算法---强联通分量

    1.基础知识 在有向图G,如果两个顶点间至少存在一条路径,称两个顶点强连通(strongly connected).如果有向图G的每两个顶点都强连通,称G是一个强连通图.非强连通图有向图的极大强连通子 ...

  6. （转载）LCA问题的Tarjan算法

    转载自:Click Here LCA问题(Lowest Common Ancestors,最近公共祖先问题),是指给定一棵有根树T,给出若干个查询LCA(u, v)(通常查询数量较大),每次求树T中两 ...

  7. 强连通分量的Tarjan算法

    资料参考 Tarjan算法寻找有向图的强连通分量 基于强联通的tarjan算法详解 有向图强连通分量的Tarjan算法 处理SCC(强连通分量问题)的Tarjan算法 强连通分量的三种算法分析 Tar ...

  8. [知识点]Tarjan算法

    // 此博文为迁移而来,写于2015年4月14日,不代表本人现在的观点与看法.原始地址:http://blog.sina.com.cn/s/blog_6022c4720102vxnx.html UPD ...

  9. Tarjan 算法&模板

    Tarjan 算法 一.算法简介 Tarjan 算法一种由Robert Tarjan提出的求解有向图强连通分量的算法,它能做到线性时间的复杂度. 我们定义: 如果两个顶点可以相互通达,则称两个顶点强连 ...

随机推荐

  1. sql server第三方产品

    sql server第三方产商工具 双活: 1. Moebius for SQL Server :http://www.grqsh.com/Subpage/product_MoebiusDA.html ...

  2. Dubbo使用Sentinel来对服务进行降级与限流

    一.Sentinel 是什么 Sentinel 是阿里中间件团队开源的,面向分布式服务架构的轻量级流量控制产品,主要以流量为切入点,从流量控制.熔断降级.系统负载保护等多个维度来帮助用户保护服务的稳定 ...

  3. sql server不同排序规则的数据库间字段的比较

    不同的排序规则的字段是不能直接比较的.会提示:无法解决 equal to 操作的排序规则冲突.可以把字段强制转换一个排序规则,这样就能比较了.示例: ------------------------- ...

  4. python-day40(正式学习)

    目录 线程队列 1 2 3 线程定时器 进程池和线程池 线程队列 1 import queue q=queue.Queue() q.put('123') q.put('456') q.put('789 ...

  5. CALL apoc.cypher.doIt创建动态节点的时候怎么指定多个标签？

    下面的创建节点实例,请教一下CALL apoc.cypher.doIt如何创建多个标签?现在的方式是只能指定一个标签! UNWIND [{name:"sdasdsad234fdgsasdfa ...

  6. Tomcat的安全性

    Web应用程序的一些内容是受限的,只有授权的用户在提供了正确的用户名和密码后才能查看他们,servlet技术支持通过配置部署 描述器(web.xml)来对这些内容进行访问控制,那么web容器是怎么样支 ...

  7. 使用iview 的表单组件验证 Upload 组件

    使用iview 的表单组件验证 Upload 组件 结果: 点击提交按钮, 没有填的form 项, 提示错误, 当填入数据后提示验证成功 代码: <template> <div id ...

  8. react如何通过shouldComponentUpdate来减少重复渲染

    转自:https://segmentfault.com/a/1190000016494335 在react开发中,经常会遇到组件重复渲染的问题,父组件一个state的变化,就会导致以该组件的所有子组件 ...

  9. 设置Windows静态IP+动态IP

    静态IP 设置以太网属性 进入IPv4属性 设置IPv4 动态IP 同上方法,只不过选成了自动

  10. h5图片展示和ajax上传

    <img src="" id="img"/> <script src="http://static.lamian.tv//pc/pu ...