连通分量板子

  求割点个数

/*  gyt
       Live up to every day            */
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<cstring>
#include<queue>
#include<set>
#include<string>
#include<map>
#include <time.h>
#define PI acos(-1)
using namespace std;
typedef long long ll;
typedef double db;
const int maxn = 4000+10;
const ll maxm = 1e7;
const int modd = 10000007;
const int INF = 1<<30;
const db eps = 1e-9;
struct Edge{
    int u, v, next;
}e[maxn*4];
int n, m, cnt,scnt, tot;
stack<int>sta;
int dfn[maxn], low[maxn], vis[maxn], head[maxn];
int a[maxn],  iscut[maxn], father[maxn];

void init() {
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(vis, 0, sizeof(vis));
    memset(iscut, 0, sizeof(iscut));
    memset(father, 0, sizeof(father));
    while(!sta.empty())  sta.pop();
    cnt=0;
    scnt=0;  tot=0;
}
void add(int u, int v) {
    e[cnt].v=v, e[cnt].next=head[u];
    head[u]=cnt++;
}
void Tarjan(int s, int fa) {
    int minn, t;
    father[s]=fa;
    dfn[s]=low[s]=++tot;
    vis[s]=2;
    sta.push(s);
    for (int i=head[s]; ~i; i=e[i].next) {
        int t=e[i].v;
        if (!dfn[t]) {
            Tarjan(t, s);
            low[s]=min(low[s], low[t]);
        } else {
            if (vis[t]==2) {
                low[s]=min(low[s], dfn[t]);
            }
        }
    }
}
void solve() {
    while(scanf("%d", &n)!=EOF) {
        if (!n)  break;
        init();
        int u, v;
        while(scanf("%d",&u) && u){
            while(getchar()!=‘\n‘){
                scanf("%d",&v);
                add(u,v);
                add(v,u);
            }
        }
        Tarjan(1, 0);
        int rootson=0;
        for (int i=2; i<=n; i++) {
            int k=father[i];
            if (k==1)  rootson++;
            else {
                if (low[i]>=dfn[k]) {
                    iscut[k]=1;
                }
            }
        }
        if (rootson>1)  iscut[1]=1;
        int ans=0;
        for (int i=1; i<=n; i++) {
            if (iscut[i])  ans++;
        }
        printf("%d\n", ans);
    }
}
int main() {
    int t = 1;
    //freopen("in.txt", "r", stdin);
    //scanf("%d", &t);
    while(t--)
        solve();
    return 0;
}

  是否联通

/*  gyt
       Live up to every day            */
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<cstring>
#include<queue>
#include<set>
#include<string>
#include<map>
#include <time.h>
#define PI acos(-1)
using namespace std;
typedef long long ll;
typedef double db;
const int maxn = 100000+10;
const ll maxm = 1e7;
const int modd = 10000007;
const int INF = 1<<30;
const db eps = 1e-9;
struct Edge{
    int u, v, next;
}e[maxn];
int n, m, cnt,scnt, tot;
stack<int>sta;
int dfn[maxn], low[maxn], vis[maxn], head[maxn];

void init() {
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(vis, 0, sizeof(vis));
    while(!sta.empty())  sta.pop();
    cnt=0;
    scnt=0;  tot=0;
}
void add(int u, int v) {
    e[cnt].v=v, e[cnt].next=head[u];
    head[u]=cnt++;
}
void Tarjan(int s) {
    int minn, t;
    dfn[s]=low[s]=++tot;
    vis[s]=2;
    sta.push(s);
    for (int i=head[s]; ~i; i=e[i].next) {
        int t=e[i].v;
        if (!dfn[t]) {
            Tarjan(t);
            low[s]=min(low[s], low[t]);
        } else {
            if (vis[t]==2) {
                low[s]=min(low[s], dfn[t]);
            }
        }
    }
    if (low[s]==dfn[s]) {
        scnt++;
        while(!sta.empty()) {
            int t=sta.top();
            sta.pop();
            vis[t]=1;
            if (t==s)  break;
        }
    }
}
void solve() {
    while(scanf("%d%d", &n, &m)!=EOF) {
        if (!n&&!m)  break;
        init();
        for (int i=0; i<m; i++) {
            int a, b;  scanf("%d%d", &a, &b);
            add(a, b);
        }
        for (int i=1; i<=n; i++) {
            if (!dfn[i])  Tarjan(i);
        }
        if (scnt==1)  puts("Yes");
        else  puts("No");
    }
}
int main() {
    int t = 1;
    //freopen("in.txt", "r", stdin);
    //scanf("%d", &t);
    while(t--)
        solve();
    return 0;
}

  缩点

/*  gyt
       Live up to every day            */
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<cstring>
#include<queue>
#include<set>
#include<string>
#include<map>
#include <time.h>
#define PI acos(-1)
using namespace std;
typedef long long ll;
typedef double db;
const int maxn = 4000+10;
const ll maxm = 1e7;
const int modd = 10000007;
const int INF = 1<<30;
const db eps = 1e-9;
struct Edge{
    int u, v, next;
}e[maxn*4];
int n, m, cnt,scnt, tot;
stack<int>sta;
int dfn[maxn], low[maxn], vis[maxn], head[maxn];
int du[maxn], color[maxn];
int a[maxn], in[maxn];

void init() {
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(vis, 0, sizeof(vis));
    memset(du, 0, sizeof(du));
    memset(color, 0, sizeof(color));
    for (int i=0; i<maxn; i++)  in[i]=INF;
    while(!sta.empty())  sta.pop();
    cnt=0;
    scnt=0;  tot=0;
}
void add(int u, int v) {
    e[cnt].v=v, e[cnt].next=head[u];
    head[u]=cnt++;
}
void Tarjan(int s) {
    int minn, t;
    dfn[s]=low[s]=++tot;
    vis[s]=2;
    sta.push(s);
    for (int i=head[s]; ~i; i=e[i].next) {
        int t=e[i].v;
        if (!dfn[t]) {
            Tarjan(t);
            low[s]=min(low[s], low[t]);
        } else {
            if (vis[t]==2) {
                low[s]=min(low[s], dfn[t]);
            }
        }
    }
    if (low[s]==dfn[s]) {
        scnt++;
        while(!sta.empty()) {
            int t=sta.top();
            sta.pop();
            vis[t]=1;
            color[t]=scnt;
            if (t==s)  break;
        }
    }
}
void solve() {
    while(scanf("%d%d", &n, &m)!=EOF) {
        for (int i=1; i<=n; i++) {
            scanf("%d", a+i);
        }
        init();
        for (int i=0; i<m; i++) {
            int a, b;  scanf("%d%d", &a, &b);
            add(a, b);
        }
        for (int i=1; i<=n; i++) {
            if (!dfn[i])  Tarjan(i);
        }
         for (int u=1; u<=n; u++) {
           for (int i=head[u]; ~i; i=e[i].next) {
                int v=e[i].v;
                if (color[u]!=color[v]) {
                    du[color[v]]++;
                }
            }
        }
        int ans=0, ansnum=0;
        for (int i=1; i<=scnt; i++) {
            if (!du[i]) {
                ans++;
                int num=INF;
                for (int j=1; j<=n; j++) {
                    if (color[j]==i) {
                        in[i]=min(a[j], in[i]);
                    }
                }
                ansnum+=in[i];
            }
        }
        printf("%d %d\n", ans, ansnum);
    }
}
int main() {
    int t = 1;
    //freopen("in.txt", "r", stdin);
    //scanf("%d", &t);
    while(t--)
        solve();
    return 0;
}
时间: 2024-10-05 02:00:05

连通分量板子的相关文章

UVALive - 5135 Mining Your Own Business(双连通分量)

题目大意:有N个矿井 ,由一些隧道连接起来,现在要修建尽量少的安全通道,使得无论哪里发生事故,所有人均能逃出,求建的最少的安全通道数量和方案数 解题思路:建安全通道的话,肯定不能建在割顶,因为割顶如果崩塌了,割顶所连接的双连通分量内的点就跑不掉了,还得在双连通分量里面再建点(上述为双连通分量内部只有一个割顶的情况),这样不划算,还不如直接在里面建点 如果一个双连通分量的内部割顶有多个的话,那么在这个双连通分量里面就可以不用建安全通道了,因为一个割顶崩塌了,还有其他点可以连向外面,所以,只考虑内部

poj 2524 求连通分量(并查集模板题)

求连通分量 Sample Input 10 91 21 31 41 51 61 71 81 91 1010 42 34 54 85 80 0Sample Output Case 1: 1Case 2: 7 1 # include <iostream> 2 # include <cstdio> 3 # include <cstring> 4 # include <algorithm> 5 # include <cmath> 6 # include

Arduino 板子 COM 接口找不到设备

复位 Arduino 板子 1.打开官方的blink程序. 2.重新拔插usb. 3.点下载. 4.按住左上角的复位按键不放. 5.等显示开始下载瞬间松开按键.把握住那个瞬间. 6.多试验几次看能下载好不.Arduino 板子 COM 接口找不到设备,布布扣,bubuko.com

[POJ2117]Electricity(连通分量,割点)

题目链接:http://poj.org/problem?id=2117 题意:求去掉割点后的最大连通分支个数. kuangbin的板子. 1 #include <algorithm> 2 #include <iostream> 3 #include <iomanip> 4 #include <cstring> 5 #include <climits> 6 #include <complex> 7 #include <casser

【转】BYV--有向图强连通分量的Tarjan算法

转自beyond the void 的博客: https://www.byvoid.com/zhs/blog/scc-tarjan 注:红色为标注部分 [有向图强连通分量] 在有向图G中,如果两个顶点间至少存在一条路径,称两个顶点强连通(strongly connected).如果有向图G的每两个顶点都强连通,称G是一个强连通图.非强连通图有向图的极大强连通子图,称为强连通分量(strongly connected components). 下图中,子图{1,2,3,4}为一个强连通分量,因为顶

一种基于连通分量的文本区域定位方法

本文通过比较基于纹理的方法和基于连通分量的方法发现对于复杂的背景使用基于连通分量的方法较好. 一.基于连通分量的方法和基于纹理的方法比较如下: 基于纹理的方法:将图像分割成块,然后提取块的纹理特征,并用分类器确认. 基于连通分量的方法:它是假设同一文本区域的字符具有相同的颜色,根据字符颜色的一致性及字符与背景有较大的颜色差来分割图像,提取连通分量,对连通分量利用几何约束关系得到文本区域. 基于纹理的方法的鲁棒性对于定位小字符的文本区域具有较好的效果,对噪声具有较高的抑制性.但是当定位大字符时,由

UVALive 5135 Mining Your Own Business 双连通分量 2011final

题意:n条隧道由一些点连接而成,其中每条隧道链接两个连接点.任意两个连接点之间最多只有一条隧道.任务就是在这些连接点中,安装尽量少的太平井和逃生装置,使得不管哪个连接点倒塌,工人都能从其他太平井逃脱,求最少安装数量和方案. 思路:其实本题就相当于在一张无向图中,涂尽量少的黑点,使得任意删除哪个点,每个连通分量至少有一个黑点.因为不同的连通分量最多只有一个公共点,那一定是割点.可以发现,涂黑割点是不划算的,而且在 一个点-双连通分量中涂黑两个黑点也是不划算的.所以只有当点-双连通分量只有一个割点时

初次拿到板子的兴奋

今天,DE2-115终于拿到手了,按捺不住内心的兴奋,马上试验一下. 一个简单的流水灯程序对照书本写好之后,遇到的第一个问题是如何将程序烧进芯片.不过还好,手头资料算是比较充足的. 1.程序很简单: //======================================================= // This code is generated by Terasic System Builder //======================================

UVALive-3523 Knights of the Round Table (双连通分量+二分图匹配)

题目大意:有n个骑士要在圆桌上开会,但是相互憎恶的两个骑士不能相邻,现在已知骑士们之间的憎恶关系,问有几个骑士一定不能参加会议.参会骑士至少有3个且有奇数个. 题目分析:在可以相邻的骑士之间连一条无向边,构成一张图G.则问题变成了有几个节点不在奇圈(有奇数个节点的圈)内,并且一个点在圈内最多出现一次.如果G不连通,应该对每一个分量分别求解.奇圈上的点一定在同一个双连通分量内,要找出所有的双连通分量.但是能构成二分图的双连通分量中一定没有奇圈,不能构成二分图的双连通分量中一定含有奇圈,并且分量中所