码迷,mamicode.com
首页 > 其他好文 > 详细

tarjan

时间:2017-10-25 23:51:59      阅读:270      评论:0      收藏:0      [点我收藏+]

标签:最短路   sha   alt   es2017   编号   背景   bool   png   分享   

tarjan算法详解直通车

 

什么是缩点?

当我们在求出强连通分量之后,我们可以把同一个强连通分量里的点当成新图里的一个新点,然后如果原图中两个不在同一个强连通分量的点有连边的话,那么他们所对应的新点也有连边。

我们可以知道,新图一定是一个有向无环图(DAG)。

void Shrink_point() {
    for(int i=1; i<=n; i++)
        for(int j=head[i]; j; j=edge[j].pre) {
            int to=edge[j].to;
            if(col[i]!=col[to])
                add(col[i],col[to]);
        }
}

P3387 【模板】缩点

题目背景

缩点+DP

题目描述

  给定一个n个点m条边有向图,每个点有一个权值,求一条路径,使路径经过的点权值之和最大。你只需要求出这个权值和。

允许多次经过一条边或者一个点,但是,重复经过的点,权值只计算一次。

输入输出格式

输入格式:

第一行,n,m

第二行,n个整数,依次代表点权

第三至m+2行,每行两个整数u,v,表示u->v有一条有向边

输出格式:

共一行,最大的点权之和。

输入输出样例

输入样例#1:
2 2
1 1
1 2
2 1
输出样例#1:
2

说明

n<=10^4,m<=10^5,|点权|<=1000

算法:Tarjan缩点+DAGdp

/*----------------------------------------------------*/

#样例:

 

10 20
970 369 910 889 470 106 658 659 916 964
3 2
3 6
3 4
9 5
8 3
5 8
9 1
9 7
9 8
7 5
3 7
7 8
1 7
10 2
1 10
4 8
2 6
3 1
3 5
8 5

#输出:

6911

技术分享

 

 

/*----------------------------------------------------*/

题解:

  Tarjan缩点+最短路(spfa)

  为何缩点?—— 因为可以重复经过点,所以一个点所在的强联通分量必定可以到达,所以直接缩点即可

  暴力从每个点跑spfa,取最大权值

代码:

技术分享
#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;

const int M = 100010;
int n,m,dis[M],value[M],ans,num_edge,dfn[M],low[M];
int Right[M],head[M];
struct Edge {
    int pre,to,len;
} edge[M*4];

void add(int u,int v) {
    edge[++num_edge].pre = head[u];
    edge[num_edge].to = v;
    head[u]=num_edge;
}

int numb_edge,head1[M];
struct Edge1 {
    int pre,to,len;
} edge1[M*3];

void add1(int u,int v) {
    edge1[++numb_edge].pre = head1[u];
    edge1[numb_edge].to = v;
    head1[u]=numb_edge;
}

int dfs_num,stack[M],top,col[M],col_num;
bool vis[M];
void tarjan(int x) {
    dfn[x]=low[x]=++dfs_num;
    stack[++top]=x;
    vis[x]=1;
    for(int i=head[x]; i; i=edge[i].pre) {
        int to=edge[i].to;
        if(!dfn[to]) {
            tarjan(to);
            low[x]=min(low[x],low[to]);
        } else if(vis[to]) {
            low[x]=min(low[x],dfn[to]);
        }
    }
    if(low[x]==dfn[x]) {
        ++col_num;
        vis[x]=false;
        while(stack[top+1]!=x) {
            col[stack[top]]=col_num;
            value[col_num]+=Right[stack[top]];
            ans=max(ans,value[col_num]);
            vis[stack[top--]]=false;
        }
    
    }
}

void Shrink_point() {
    for(int i=1; i<=n; i++)
        for(int j=head[i]; j; j=edge[j].pre) {
            int to=edge[j].to;
            if(col[i]!=col[to])
                add1(col[i],col[to]);
        }
}


bool v[M];
void spfa(int x) {
    memset(dis,0,sizeof(dis));
    memset(v,0,sizeof(v));
    dis[x]=value[x];
    queue<int>q;
    q.push(x);
    v[x]=true;
    while(!q.empty()) {
        int fst=q.front();
        q.pop();
        v[fst]=false;
        for(int i=head1[fst]; i; i=edge1[i].pre) {
            int to=edge1[i].to;
            if(dis[to]<dis[fst]+value[to]) {
                dis[to]=dis[fst]+value[to];
                if(!v[to]) {
                    v[to]=true;
                    q.push(to);
                }
            }
        }
    }
    for(int i=1; i<=col_num; i++)
        ans=max(ans,dis[i]);
}

int main() {
    scanf("%d%d",&n,&m);
    for(int i=1; i<=n; i++)
        scanf("%d",&Right[i]);
    int u,v;
    for(int i=1; i<=m; i++) {
        scanf("%d%d",&u,&v);
        add(u,v);
    }
    for(int i=1; i<=n; i++)
        if(!dfn[i]) tarjan(i);
    Shrink_point();
    for(int i=1; i<=col_num; i++)
        spfa(i);
    printf("%d",ans);
    return 0;
}
缩点

割点:如果在图G中去掉一个顶点(自然同时去掉与该顶点相关联的所有边)后,该图的连通分支数增加,则称该顶点为G的割点

访问路径可以绘制成下图(绿边为访问未访问顶点时经过的边,红边为访问已访问节点时经过的边):

 

技术分享

 

我们把上图称为DFS搜索树(DFS tree),上图中的绿边称为树边(tree edge),红边称为回边(back edge)。通过回边可以从一个点返回到之间访问过的顶点

首先选定一个根节点,从该根节点开始遍历整个图(使用DFS)。

对于根节点,判断是不是割点很简单——计算其子树数量,如果有2棵即以上的子树,就是割点。因为如果去掉这个点,这两棵子树就不能互相到达。

对于非根节点,判断是不是割点就有些麻烦了。我们维护两个数组dfn[]和low[],

dfn[u]表示顶点u第几个被(首次)访问

low[u]表示顶点u及其子树中的点,通过非父子边(回边),能够回溯到的最早的点(dfn最小)的dfn值(但不能通过连接u与其父节点的边)。对于边(u, v),如果low[v]>=dfn[u],此时u就是割点。

 

但这里也出现一个问题:怎么计算low[u]。

假设当前顶点为u,则默认low[u]=dfn[u],即最早只能回溯到自身。

有一条边(u, v),如果v未访问过,继续DFS,DFS完之后,low[u]=min(low[u], low[v]);

如果v访问过(且u不是v的父亲),就不需要继续DFS了,一定有dfn[v]<dfn[u],low[u]=min(low[u], dfn[v])。

 

P3388 【模板】割点(割顶)

题目背景

割点

题目描述

给出一个n个点,m条边的无向图,求图的割点。

输入输出格式

输入格式:

第一行输入n,m

下面m行每行输入x,y表示x到y有一条边

输出格式:

第一行输出割点个数

第二行按照节点编号从小到大输出节点,用空格隔开

输入输出样例

输入样例#1
6 7
1 2
1 3
1 4
2 5
3 5
4 5
5 6
输出样例#1:
1 
5

说明

n,m均为100000

tarjan 图不一定联通!!!

 代码:

 

技术分享
#include<cstdio>
#include<iostream>
using namespace std;

const int M = 100010;
int dfn[M],low[M];
int dfs_num,top,vis[M],col_num,n,m;
int head[M],num_edge,tot;
bool cut[M];

struct Edge {
    int pre,to,len;
} edge[M*4];

void add(int u,int v) {
    edge[++num_edge].pre = head[u];
    edge[num_edge].to = v;
    head[u] = num_edge;
}

void tarjan(int x,int fa) {
    tot=0;
    dfn[x]=low[x]=++dfs_num;
    for(int i=head[x]; i; i=edge[i].pre) {
        int to=edge[i].to;
        if(!dfn[to]) {
            tarjan(to,fa);
            low[x]=min(low[x],low[to]);
            if(low[to]>=dfn[x]&&x!=fa)
                cut[x]=true;
            if(x==fa) tot++;

        }
        low[x]=min(low[x],dfn[to]);
    }
    if(tot>=2&&x==fa)
        cut[x]=true;
}

int main() {
    scanf("%d%d",&n,&m);
    int x,y;
    for(int i=1; i<=m; i++) {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    for(int i=1; i<=n; i++)
        if(!dfn[i]) tarjan(i,i);
    int ans=0;
    for(int i=1; i<=n; i++)
        if(cut[i]) ans++;
    printf("%d\n",ans);
    for(int i=1; i<=n; i++)
        if(cut[i])
            printf("%d ",i);
    return 0;
}
割点

 

 

自己选的路,跪着也要走完!!!

 

tarjan

标签:最短路   sha   alt   es2017   编号   背景   bool   png   分享   

原文地址:http://www.cnblogs.com/wsdestdq/p/7711353.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!