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

最新推荐文章于 2024-01-24 15:22:09 发布
最新推荐文章于 2024-01-24 15:22:09 发布
阅读量492 收藏 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
关注
专栏目录
acwing基础算法模板整理
02-27
这个"acwing基础算法模板整理"提供的资源很可能包含了这些领域的实例代码、解题思路和技巧，对于学习者来说，通过实践这些模板，不仅可以加深理论理解，还能提高编程能力，有助于在ACM/ICPC等编程竞赛或者实际开发中...
AcWing代码模板
m0_54615144的博客
02-20 247
常用代码模板1——基础算法常用代码模板2——数据结构常用代码模板3——搜索与图论常用代码模板4——数学知识
AcWing 算法基础课常用代码模板 1 —— 基础算法
Xi Xu 的博客
04-14 517
AcWing 算法基础课常用代码模板
AcWing 算法基础课常用代码模板 3 —— 搜索与图论
Xi Xu 的博客
04-14 281
AcWing 算法基础课常用代码模板
AcWing第二章算法模板总结——数据结构
weixin_43389219的博客
06-03 573
一、链表与邻接表 二、栈与队列 三、KMP 四、Trie树 五、并查集 六、堆 七、哈希 八、C++ STL简介
【模板】ACwing算法基础课模板小全
Zh0uKal1的博客
03-30 2943
边界问题因为边界问题只有这两种组合，不能随意搭配 归并排序算法模板 整数二分算法模板 浮点数二分算法模板 高精度加法 高精度减法 高精度乘低精度 高精度乘高精度 高精度除低精度 一维前缀和 前缀和可以用于快速计算一个序列的区间和，也有很多问题里不是直接用前缀和，但是借用了前缀和的思想。 应用 二维前缀和 应用 一维差分 差分是前缀和的逆运算，对于一个数组a，其差分数组b的每一项都是a [ i ]和前一项a [ i − 1 ]的差。注意：差分数组和原数组必须分开存放！！！！ 应用 二维差
AcWing的语法基础课代码整理-第一章
08-03
以下是针对您想要发布的“AcWing的语法基础课代码整理”资源的一个示例描述： --- **资源名称：** AcWing的语法基础课代码整理 **资源描述：** 探索编程语言的精髓，从基础到精通 —— 这是一份专为编程爱好者和...
Acwing 算法基础课超详细笔记
11-27
Acwing 算法基础课超详细笔记 本资源摘要信息中，我们将对 Acwing 算法基础课进行详细笔记，涵盖快速排序、快速选择算法、归并排序、逆序对的数量和二分搜索等多个知识点。 快速排序 快速排序是一种基于分治的...
AcWing 基础算法课.md
10-11
AcWing 基础算法课.md
保研机试，Acwing算法基础课笔记_Acwing-Basic-Notes.zip
最新发布
08-27
保研机试，Acwing算法基础课笔记_Acwing-Basic-Notes
AcWing算法题常用代码模板
Lyf_Ah的博客
11-18 6907
一、基础算法 1、常用代码模板 快速排序算法模板 —— 模板题 AcWing 785. 快速排序 算法步骤： ​ ①确定分界点 ​ ②调整区间 ​ ③递归处理左右两段 Tips： ​ ①如果输入数据量比较大的话，用scanf输入更快，不要使用cin。 ​ ②只要背诵一种万能模板即可避开所有边界问题。 ​ ③考试时一般不会用到快排，面试时喜欢考察。 ​ ④ #include<bits/stdc++.h>包含了目前c++所包含的所有头文件 。 ​ ⑤分治一般用不到，只要掌握快速排序和归并排序就行。
AcWing第三章算法模板总结——搜索与图论
weixin_43389219的博客
06-19 428
一、DFS与BFS 二、树与图的遍历：拓扑排序 三、最短路径 四、最小生成树 五、二分图：染色法、匈牙利算法。
Acwing 第二章模板及详解（数据结构）
weixin_64393298的博客
02-04 1149
一、链表与邻接表：树与图的存储 二、栈与队列：单调队列、单调栈 三、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第一章算法模板总结——基础算法
weixin_43389219的博客
05-07 594
一、排序算法二、二分三、高精度四、前缀和与差分五、位运算六、双指针算法七、离散化八、区间合并。
Acwing《算法基础课》第5章 动态规划
weixin_45769709的博客
10-07 599
Acwing《算法基础课》第5章 动态规划 文章目录Acwing《算法基础课》第5章 动态规划背包问题01背包问题完全背包问题多重背包问题分组背包问题线性DP数字三角形最长上升子序列最长公共子序列最短编辑距离区间DP计数类DP完全背包解法其它算法数位统计DP状态压缩DP蒙德里安的梦想最短Hamilton路径树形DP记忆化搜索 背包问题 01背包问题 nnn个物品，每个物品的体积是viv_ivi​，价值是wiw_iwi​，背包的容量是mmm 若每个物品最多只能装一个，且不能超过背包容量，则背包的最大价值是
ACwing算法模板 编程学习
syntax_loop446的博客
09-20 90
学习者可以通过阅读模板代码和解释，理解算法的原理和实现方法，并应用到自己的编程项目中。总之，ACwing算法模板是一个有价值的编程学习资源，它提供了丰富的算法模板和解释，帮助学习者掌握常见算法的实现方法。ACwing算法模板是一个广泛使用的资源，提供了各种常用算法的实现代码和详细解释。本文将介绍ACwing算法模板的使用，并附上相关的源代码。通过阅读和理解这些算法模板的代码，学习者可以掌握算法的基本思想和实现方法。同时，ACwing算法模板还提供了对每个算法的详细解释，帮助学习者了解算法的原理和应用场景。
AcWing.表达式求值模板题
2302_76649176的博客
01-24 443
给定一个表达式，其中运算符仅包含+,-,*,/（加 减 乘 整除），可能包含括号，请你求出表达式的最终值。
acwing算法基础课模版分析
m0_60565784的博客
10-03 3179
基础算法 快排模版 模版分析: 整数二分算法 模版分析:这个算法一般是用来求开方后的结果的!!用一个例题来理解! 给你一个数字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
spfa算法实例 acwing算法模板
sher_chang的博客
03-16 106
acwing3305 作物杂交。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值