图论模板（最短路、tarjan）

奔跑的星黛露

已于 2022-11-03 19:28:05 修改

阅读量339

点赞数

分类专栏： ACM 文章标签：算法图论

于 2022-10-27 20:33:26 首次发布

本文链接：https://blog.csdn.net/Galaxy_Su/article/details/120223776

版权

ACM 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

最短路

Dijkstra普通版

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

int n,m,node[maxn][maxn],dist[maxn],vis[maxn];
int dijkstra(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=1;i<=n-1;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!vis[j] && (t==-1||dist[j]<dist[t])){
                t=j;
            }
        }
        for(int j=1;j<=n;j++){
            dist[j]=min(dist[j],dist[t]+node[t][j]);
        }
        vis[t]=1;
    }
    if(dist[n]==INF){
        return -1;
    }
    return dist[n];
}
int main(){
    scanf("%d%d",&n,&m);
    memset(node,0x3f,sizeof node);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        node[a][b]= min(node[a][b],c);
    }
    printf("%d\n",dijkstra());
    return 0;
}

Dijkstra堆优化

// vector版
int n,m,vis[maxn],dist[maxn];
vector<int> node[maxn],val[maxn];
int dijkstra(){
    dist[1]=0;
    priority_queue<PII,vector<PII>,greater<PII> > heap;
    heap.push({0,1});
    while(!heap.empty()){
        auto it=heap.top();
        heap.pop();
        int i=it.second;
        if(vis[i])  continue;
        vis[i]=1;
        for(int k=0;k<node[i].size();k++){
            int j=node[i][k];
            dist[j]=min(dist[j],dist[i]+val[i][k]);
            heap.push({dist[j],j});
        }
    }
    if(dist[n]==INF){
        return -1;
    }
    return dist[n];
}
int main(){
    memset(dist,0x3f,sizeof dist);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        node[a].push_back(b);
        val[a].push_back(c);
    }
    printf("%d\n",dijkstra());
    return 0;
}

// 链式前向星

int idx, e[N], ne[N], w[N], h[N];
void add(int u, int v, int c){
e[idx] = v, ne[idx] = h[u], w[idx] = c, h[u] = idx++;
}

int dis[N];
bool vis[N];
void dijkstra(int s){
priority_queue<PII, vector<PII>, greater<PII>> q;
for(int i = 1; i <= n; i++){
dis[i] = INF;
}
dis[s] = 0;
q.push({0, s});
while(!q.empty()){
auto [d, u] = q.top();
q.pop();
if(vis[u]) continue;
vis[u] = true;
for(int i = h[u]; ~i; i = ne[i]){
int v = e[i], c = w[i];
if(vis[v]) continue;
if(dis[u] + c < dis[v]){
dis[v] = dis[u] + c;
q.push({dis[v], v});
}
}
}
}

spfa求最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

int n,m,vis[maxn],dist[maxn];
vector<int> node[maxn],val[maxn];
int spfa(){
    dist[1]=0;
    queue<int> q;
    q.push(1);
    vis[1]=1;
    while(!q.empty()){
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=0;i<node[x].size();i++){
            int y=node[x][i];
            if(dist[y]>dist[x]+val[x][i]) {
                dist[y]=dist[x]+val[x][i];
                if (!vis[y]) {
                    q.push(y);
                    vis[y] = 1;
                }
            }
        }
    }
    return dist[n];
}
int main(){
    memset(dist,0x3f,sizeof dist);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        node[a].push_back(b);
        val[a].push_back(c);
    }
    int ans=spfa();
    if(ans==INF){
        printf("impossible\n");
    }
    else printf("%d\n",ans);
    return 0;
}

spfa判断负环

给定一个 nn 个点 mm 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你判断图中是否存在负权回路。

存在 “Yes" 否则 "No”

int n,m,vis[maxn],dist[maxn],cnt[maxn];
vector<int> node[maxn],val[maxn];
int spfa(){
    queue<int> q;
    for(int i=1;i<=n;i++){
        q.push(i);
        vis[i]=1;
    }
    while(!q.empty()){
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=0;i<node[x].size();i++){
            int y=node[x][i];
            if(dist[y]>dist[x]+val[x][i]) {
                dist[y]=dist[x]+val[x][i];
                cnt[y]=cnt[x]+1;
                if(cnt[y]>=n) return true;
                if (!vis[y]) {
                    q.push(y);
                    vis[y] = 1;
                }
            }
        }
    }
    return false;
}
int main(){
    memset(dist,0x3f,sizeof dist);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        node[a].push_back(b);
        val[a].push_back(c);
    }
    if(spfa()){
        puts("Yes");
    }
    else puts("No");
    return 0;
}

强连通分量

有向图最少加多少条边变成强连通分量？

max（p,q）【p:出度为0的点的数量 q:入度为0的点的数量】

无向图最少加多少条边变成强连通分量？

（cnt + 1） / 2 下取整【cnt：缩完点之后度数为1的点的个数】

有向图 - tarjan缩点

int e[M], ne[M], w[M], h[M], idx;
void add(int u, int v, int c){
e[idx] = v, ne[idx] = h[u], w[idx] = c, h[u] = idx++;
}

int dfn[N], low[N], tim, sta[N], top, vis[N], scc_cnt, id[N], siz[N];
void tarjan(int u){
dfn[u] = low[u] = ++tim;
sta[++top] = u, vis[u] = true;
for(int i = h[u]; ~i; i = ne[i]){
int v = e[i];
if(!dfn[v]){
tarjan(v);
low[u] = min(low[u], low[v]);
}
else if(vis[v]){
low[u] = min(low[u], dfn[v]);
}
}
if(dfn[u] == low[u]){
++scc_cnt;
int v;
do{
v = sta[top--];
vis[v] = false;
id[v] = scc_cnt;
siz[scc_cnt]++;
}while(v != u);
}
}

int main(){
for(int i = 1; i <= n; i++){
if(!dfn[i]) tarjan(i);
}
}

无向图 - tarjan缩点

桥

const int N=5e3+20,M=1e4+20;
int e[M],ne[M],h[N],idx;
int n,m;
int dfn[N],low[N],timestmp;
bool is_bridge[M];
int dcc_cnt,id[N],d[M];

void add(int a,int b){
e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

stack<int> st;
void tarjan(int u,int from){
dfn[u]=low[u]=++timestmp;
st.push(u);
for(int i=h[u];~i;i=ne[i]){
int j=e[i];
if(!dfn[j]){
tarjan(j,i);
low[u]=min(low[u],low[j]);
if(dfn[u]<low[j]){
is_bridge[i]=is_bridge[i^1]=true; // 此边为桥
}
}
else if(i!=(from^1)){
low[u]=min(low[u],dfn[j]);
}
}
if(dfn[u]==low[u]){
++dcc_cnt;
int y;
do{
y=st.top();
st.pop();
id[y]=dcc_cnt;
}while(y!=u);
}
}

int main(){
// freopen("123.in","r",stdin);
memset(h,-1,sizeof(h));
scanf("%d%d",&n,&m);
while(m--){
int a,b;
scanf("%d%d",&a,&b);
add(a,b),add(b,a);
}
tarjan(1,-1);
for(int i=0;i<idx;i++){
if(is_bridge[i])
d[id[e[i]]]++;
}
int res=0;
for(int i=1;i<=dcc_cnt;i++){
if(d[i]==1) res++;
}
printf("%d\n",(res+1)/2);
return 0;
}

割点【矿场搭建】

typedef unsigned long long ULL;

const int N = 1010, M = 1010;

int n, m;
int root; // 当前搜索的连通块的根

int h[N], e[M], ne[M], idx;
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

int dfn[N], low[N], timestamp, stk[N], top, dcc_cnt;
vector<int> dcc[N];
bool cut[N];
void tarjan(int u)
{
dfn[u] = low[u] = ++ timestamp;
stk[ ++ top] = u;

if (u == root && h[u] == -1) // 此连通块只有一个结点
{
dcc_cnt ++ ;
dcc[dcc_cnt].push_back(u);
return;
}

int cnt = 0;
for (int i = h[u]; ~i; i = ne[i])
{
int j = e[i];
if (!dfn[j])
{
tarjan(j);
low[u] = min(low[u], low[j]);
if (dfn[u] <= low[j])
{
cnt ++ ; // 与当前点相连的联通分量的数量
if (u != root || cnt > 1) cut[u] = true; // cut[u]记录u是否为割点
++ dcc_cnt;
int y;
do {
y = stk[top -- ];
dcc[dcc_cnt].push_back(y);
} while (y != j);
dcc[dcc_cnt].push_back(u);
}
}
else low[u] = min(low[u], dfn[j]);
}
}

int main()
{
int T = 1;
while (cin >> m, m)
{
for (int i = 1; i <= dcc_cnt; i ++ ) dcc[i].clear();
idx = n = timestamp = top = dcc_cnt = 0;
memset(h, -1, sizeof h);
memset(dfn, 0, sizeof dfn);
memset(cut, 0, sizeof cut);
while (m -- )
{
int a, b;
cin >> a >> b;
n = max(n, a), n = max(n, b);
add(a, b), add(b, a);
}

for (root = 1; root <= n; root ++ ) // 根需要全局记录
if (!dfn[root])
tarjan(root);
int res = 0;
ULL num = 1;
for (int i = 1; i <= dcc_cnt; i ++ )
{
int cnt = 0;
for (int j = 0; j < dcc[i].size(); j ++ )
if (cut[dcc[i][j]])
cnt ++ ;
if (cnt == 0)
{
if (dcc[i].size() > 1) res += 2, num *= dcc[i].size() * (dcc[i].size() - 1) / 2;
else res ++ ;
}
else if (cnt == 1) res ++, num *= dcc[i].size() - 1;
}
printf("Case %d: %d %llu\n", T ++, res, num);
}
return 0;
}

例题：电力（题目描述：给定一个由 n 个点 m 条边构成的无向图，请你求出该图删除一个点之后，连通块最多有多少）
const int N=1e4+20,M=3e4+20;
int n,m;
int ans,root;

int e[M],ne[M],h[N],idx;
void add(int a,int b){
e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

int dfn[N],low[N],timestmp;
void tarjan(int u){
dfn[u]=low[u]=++timestmp;
int cnt=0;
for(int i=h[u];~i;i=ne[i]){
int j=e[i];
if(!dfn[j]){
tarjan(j);
low[u]=min(low[u],low[j]);
if(dfn[u]<=low[j]) cnt++;
}
else low[u]=min(low[u],dfn[j]);
}
if(u!=root) cnt++;
ans=max(ans,cnt);
}

int main(){
// freopen("123.in","r",stdin);
while(scanf("%d%d",&n,&m),n||m){
memset(h,-1,sizeof(h));
memset(dfn,0,sizeof(dfn));
idx=timestmp=0;
while(m--){
int a,b;
cin>>a>>b;
add(a,b),add(b,a);
}
ans=0;
int cnt=0;
for(root=0;root<n;root++){
if(!dfn[root]){
cnt++;
tarjan(root);
}
}
printf("%d\n",ans+cnt-1);
}
return 0;
}

最大匹配问题（匈牙利）

【时间复杂度 n的三次方】

int n1, n2, m;
int e[M], ne[M], w[M], h[M], idx;
void add(int u, int v, int c){
e[idx] = v, ne[idx] = h[u], w[idx] = c, h[u] = idx++;
}

bool st[N];
int match[N];
bool find(int x){
for(int i = h[x]; ~i; i = ne[i]){
int j = e[i];
if(!st[j]){
st[j] = true;
if(match[j] == 0 || find(match[j])){
match[j] = x;
return true;
}
}
}
return false;
}

int main(){
memset(h, -1, sizeof h);
idx = 0;
scanf("%d%d%d", &n1, &n2, &m);
for(int i = 1; i <= m; i++){
int u, v;
scanf("%d%d", &u, &v);
add(u, v, 1);
}

int res = 0; // 匹配数
for(int i = 1; i <= n1; i++){
memset(st, false, sizeof st);
if(find(i)) res++;
}
printf("%d\n", res);
return 0;
}