关于图论算法

已于 2022-06-14 08:52:37 修改
阅读量110 收藏
点赞数
文章标签： 算法 图论 蓝桥杯
于 2022-06-11 16:04:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011616934/article/details/125235557
版权

1.邻接矩阵

#include <iostream>
using namespace std;

int arr[105][105], n, m;

int main(int argc, char const *argv[])
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        arr[a][b] = c;
    }
    for (int i = 1; i <= n; i++)
    {
        cout << i << " : ";
        for (int j = 1; j <= n; j++)
        {
            if (arr[i][j] != 0)
            {
                cout << "{" << i << "-->" << j << ", " << arr[i][j] << "} ";
            }
        }
        cout << endl;
    }  
    return 0;
}

2.弗洛伊德算法

用于求解最短路

特点：

①慢

②求解多源最短路（从任意点到任意点的最短路径）

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

③简单，好实现

代码实现：

#include <iostream>
#include <cstring>
using namespace std;

int arr[1005][1005], n, m, s;

int main(int argc, char const *argv[])
{
    memset(arr, 0x3F, sizeof(arr));
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        if (arr[a][b] > c) {
            arr[a][b] = c;
            arr[b][a] = c;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            for (int k = 1; k <= n; k++)
            {
                arr[j][k] = min(arr[j][k], arr[j][i] + arr[i][k]);
            }
        }
    }
    for (int i = 1; i <= n; i++)
    {
        arr[i][i] = 0;
        if (arr[s][i] == 0x3F3F3F3F) {
            cout << -1 << endl;
        } else {
            cout << arr[s][i] << endl;
        }
    }
    return 0;
}

3.邻接表

特点：

①只存储有用信息，省空间

②可以以某个点为起点的所有边

与邻接矩阵互补！

邻接表实现：

#include <iostream>
using namespace std;

int n, m, edg[105][105];

int main(int argc, char const *argv[])
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b;
        cin >> a >> b;
        edg[a][++edg[a][0]] = b;
    }
    for (int i = 1; i <= n; i++)
    {
        cout << i << " : ";
        for (int j = 1; j <= edg[i][0]; j++)
        {
            cout << edg[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

 节省内存的邻接表实现：

#include <iostream>
#include <vector>
using namespace std;

struct edge
{
    int s, e, v;
};

int main(int argc, char const *argv[])
{
    int n, m;
    cin >> n >> m;
    vector<vector<edge>> edg(n+5, vector<edge>());
    for (int i = 0; i < m; i++)
    {
        //起点，终点，边权
        int a, b, c;
        cin >> a >> b >> c;
        edg[a].push_back((edge){a, b, c});
    }
    for (int i = 1; i <= n; i++)
    {
        cout << i << " : ";
        for (int j = 0; j < edg[i].size(); j++)
        {
            cout << "{" << i << "-->" << edg[i][j].e << ", " << edg[i][j].v << "}";
        }
        cout << endl;
    }
   
    return 0;
}

4.dijkstra算法

求解单源，没有负值！

每次找到该点到其它的点的最短路径。

代码实现：

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

struct node
{
    int now, dis;
    bool operator< (const node &b) const {
        return this->dis > b.dis;
    }
};

struct edge
{
    int e, v;
};

int main(int argc, char const *argv[])
{
    int n, m, s, ans[100005];
    memset(ans, 0x3F, sizeof(ans));
    // cin >> n >> m >> s;
    scanf("%d%d%d", &n, &m, &s);
    vector<vector<edge>> edg(n+5, vector<edge>());
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        // cin >> a >> b >> c;
        scanf("%d%d%d", &a, &b, &c);
        edg[a].push_back((edge){b, c});
        edg[b].push_back((edge){a, c});
    }
    priority_queue<node> que;
    que.push((node){s, 0});
    ans[s] = 0;
    while (!que.empty())
    {
        node temp = que.top();
        que.pop();
        if (ans[temp.now] < temp.dis) {
            continue;
        }
        for (int i = 0; i < edg[temp.now].size(); i++)
        {
            int e = edg[temp.now][i].e, v = edg[temp.now][i].v;
            if (ans[e] > temp.dis + v) {
                ans[e] = temp.dis + v;
                que.push((node){e, ans[e]});
            }
        }  
    }
    for (int i = 1; i <= n; i++)
        {
            if (ans[i] == 0x3F3F3F3F) {
                // cout << -1 << endl;
                printf("-1\n");
            } else {
                // cout << ans[i] << endl;
                printf("%d\n", ans[i]);
            }
        }
    return 0;
}

 

5.链式前向星

用指针域模拟一个链表。

代码实现：

#include <iostream>
#include <cstring>
using namespace std;

struct edge
{
    int e, v, next;
};

edge edg[1005];
int n, m, head[1005];

int main(int argc, char const *argv[])
{
    memset(head, -1, sizeof(head));
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        edg[i].e = b;               //终点
        edg[i].v = c;               //权值
        edg[i].next = head[a];      //同起点的上一条边
        head[a] = i;                //a的最后一条边
    }
    for (int i = 1; i <= n; i++)
    {
        cout << i << " : ";
        for (int j = head[i]; j != -1; j = edg[j].next)
        {
            cout << "{" << i << "-->" << edg[j].e << ", " << edg[j].v << "} ";
        }
        cout << endl;
    }
   
    return 0;
}

基于dijkstra链式前向星代码实现：

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

struct edge
{
    int e, v, next;
};

struct node
{
    int now, dis;
    bool operator< (const node &b) const {
        return this->dis > b.dis;
    }
};

edge edg[200005];
int n, m, s, ans[100005], head[100005], cnt;

void add_edge(int a, int b, int c) {
    edg[cnt].e = b;
    edg[cnt].v = c;
    edg[cnt].next = head[a];
    head[a] = cnt;
    cnt++;
}

int main(int argc, char const *argv[])
{
    memset(head, -1, sizeof(head));
    memset(ans, 0x3F, sizeof(ans));
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add_edge(a, b, c);
        add_edge(b, a, c);
    }
    priority_queue<node> que;
    que.push((node){s, 0});
    ans[s] = 0;
    while (!que.empty())
    {
        node temp = que.top();
        que.pop();
        if (temp.dis > ans[temp.now]) {
            continue;
        }
        for (int i = head[temp.now]; i != -1; i = edg[i].next)
        {
            int e = edg[i].e, v = edg[i].v;
            if (ans[e] > ans[temp.now] + v) {
                ans[e] = ans[temp.now] + v;
                que.push((node){e, ans[e]});
            }
        }
    }
    for (int i = 1; i <= n; i++)
    {
        if (ans[i] == 0x3F3F3F3F) cout << -1 << endl;
        else cout << ans[i] << endl;
    }
   
    return 0;
}

 

 6.Bellman-ford

特点：单源最短路径，处理速度比较慢，但可以处理负权边。

代码实现：

#include <iostream>
#include <cstring>
using namespace std;

struct edge
{
    int s, e, v;
};

edge edg[200005];
int n, m, s, ans[100005], cnt;

void add_edge(int a, int b, int c) {
    edg[cnt].s = a;
    edg[cnt].e = b;
    edg[cnt].v = c;
    cnt++;
}

int main(int argc, char const *argv[])
{
    memset(ans, 0x3F, sizeof(ans));
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add_edge(a, b, c);
        add_edge(b, a, c);
    }
    ans[s] = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < cnt; j++)
        {
            if (ans[edg[j].e] > ans[edg[j].s] + edg[j].v) {
                ans[edg[j].e] = ans[edg[j].s] + edg[j].v;
            }
        }
    }
    for (int i = 1; i <= n; i++)
    {
        if (ans[i] == 0x3F3F3F3F) cout << -1 << endl;
        else cout << ans[i] << endl;
    }
   
    return 0;
}

 时间复杂度是O(n * m)

优化：

#include <iostream>
#include <cstring>
using namespace std;

struct edge
{
    int s, e, v;
};

edge edg[200005];
int n, m, s, ans[100005], cnt;

void add_edge(int a, int b, int c) {
    edg[cnt].s = a;
    edg[cnt].e = b;
    edg[cnt].v = c;
    cnt++;
}

int main(int argc, char const *argv[])
{
    memset(ans, 0x3F, sizeof(ans));
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add_edge(a, b, c);
        add_edge(b, a, c);
    }
    ans[s] = 0;
    for (int i = 0; i < n; i++)
    {
        int f = 0;
        for (int j = 0; j < cnt; j++)
        {
            if (ans[edg[j].e] > ans[edg[j].s] + edg[j].v) {
                ans[edg[j].e] = ans[edg[j].s] + edg[j].v;
                f = 1;
            }
        }
        if (f == 0) break;
    }
    for (int i = 1; i <= n; i++)
    {
        if (ans[i] == 0x3F3F3F3F) cout << -1 << endl;
        else cout << ans[i] << endl;
    }
   
    return 0;
}

只有上一轮更新过的点，才能影响下一轮答案

->基于队列的bellman-ford算法的优化：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

struct edge
{
    int e, v, next;
};

edge edg[200005];
int n, m, s, ans[100005], head[100005], cnt, mark[100005];

void add_edge(int a, int b, int c) {
    edg[cnt].e = b;
    edg[cnt].v = c;
    edg[cnt].next = head[a];
    head[a] = cnt++;
}

int main(int argc, char const *argv[])
{
    memset(ans, 0x3F, sizeof(ans));
    memset(head, -1, sizeof(head));
    cin >> n >> m >> s;
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add_edge(a, b, c);
        add_edge(b, a, c);
    }
    queue<int> que;
    ans[s] = 0;
    que.push(s);
    mark[s] = 1;
    while (!que.empty())
    {
        int temp = que.front();
        que.pop();
        mark[temp] = 0;
        for (int i = head[temp]; i != -1; i = edg[i].next)
        {
            int e = edg[i].e, v = edg[i].v;
            if (ans[e] > ans[temp] + v) {
                ans[e] = ans[temp] + v;
                if (mark[e] == 0) {
                    que.push(e);
                    mark[e] = 1;
                }
            }
        }    
    }
    for (int i = 1; i <= n; i++)
    {
        if (ans[i] == 0x3F3F3F3F) cout << -1 << endl;
        else cout << ans[i] << endl;
    }
   
    return 0;
}

 

7.code

#include <iostream>
#include <cstring>
using namespace std;

int n, num[105], arr[105][105];

int main(int argc, char const *argv[])
{
    memset(arr, 0x3F, sizeof(arr));
    // cin >> n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &num[i]);
        int a, b;
        scanf("%d%d", &a, &b);
        if (a) {
            arr[i][a] = 1;
            arr[a][i] = 1;
        }
        if (b) {
            arr[i][b] = 1;
            arr[b][i] = 1;
        }
        arr[i][i] = 0;
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            for (int k = 1; k <= n; k++)
            {
                arr[j][k] = min(arr[j][k], arr[j][i] + arr[i][k]);
            }
        }
    }
    int ans = 0x3F3F3F3F;
    for (int i = 1; i <= n; i++)
    {
        int t = 0;
        for (int j = 1; j <= n; j++)
        {
            t += arr[j][i] * num[j];
        }
        ans = min(ans, t);
    }
    printf("%d\n", ans);
    return 0;
}
#include <iostream>
#include <cstring>
using namespace std;

int n, m, q, now, num[205], arr[205][205];

int main(int argc, char const *argv[])
{
    memset(arr, 0x3F, sizeof(arr));
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &num[i]);
        arr[i][i] = 0;
    }
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        a++, b++;
        arr[a][b] = arr[b][a] = c;
    }
    scanf("%d", &q);
    for (int i = 0; i < q; i++)
    {
        int  x, y, t;
        scanf("%d%d%d", &x, &y, &t);
        x++, y++;
        while (num[now] <= t && now <= n)
        {
            for (int j = 1; j <= n; j++)
            {
                for (int k = 1; k <= n; k++)
                {
                    arr[j][k] = min(arr[j][k], arr[j][now] + arr[now][k]);
                }
            }
            now++;
        }
        if (num[x] > t || num[y] > t || arr[x][y] == 0x3F3F3F3F) printf("-1\n");
        else printf("%d\n", arr[x][y]);
    }
   
    return 0;
}

Tra220123
关注
图论算法
Ankang的博客
05-25 1424
推荐书籍《数据结构与算法分析--C++语言描述》p.304-p.316 源代码 1.图论基本知识点 图：图有顶点和边构成。图用符号G表示，顶点用符号V表示，边（或称弧）用符号E表示。G(V,E)表示由顶点集合V和边集合E构成的图。其中边由两个顶点构成，若两个顶点构成的边无序，如v-w和w-v相同，则称无向图，否则称有向图。若（v,w）构成一条边，则称w邻接到v；若是无向图，则w邻接到v且v邻...
HDU6029-Graph Theory-图论简单推理
survivorone的博客
05-07 1033
//传送门：http://acm.hdu.edu.cn/showproblem.php?pid=6029 #include #include #include #include #include #include using namespace std; #define LL long long #define N 100005 #define M 2005 #define INF 0
图论
weixin_30924087的博客
07-03 447
--------------------siwuxie095 图论 这里介绍图论（Graph Theory），图论是计算机科学中非常重要 的一部分内容，甚至可以单独划分成为一个领域 很多人第一次接触到图论这个词，就觉得图论是研究和图画相关的 内容 ...
数据结构与算法-16高级数据结构_图论（图论基础）
最新发布
qq_40469712的博客
08-12 630
图（Graph）是一个用于描述一组对象之间关系的数学结构。这些对象被称为顶点（Vertex），也称为节点（Node）或点（Point），而对象之间的关系则通过边（Edge）来表示，边也称为链接（Link）或线（Line）。图通常以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。
图论算法软件Graph.exe
02-03
Graph.exe是一个图论算法软件，用于执行各种图论算法。它可以用来解决图论问题，如最短路径、最小生成树、网络流等。用户可以输入图的结构和权重，然后选择所需的算法进行计算，最后得到相应的结果。该软件可以帮助...
图论算法理论实现_图论及其_图论算法_图论_图论知识_
09-30
图论是数学的一个分支，主要研究点（顶点）与线（边）组成的结构，它在计算机科学中有着广泛的应用，特别是在...《图论算法理论实现及其应用》这本书无疑是一份宝贵的资源，它将帮助读者深入理解这一领域的核心内容。
图论算法及其MATLAB实现（完整版）
04-30
《图论算法及其MATLAB实现》是一本深入探讨图论算法与其实现的书籍，尤其强调了使用MATLAB这一强大的科学计算工具进行编程实践。图论是计算机科学和数学的一个重要分支，它研究的是点（节点）和点之间的连接线（边）...
图论算法软件图论算法软件
06-02
图论算法软件是一种用于解决与图相关问题的计算工具，它涵盖了广泛的数学和计算机科学理论。在图论中，一个图是由节点（或顶点）和连接这些节点的边构成的抽象结构。这个领域的算法在计算机科学中有着广泛应用，如...
MATLAB算法图论算法软件
04-15
“MATLAB算法图论算法软件”很可能是指专为图论算法设计的一套软件或插件，它允许用户利用MATLAB的平台执行更复杂的图论算法。这类软件或插件可能集成了常用的图论算法，比如图的遍历（如深度优先搜索和广度优先搜索...
图论---算法篇
weixin_33704234的博客
06-28 486
小书匠Graph图论声明:图论中的算法基本都是提出后,经过检验的.我就不讨论算法很基础的原理,只是从看懂一个算法的角度去学习.本着不花时间去重复别人优秀工作的原则,本文中很多部分引用了别人的工作,甚至是照搬过来,因为我觉得算法这东西已经类似真理,证明不需要你,你可以看得懂,别人也可以,只是表达方式不同,别人有优秀的表达方式,我为什么不用呢! 如认为侵权,可联系删除! 目录: 二.算法类 ...
图论算法详解
qq_44886213的博客
03-24 3837
一、图的表示 1.1 邻接矩阵 一个一维数组存储顶点。一个二维数组存储边。 稠密图首选邻接矩阵。如果顶点太多了，比如说有100000个顶点，要开辟mpt[100000][100000]这么大的数组，空间超出限制，则考虑用邻接表。同时，如果图比较稀疏，也可考虑用邻接表。 下面演示邻接矩阵的存储过程。 #include <bits/stdc++.h> using namespace std; int mpt[105][105]; int n,m; //n个点,m条边 # define IN
图论算法MATLAB实现指南
"图论算法及其MATLAB实现，王海英黄强李传涛褚宝增编著，北京航空航天大学出版社出版。本书详细介绍了图论的重要算法，并提供了MATLAB实现，适用于数学、计算机科学、工程科学等相关专业的学生和研究人员。" 本书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值