Acwing-算法基础课——图论篇 代码模板大全

最新推荐文章于 2024-04-08 20:59:30 发布
最新推荐文章于 2024-04-08 20:59:30 发布
阅读量434 收藏 2
点赞数 2
分类专栏： Acwing代码模板 文章标签： 算法 图论 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64177548/article/details/126056268
版权

一. 树与图的深度优先遍历（846. 树的重心 - AcWing题库）

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;
const int M = 2 * N;

int idx,e[M],h[N],ne[M];
int n; 
bool str[M];
int ans=N;

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

int dfs(int u)
{
    str[u]=true;

    int sum=1,res=0;

    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!str[j])
        {
            int s=dfs(j);
            res=max(res,s);
            sum+=s;
        }
    }

    res=max(res,n-sum);

    ans=min(ans,res);

    return sum;
}

int main()
{
    cin>>n;

    memset(h,-1,sizeof h);


    for(int i=0;i<n-1;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }

    dfs(1);

    cout<<ans<<'\n';
    return 0;
}

二.树与图的广度优先遍历(847. 图中点的层次 - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 101000;

int n,m;
int e[N],ne[N],h[N],idx;
int d[N];

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

int bfs()
{
    queue<int> q;

    memset(d,-1,sizeof d);

    q.push(1);

    d[1]=0;

    while(q.size())
    {
        int t=q.front();

        q.pop();

        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];

            if(d[j]==-1)
            {
                d[j]=d[t]+1;
                q.push(j);
            }
        }
    }
    return d[n];
}

int main()
{
    cin>>n>>m;

    int a,b;

    memset(h,-1,sizeof h);

    for(int i=1;i<=m;i++)
    {
        cin>>a>>b;
        add(a,b);
    }

    cout<<bfs()<<'\n';

    return 0;
}

三.拓扑排序(848. 有向图的拓扑序列 - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 101000;

int n,m;
int e[N],ne[N],h[N],idx;
int d[N],q[N];

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

bool topsort()
{
    int hh=0,tt=-1;

    for(int i=1;i<=n;i++)
    {
        if(!d[i])
        {
            q[++tt]=i;
        }
    }

    while(hh<=tt)
    {
        int t=q[hh++];

        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            d[j]--;
            if(!d[j])
            {
                q[++tt]=j;
            }
        }
    }
    return tt==n-1;
}


int main()
{
    cin>>n>>m;

    memset(h,-1,sizeof h);

    for(int i=1;i<=m;i++)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        d[b]++;
    }

    if(topsort())
    {

        for(int i=0;i<n;i++)
        {
            cout<<q[i]<<" ";
        }

        cout<<'\n';

    }else{
        cout<<"-1\n";
    }
    return 0;
}

 

四.求最短路

1.Dijkstra 朴素算法  O（n^2) (849. Dijkstra求最短路 I - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 510;

int n,m; 
int g[N][N],d[N];
bool str[N];

int Dijlstra()
{
    memset(d,0x3f,sizeof d);

    d[1]=0;

    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!str[j]&&(t==-1||d[t]>d[j]))
            {
                t=j;
            }
        }

        for(int j=1;j<=n;j++)
        {
            d[j]=min(d[j],d[t]+g[t][j]);
        }

        str[t]=true;

    }

    if(d[n]==0x3f3f3f3f) return -1;
    else return d[n];
}

int main()
{
    cin>>n>>m;

    memset(g,0x3f,sizeof g);

    while(m--)
    {
        int x,y,z;
        cin>>x>>y>>z;

        g[x][y]=min(g[x][y],z);

    }

    cout<<Dijlstra()<<'\n';

    return 0;
}

2.堆优化版的Dijkstra算法 O(mlogn)

(850. Dijkstra求最短路 II - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int ,int > PII;

const int N = 201000;

int n,m; 
int e[N],h[N],ne[N],idx,w[N];
int d[N];
bool str[N];

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

int Dijkstra()
{
    priority_queue<PII, vector<PII>, greater<PII>> heap;

    memset(d,0x3f,sizeof d);

    d[1]=0;

    heap.push({0,1});

    while(heap.size())
    {
        auto t=heap.top();

        heap.pop();

        int ver=t.second,distance=t.first;

        if(str[ver]) continue;

        str[ver]=true;

        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[ver]+w[i])
            {
                d[j]=d[ver]+w[i];
                heap.push({d[j],j});
            }
        }
    }

    if(d[n]==0x3f3f3f3f) return -1;
    else return d[n];
}


int main()
{
    cin>>n>>m;

    memset(h,-1,sizeof h);

    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }

    cout<<Dijkstra()<<'\n';

    return 0;
}

3.bellman-ford算法 O(nm)(853. 有边数限制的最短路 - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;

int n,m,k;
int d[N],last[N];

struct Edge
{
    int a,b,w;

}edges[N];

void bellman_ford()
{
    memset(d,0x3f,sizeof d);

    d[1]=0;

    for(int i=0;i<k;i++)
    {
        memcpy(last,d,sizeof d);

        for(int j=0;j<m;j++)
        {
            auto e=edges[j];

            d[e.b]=min(d[e.b],last[e.a]+e.w);

        }
    }
}

int main()
{
    cin>>n>>m>>k;

    for(int i=0;i<m;i++)
    {
        int a,b,w;
        cin>>a>>b>>w;
        edges[i]={a,b,w};
    }

    bellman_ford();

    if(d[n]>0x3f3f3f3f/2) cout<<"impossible\n";
    else cout<<d[n]<<'\n';

    return 0;
}

4.SFPA算法O(m--nm)(851. spfa求最短路 - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;

int n,m; 
int e[N],h[N],ne[N],w[N],idx;
int d[N];
bool str[N];

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

void spfa()
{
    memset(d,0x3f,sizeof d);

    queue<int>q;
    d[1]=0;
    q.push(1);

    str[1]=true;

    while(q.size())
    {
        auto t=q.front();
        q.pop();

        str[t]=false;

        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])
            {
                d[j]=d[t]+w[i];


                if(!str[j])
                {
                    q.push(j);
                    str[j]=true;
                }
            }
        }
    }
}

int main()
{
    cin>>n>>m;

    memset(h,-1,sizeof h);

    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d", &a, &b, &c);
        add(a,b,c);
    }

    spfa();

    if(d[n]==0x3f3f3f3f) cout<<"impossible\n";
    else cout<<d[n]<<'\n';

    return 0;
}

5.852. spfa判断负环 - AcWing题库

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;

int n,m; 
int e[N],h[N],ne[N],w[N],idx;
int d[N],cnt[N];
bool str[N];

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

int spfa()
{


    queue<int>q;


    for(int i=1;i<=n;i++)
    {
        str[i]=true;
        q.push(i);
    }


    while(q.size())
    {
        auto t=q.front();
        q.pop();

        str[t]=false;

        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(d[j]>d[t]+w[i])
            {
                d[j]=d[t]+w[i];
                cnt[j]=cnt[t]+1;

                if(cnt[j]>=n) return false;

                if(!str[j])
                {
                    q.push(j);
                    str[j]=true;
                }
            }
        }
    }
    return true;
}

int main()
{
    cin>>n>>m;

    memset(h,-1,sizeof h);

    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d", &a, &b, &c);
        add(a,b,c);
    }

    if(spfa()) cout<<"No";
    else cout<<"Yes";

    return 0;
}

6.Floyd算法O(n^3)  (854. Floyd求最短路 - AcWing题库)

#include <bits/stdc++.h>

using namespace std;

const int N = 210, INF = 1e9;

int n, m, Q;
int d[N][N];

void floyd()
{
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

int main()
{
    scanf("%d%d%d", &n, &m, &Q);

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);
    }

    floyd();

    while (Q -- )
    {
        int a, b;
        scanf("%d%d", &a, &b);

        int t = d[a][b];
        if (t > INF / 2) puts("impossible");
        else printf("%d\n", t);
    }

    return 0;
}

五.求最小生成树

1.Prim算法  （858. Prim算法求最小生成树 - AcWing题库）

#include <bits/stdc++.h>

using namespace std;

const int N = 510,INF=0x3f3f3f3f;

int n,m; 
int d[N],g[N][N];
bool str[N];

int prim()
{
    memset(d,INF,sizeof d);

    int res=0;

    for(int i=0;i<n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!str[j]&&(t==-1||d[t]>d[j]))
            {
                t=j;
            }
        }

        if(i&&d[t]==INF) return INF;

        if(i) res+=d[t];

        str[t]=true;

        for(int j=1;j<=n;j++) d[j]=min(d[j],g[t][j]);
    }

    return res;
}

int main()
{
    cin>>n>>m;

    memset(g,INF,sizeof g);

    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(g[a][b],c);
    }

    int tt=prim();

    if(tt==INF) cout<<"impossible";
    else cout<<tt<<'\n';

    return 0;
}

2.Kruskalw算法（859. Kruskal算法求最小生成树 - AcWing题库）

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;

int n,m; 
int p[N];


struct Node
{
    int x,y,z;
}st[N]; 

bool cmp(Node a,Node b)
{
    return a.z<b.z;
}

int find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}

int Kruskal()
{
    int res=0,cnt=0;

    for(int i=0;i<m;i++)
    {
        int a=st[i].x,b=st[i].y,c=st[i].z;

        a=find(a),b=find(b);

        if(a!=b)
        {
            p[a]=b;
            res+=c;
            cnt++;
        }
    }

    if(cnt<n-1) return -1;
    return res;
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) p[i]=i;

    for(int i=0;i<m;i++)
    {
        cin>>st[i].x>>st[i].y>>st[i].z;
    }

    sort(st,st+m,cmp);

    int tt=Kruskal();

    if(tt==-1) cout<<"impossible\n";
    else cout<<tt<<'\n';

    return 0;
}

六.染色法判定二分图(AcWing 860. 染色法判定二分图 - AcWing)

#include <bits/stdc++.h>

using namespace std;

const int N = 201000;

int n,m;
int color[N];
int e[N],ne[N],h[N],idx;

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

bool dfs(int u,int c)
{
    color[u]=c;

    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!color[j])
        {
            if(!dfs(j,3-c)) return false;

        }
        else if(color[j]==c) return false;
    }
    return true;
}

int main()
{
    cin>>n>>m;

    memset(h,-1,sizeof h);

    while(m--)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }

    bool str=true;
    for(int i=1;i<=n;i++)
    {
        if(!color[i])
        {
            if(!dfs(i,1))
            {
                str=false;
                break;
            }
        }
    }

    if(str) cout<<"Yes\n";
    else cout<<"No\n";

    return 0;
}

七.匈牙利算法(861. 二分图的最大匹配 - AcWing题库)

#include <bits/stdc++.h>

const int N = 510,M=100100;

int n1,n2,m; 
int e[M],ne[M],h[M],idx;
bool str[N];
int match[N];

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

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

int main()
{
   scanf("%d %d %d", &n1, &n2, &m);
    
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b;
        scanf("%d %d", &a, &b);
        add(a,b);
    }
	
	
	int res=0;
	for(int i=1;i<=n1;i++)
	{
	    memset(str,false,sizeof str);
	    
	    if(find(i)) res++;
	}
	
	printf("%d",res);
    return 0;
}

(制作不易，若要收藏请留下小红心）

Hxxj
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AcWing算法题常用代码模板
Lyf_Ah的博客
11-18 6472
一、基础算法 1、常用代码模板 快速排序算法模板 —— 模板题 AcWing 785. 快速排序 算法步骤： ​ ①确定分界点 ​ ②调整区间 ​ ③递归处理左右两段 Tips： ​ ①如果输入数据量比较大的话，用scanf输入更快，不要使用cin。 ​ ②只要背诵一种万能模板即可避开所有边界问题。 ​ ③考试时一般不会用到快排，面试时喜欢考察。 ​ ④ #include<bits/stdc++.h>包含了目前c++所包含的所有头文件 。 ​ ⑤分治一般用不到，只要掌握快速排序和归并排序就行。
Acwing-基础算法-第三章-搜素与图论
04-01
看了一下，这次字写的有点小了，需要放大才能看清，后面的笔记会写大一点的，图论这部分的知识，跟着y总思路写的代码，思路很清晰，写的代码也很清晰，不过还是一定一定要多加练习，人的记忆在那，不练就会忘是一定...
AcWing 算法基础课常用代码模板 1 —— 基础算法
Xi Xu 的博客
04-14 375
AcWing 算法基础课常用代码模板
AcWing 算法基础课常用代码模板 3 —— 搜索与图论
Xi Xu 的博客
04-14 228
AcWing 算法基础课常用代码模板
acwing算法全总结——搜索与图论
最新发布
2302_80729149的博客
04-08 1752
dfsbfs树与图的深度优先遍历，树与图的广度优先遍历，拓扑排序，最短路问题，dijkstra最短路，bellman-ford最短路，spfa最短路，floyd最短路，最小生成树，prim最小生成树kruskal最小生成树，二分图。
AcWing第二章算法模板总结——数据结构
weixin_43389219的博客
06-03 440
一、链表与邻接表 二、栈与队列 三、KMP 四、Trie树 五、并查集 六、堆 七、哈希 八、C++ STL简介
Acwing 第二章模板及详解（数据结构）
weixin_64393298的博客
02-04 1094
一、链表与邻接表：树与图的存储 二、栈与队列：单调队列、单调栈 三、kmp 四、Trie 五、并查集 六、堆 七、Hash表 单链表 // head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 在链表头插入一个数a void insert(int a) { e[idx] = a...
acwing算法基础课讲义
04-30
Acwing 算法基础课讲义笔记 Acwing 算法基础课讲义是计算机科学和信息技术领域中的一个重要基础课程，本课程的主要内容是学习算法的基础知识，包括 C++ 语言的基本语法、printf 语句、判断结构、条件表达式等。 一...
AcWing算法基础课模板大全
07-14
基础算法 —— 代码模板链接 常用代码模板1——基础算法 排序 二分 高精度 前缀和与差分 双指针算法 位运算 离散化 区间合并 数据结构 —— 代码模板链接 常用代码模板2——数据结构 链表与邻接表：树与图的存储 ...
acwing基础算法模板整理
02-27
算法整理，包括但不限于基础算法，数据结构，搜索图论以及数学知识
Acwing 算法基础课超详细笔记
11-27
Acwing 算法基础课超详细笔记 本资源摘要信息中，我们将对 Acwing 算法基础课进行详细笔记，涵盖快速排序、快速选择算法、归并排序、逆序对的数量和二分搜索等多个知识点。 快速排序 快速排序是一种基于分治的...
AcWing.表达式求值模板题
2302_76649176的博客
01-24 406
给定一个表达式，其中运算符仅包含+,-,*,/（加 减 乘 整除），可能包含括号，请你求出表达式的最终值。
AcWing第一章算法模板总结——基础算法
weixin_43389219的博客
05-07 503
一、排序算法二、二分三、高精度四、前缀和与差分五、位运算六、双指针算法七、离散化八、区间合并。
Acwing《算法基础课》第5章 动态规划
weixin_45769709的博客
10-07 565
Acwing《算法基础课》第5章 动态规划 文章目录Acwing《算法基础课》第5章 动态规划背包问题01背包问题完全背包问题多重背包问题分组背包问题线性DP数字三角形最长上升子序列最长公共子序列最短编辑距离区间DP计数类DP完全背包解法其它算法数位统计DP状态压缩DP蒙德里安的梦想最短Hamilton路径树形DP记忆化搜索 背包问题 01背包问题 nnn个物品，每个物品的体积是viv_ivi​，价值是wiw_iwi​，背包的容量是mmm 若每个物品最多只能装一个，且不能超过背包容量，则背包的最大价值是
acwing算法基础课模版分析
m0_60565784的博客
10-03 2814
基础算法 快排模版 模版分析: 整数二分算法 模版分析:这个算法一般是用来求开方后的结果的!!用一个例题来理解! 给你一个数字x,请你求根号x的结果,保留六位小数! 模版分析:举个例子你就知道什么叫前缀和了,已知原数组是a(下标从1开始,0位置数值为0),前缀和数组是s,s[i]=a[0]+a[1]+…+a[i] ,这就是前缀和!!! 前缀和的好处是当你频繁计算区间和时,支持O(1)复杂度计算! 性质: 求[L,R]区间和=>s[R]-S[L-1]看图分析: 性质: 求以(x1, y1)为左上角，(x
acwing算法基础 模板
weixin_47741017的博客
07-17 650
快排： 经典快排 #include<bits/stdc++.h> using namespace std; const int N=1e6+10; int q[N]={}; //核心 void quick_sort(int q[],int l,int r){ if(l>=r) return ; int x=q[(l+r)/2],i=l-1,j=r+1; while(i<j){ do i++;while(q[i]<x);
Acwing 第三章模板及详解（搜索与图论）
weixin_64393298的博客
02-04 1070
一、DFS与BFS 二、树与图的遍历：拓扑排序 三、最短路 四、最小生成树 五、二分图：染色法、匈牙利算法 一、DFS与BFS 概述 DFS：深度优先搜索（Depth-First-Search） BFS：宽度优先搜索（Breadth-First-Search） DFS和BFS的对比 DFS使用栈（stack）来实现，BFS使用队列（queue）来实现 DFS所需要的空间是树的高度h，而BFS需要的空间是2h （DFS的空间复杂度较低） DFS不具有最短路的特性，BFS具有最短路的特.
AcWing算法学习笔记：搜索与图论1（DFS + BFS + 树与图的深度优先遍历 + 树与图的广度优先遍历 + 拓扑排序）
一只可爱的小猴子的博客
02-04 465
每次将入度为0的点放入队列，该点弹出时，将其相连的点入度-1，并将入度为0的点入队。若存在环，整个过程中所有入度为0的点的个数小于总点数。使用bfs得到拓扑序列，并且可以判断该图中是否有环。使用邻接表存储有向图，并记录每个点的入度。两个重要概念：回溯和剪枝。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值