连通图(tarjan等)

最新推荐文章于 2022-08-04 10:03:29 发布
最新推荐文章于 2022-08-04 10:03:29 发布
阅读量272 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44178736/article/details/99652142
版权

缩点

P2341 [HAOI2006]受欢迎的牛

题意：

给牛的个数n，和m条可传递关系，例如a->b表示a喜欢b
问被所有牛喜欢的牛有多少

分析：

缩点之后如果只有一个出度为0的超级点，那么这个点里的原始点数量就是答案，否则答案为0

code：
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<stack>
#include<algorithm>
typedef long long ll;
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=1e5+5;
int low[maxm],dfn[maxm],idx;
int head[maxm],to[maxm],nt[maxm],cnt;
int out[maxm];
int belong[maxm],sum,num[maxm];
bool ins[maxm];
stack<int>s;
void init(){
    memset(low,0,sizeof low);
    memset(dfn,0,sizeof dfn);
    memset(head,-1,sizeof head);
    memset(belong,0,sizeof belong);
    memset(out,0,sizeof out);
    memset(ins,0,sizeof ins);
    while(!s.empty())s.pop();
    idx=0;
    cnt=1;
    sum=0;
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void dfs(int u){
    low[u]=dfn[u]=++idx;
    s.push(u);
    ins[u]=1;
    for(int i=head[u];i!=-1;i=nt[i]){
        int v=to[i];
        if(!dfn[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }else if(ins[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u]){
        sum++;
        while(1){
            int x=s.top();
            s.pop();
            ins[x]=0;
            belong[x]=sum;
            num[sum]++;
            if(x==u)break;
        }
    }
}
int main(){
    init();
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        add(a,b);
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            dfs(i);
        }
    }
    for(int k=1;k<=n;k++){
        for(int i=head[k];i!=-1;i=nt[i]){
            int v=to[i];
            if(belong[k]!=belong[v]){
                out[belong[k]]++;//out++
            }
        }
    }
    vector<int>ans;
    for(int i=1;i<=sum;i++){
        if(!out[i]){
            ans.push_back(i);
        }
    }
    if(ans.size()==1){
        cout<<num[ans[0]]<<endl;
    }else{
        cout<<0<<endl;
    }
    return 0;
}

文件传递问题&&最少加多少边成为强连通图

poj1236 Network of Schools

题意：

n个学校，每个学校可以通讯若干个学校(即有向边)
问题1：现在要传递文件，问开始最少给多少个学校，能由这些学校传递给其他所有学校
问题2：要添加多少条边使得所有学校强连通

分析:

先缩点，计算超级点的入度和出度。
问题1的答案是：入度为0的超级点的个数
问题2的答案是：入度为0的点的个数，出度为0的点个数，两者的最大值
这里就不证明了

另外要特判一下开始就直接缩成一个点的情况,这种情况下问题2的答案为0

code：
#include<cstdio>
#include<cstring>
#include<iostream>
#include<map>
#include<stack>
#include<vector>
#include<cmath>
#include<algorithm>
typedef long long ll;
using namespace std;
const int maxm=1e4+5;
int head[maxm],nt[maxm],to[maxm],cnt;
int low[maxm],dfn[maxm],idx;
int belong[maxm],sum;
int in[maxm],out[maxm];
bool ins[maxm];
stack<int>s;
void init(){
    memset(head,-1,sizeof head);
    memset(low,0,sizeof low);
    memset(dfn,0,sizeof dfn);
    memset(in,0,sizeof in);
    memset(out,0,sizeof out);
    memset(belong,0,sizeof belong);
    memset(ins,0,sizeof ins);
    sum=0;
    idx=0;
    cnt=1;
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void dfs(int u){
    low[u]=dfn[u]=++idx;
    s.push(u);
    ins[u]=1;
    for(int i=head[u];i!=-1;i=nt[i]){
        int v=to[i];
        if(!dfn[v]){
            dfs(v);
            low[u]=min(low[u],low[v]);
        }else if(ins[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(low[u]==dfn[u]){
        sum++;
        while(1){
            int x=s.top();
            s.pop();
            ins[x]=0;
            belong[x]=sum;
            if(x==u)break;
        }
    }
}
int main() {
    init();
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        while(1){
            int t;
            cin>>t;
            if(!t)break;
            add(i,t);
        }
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            dfs(i);
        }
    }
    if(sum==1){//特判1的时候
        cout<<1<<endl;
        cout<<0<<endl;
        return 0;
    }
    for(int k=1;k<=cnt;k++){
        for(int i=head[k];i!=-1;i=nt[i]){
            int v=to[i];
            if(belong[k]!=belong[v]){
                in[belong[v]]++;
                out[belong[k]]++;
            }
        }
    }
    int inn=0,outt=0;
    for(int i=1;i<=sum;i++){
        if(!in[i])inn++;
        if(!out[i])outt++;
    }
    cout<<inn<<endl;
    cout<<max(inn,outt)<<endl;
    return 0;
}

无向图割点

例题：uva315(以前写的)
题意：

求割点数量

割点求法：

1.如果是根节点，有两棵以上子树，则该根节点是割点
2.如果不是根节点，假设当前点为x，去的点为y，当low[y]>=dfn[x]的时候点x是割点

code：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<stack>
#include<set>
#include<sstream>
#include<algorithm>
#define lowbit(x) (x&(-(x)))
#define coff ios::sync_with_stdio(0)
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=1e3+5;
int low[maxm],dfn[maxm],idx;
int head[maxm],nt[maxm<<1],to[maxm<<1],cnt;
set<int>ans;
int n;
int root;
void init(){
    memset(low,0,sizeof low);
    memset(dfn,0,sizeof dfn);
    memset(head,-1,sizeof head);
    cnt=1;
    idx=0;
    ans.clear();
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void input(){
    string s;
    while(getline(cin,s)){
        if(s=="0")break;
        stringstream str(s);
        int st;
        str>>st;
        int ed;
        while(str>>ed){
            add(st,ed);
            add(ed,st);
        }
    }
}
void dfs(int x){
    low[x]=dfn[x]=++idx;
    int ch=0;
    for(int i=head[x];i!=-1;i=nt[i]){
        int v=to[i];
        if(!dfn[v]){
            dfs(v);
            low[x]=min(low[x],low[v]);
            if(low[v]>=dfn[x]){
                ch++;//这一步也可以放在外面，因为根节点的low肯定最小
                if(x!=root){//如果是根且low[v]>=dfn[x]
                    ans.insert(x);
                }
            }
        }else{
            low[x]=min(low[x],dfn[v]);
        }
    }
    if(x==root&&ch>=2){//如果是根节点且子树数量大于等于2
        ans.insert(x);
    }
}
void solve(){
    for(int i=1;i<=n;i++){
        if(!dfn[i]){
            root=i;
            dfs(i);
        }
    }
    printf("%d\n",ans.size());
}
int main(){
    while(scanf("%d",&n)!=EOF&&n){
        getchar();
        init();
        input();
        solve();
    }
    return 0;
}

无向图割边(桥)

例题:uva796 求无重边图的割边

求有重边图的割边：

递归过程改为记录入边的编号，编号就是边在邻接表的下标(链式前向星)。
利用链式前向星成对变换的技巧，无向图的每一条边都可以看作是双向边，
因为下标是成对存储的，所以利用异或就可以判断是否是回边，
如果不是回边则可以更新low[x]

code：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<stack>
#include<sstream>
#include<algorithm>
#define lowbit(x) (x&(-(x)))
#define coff ios::sync_with_stdio(0)
const int inf=0x3f3f3f3f;
const int inn=0x80808080;
using namespace std;
const int maxm=1e3+5;
int head[maxm],nt[maxm<<1],to[maxm<<2],cnt;
int low[maxm],dfn[maxm],idx;
int n,m;//n是点的数量，m是边的数量
vector<pair<int,int> >ans;//存放答案
void init(){
    memset(head,-1,sizeof head);
    memset(low,0,sizeof low);
    memset(dfn,0,sizeof dfn);
    cnt=1;
    idx=0;
    ans.clear();
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void input(){
    for(int i=1;i<=m;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
}
void dfs(int x,int pre){
    low[x]=dfn[x]=++idx;
    for(int i=head[x];i!=-1;i=nt[i]){
        int v=to[i];
        if(!dfn[v]){
            dfs(v,i);
            low[x]=min(low[x],low[v]);
            if(dfn[x]<low[v]){
                int a=to[i];
                int b=to[i^1];
//                if(a>b)swap(a,b);//可选，编号小的在左边
                ans.push_back({a,b});
            }
        }else if(i!=(pre^1)){//如果不是回边才能更新
            low[x]=min(low[x],dfn[v]);
        }
    }
}
void solve(){
    for(int i=1;i<=n;i++){//dfs
        if(!dfn[i]){
            dfs(i,-1);
        }
    }
//    sort(ans.begin(),ans.end());//编号排序，可选
    int len=ans.size();
    printf("%d critical links\n",len);//输出割边数量
    for(int i=0;i<len;i++){//输出割边的端点
        printf("%d - %d\n",ans[i].first,ans[i].second);
    }
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        init();
        input();
        solve();
    }
    return 0;
}

无向图双连通分量

待续

题集

2019南昌邀请赛Winner (tarjan)

题意：

n个人q次询问，每个人有三种能力值
n个人共进行n-1场比赛，每场都由你决定谁和谁比以及用哪种类型的能力值比，能力值大的获胜
然后每次询问给一个编号x，问由你决定比赛顺序，最后x能否获得冠军

思路：

对于每种能力值，排序一下，然后能力值大的向能力值小的连有向边
边是具有传递性，只需要建成一条链即可

三种能力值的图建在一起，跑tarjan缩点，入度为0的超级点内都是可以得到冠军的点
对于每次询问判断一下x所属超级点是否入度为0即可

code:
//https://nanti.jisuanke.com/t/40259
#include<bits/stdc++.h>
using namespace std;
const int maxm=1e5+5;
struct Node{
    int v,id;
}e[maxm];
vector<int>g[maxm];
int n,q;
stack<int>stk;
int mark[maxm];
int dfn[maxm];
int low[maxm];
int belong[maxm];
int in[maxm];
int idx,sum;
bool cmp(Node a,Node b){
    return a.v>b.v;
}
void dfs(int x){
    dfn[x]=low[x]=++idx;
    mark[x]=1;
    stk.push(x);
    for(int v:g[x]){
        if(!dfn[v]){
            dfs(v);
            low[x]=min(low[x],low[v]);
        }else if(mark[v]){
            low[x]=min(low[x],dfn[v]);
        }
    }
    if(low[x]==dfn[x]){
        sum++;
        while(1){
            int t=stk.top();
            stk.pop();
            belong[t]=sum;
            mark[t]=0;
            if(t==x)break;
        }
    }
}
signed main(){
    scanf("%d%d",&n,&q);
    //第一种
    for(int i=1;i<=n;i++){
        scanf("%d",&e[i].v);
        e[i].id=i;
    }
    sort(e+1,e+1+n,cmp);
    for(int i=1;i<n;i++){
        g[e[i].id].push_back(e[i+1].id);
    }
    //第二种
    for(int i=1;i<=n;i++){
        scanf("%d",&e[i].v);
        e[i].id=i;
    }
    sort(e+1,e+1+n,cmp);
    for(int i=1;i<n;i++){
        g[e[i].id].push_back(e[i+1].id);
    }
    //第三种
    for(int i=1;i<=n;i++){
        scanf("%d",&e[i].v);
        e[i].id=i;
    }
    sort(e+1,e+1+n,cmp);
    for(int i=1;i<n;i++){
        g[e[i].id].push_back(e[i+1].id);
    }
    //缩点
    for(int i=1;i<=n;i++){
        if(!dfn[i])dfs(i);
    }
    //标记入度不为0的超级点
    for(int x=1;x<=n;x++){
        for(int v:g[x]){
            if(belong[x]!=belong[v]){
                in[belong[v]]=1;
            }
        }
    }
    //处理询问
    while(q--){
        int x;
        scanf("%d",&x);
        if(in[belong[x]]==0){//如果入度为0则说明可以第一
            puts("YES");
        }else{
            puts("NO");
        }
    }
    return 0;
}
live4m
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode链表专题
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
02-04 964
链表
30段超实用CSS代码
lovemedsz的专栏
05-29 1191
http://www.csdn.net/article/2013-05-29/2815470-css-snippets-for-designers 1.花式连字符（&） 这个类应该在span元素里使用，并且里面包括&字符。它使用经典的serif字体和斜体来增强&符号。 1 2 3 4 5 .amp {     font-family: Bask
50 Useful CSS Snippets Every Designer Should Have
一个Java菜鸟(同微信公众号)
05-30 1万+
With so many new trends advancing every year it can be difficult keeping up with the industry. Website designers and frontend developers have been deeply ingrained into the newer CSS3 properties,
30段超实用CSS代码 (2)
u010652440的专栏
07-17 9373
16.气泡引用效果 　　这种效果常出现在论坛、创建公告牌或者是文本引用上。你只需把下面这段代码拷贝到样式表文件即可。这里（需翻墙）提供了许多关于语音泡泡的代码片段和使用技巧，欢迎去围观。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1
Android 客户端起HttpServer NanoHttpd
热门推荐
郑敏
10-28 26万+
最近接到客户那边需求，说需要实现一个java后端请求android客户端，android客户端作为微型Web服务端，听起来真的很刺激，后面去网上查找一些资料，了解NanoHttpd是怎么回事?NanoHTTPD是一个免费、轻量级的(只有一个Java文件) HTTP服务器,可以很好地嵌入到Java程序中。支持 GET, POST, PUT, HEAD 和 DELETE 请求，支持文件上传，占用内存很...
连通图tarjan算法动画讲解呕心沥血之作
02-01
tarjan算法呕心沥血之作，动画演示，步步清晰可见，详细的描述了tarjan算法的工作过程，比网上的单纯的图片更加容易理解。
youxiangtu.rar_强连通_连通图
最新发布
09-24
理解并掌握强连通图的性质和检测算法，有助于解决复杂网络中的路径查找、网络连接性分析等问题。在提供的压缩包文件中，我们可以期待找到与之相关的实践案例和代码实现，进一步加深对强连通图的理解。
图的连通性问题
04-12
本课件主要讲解了并查集，割点和桥，强连通分量(Kosaraju, Tarjan)
无向图缩点：tarjan点双与边双缩点(模板)
01-20
Tarjan算法是一个用于查找图中强连通分量和检测桥的有效算法。 首先，让我们理解Tarjan算法的基本思想。Tarjan算法通过深度优先搜索（DFS）遍历图，同时维护两个关键值：`dfn`（深度优先访问编号）和`low`（到达...
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
判断连通图（并查集 ）
昊昊的专栏
02-15 5004
给定一个无向图和其中的所有边，判断这个图是否所有顶点都是连通的。 输入：每组数据的第一行是两个整数n 和m（0 数目，m 表示图中边的数目。如果n 为0 表示输入结束。随后有m 行数据，每 行有两个值x 和y（0顶点的编号从1 开始计 算。输入不保证这些边是否重复。 输出：对于每组输入数据，如果所有顶点都是连通的，输出 ’YES’ ，否则输 出 ’NO’。 ===样例输入===
JOBDU 1109 连通图
weixin_33943836的博客
03-14 83
题目1109：连通图 时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：4192 解决：2224 题目描述： 给定一个无向图和其中的所有边，判断这个图是否所有顶点都是连通的。 输入： 每组数据的第一行是两个整数 n 和 m（0<=n<=1000）。n 表示图的顶点数目，m 表示图中边的数目。如果 n 为 0 表示输入结束。随后有 m...
CSS的50个代码片段
weixin_33831196的博客
01-08 265
1.css全局   Html代码   html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, ...
题目1109：连通图
ych19871020的专栏
09-24 796
一道简单的并查集 #include #include #include #include using namespace std; int fa[10000]; int find(int x) { if(x==fa[x])return x; fa[x]=find(fa[x]); } void merge(int a,int b) { a=find(a); b=find(b); fa
UVA11806 Cheerleaders（容斥）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
08-17 182
题意： 给定n,m,k， 表示有一个n*m的矩阵， 现在你要在矩阵中选出k个不同的格子放k个人， 要求矩阵中四条边上都至少有一个人 (4个角的格子可以算作在两个边上) 答案对1e6+7取模 数据范围：n,m<=20，k<=500 解法： 答案=C(n*m,k)-至少一条边没人+至少两条边没人-至少三条边没人+至少四条边没人 用4位二进制数表示4条边放不放,二进制枚举一下就行了 (根据二进制1的位数,奇减偶加) code： #include<bits/stdc++.h> using
springSecurity学习
weixin_44348734的博客
08-04 423
Spring技术栈组成部分Apache 旗下的轻量级权限控制框架。​是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架Shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。​ 一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。​ 一般Web应用的需要进行认证和授权。​认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户​授权：经过认证后判断当前用户是否有权限进行某个操作。...
【RuoYi-Vue-Plus】学习笔记 26 - Redisson（四） 限流器 RateLimiter（Redisson 源码 + Lua 脚本）
MichelleChung的星球
06-05 1640
简单分析 Redisson 限流器 RateLimiter 源码以及底层 Lua 源码。
SpringBoot_整合SpringSecurity（前后端分离版）
m0_67393619的博客
08-02 3921
1、登录校验流程2、SpringSecurity简单过滤器链（完整的过滤器大概是14个），前后端分离一般用jwt，前后端不分离一般采用session。
C#取五笔或拼音代码
jinning13的专栏
05-12 3万+
        private string GetWbPy(string inputstring, string pywb)        {             string  thisletter = inputstring.Trim();            int letterlen  = thisletter.Length;            string pystring 

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值