图论算法

最新推荐文章于 2021-06-21 13:03:00 发布
最新推荐文章于 2021-06-21 13:03:00 发布
阅读量685 收藏
点赞数
分类专栏： 算法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/southernriver/article/details/52440059
版权

问题1、图的邻接矩阵表示法

#define MAXSIZE 100        //定义最大顶点个数
typedef char   VertexType;  //顶点的类型
struct Graph
{
 VertexType Vertex[MAXSIZE];     //顶点
 int AdjMatrix[MAXSIZE][MAXSIZE];//两个顶点之间的权重
 int vexnum;   //实际顶点数
 int arcnum;   //实际的弧数
};
struct Info
{
 VertexType start;
 VertexType end;
 int weight;
};
void AddVextex(Graph *g){
    for (int i = 0; i<g->vexnum; i++){
         g->Vertex[i] = 'A' + i;
    }
}
void CreateGraph(Graph *g){
     g->vexnum = 5;//确定顶点个数
     g->arcnum = 6; //确定弧数
     //弧长初始化为1000
     for (int i = 0; i<g->vexnum; i++){
           for (int j = 0; j<g->vexnum; j++){
                 g->AdjMatrix[i][j] = 1000;
           }
     }
     Info info[6] = { 'A', 'B', 3,
      'B', 'C', 6, 'C', 'D', 9, 'A', 'D', 12, 'D', 'E', 23, 'D', 'A', 13
      };
     for (int i = 0; i<6; i++){
          g->AdjMatrix[info[i].start - 'A'][info[i].end - 'A'] = info[i].weight;
      } 
}
void Display(Graph g){
    for (int i = 0; i<g.vexnum; i++){
            for (int j = 0; j<g.vexnum; j++){
                   cout << g.AdjMatrix[i][j] << "\t";
            }
            cout << endl;
    }
}

问题2、图的深度优先遍历DFS

void DFS(Graph g){
    int *flag = new int[g.vexnum];//标记顶点是否被访问
    memset(flag, 0, sizeof(int) * 5);
    flag[0] = 1;//访问第一个顶点
    cout << "0" << "->";
    stack<int>   s;
    s.push(0);    //栈保存第一个顶点，先进后出
    while (!s.empty()){
        int cur = s.top();//栈中当前的顶点
        int i = 0;
        for (; i < g.vexnum; i++){
         if (g.AdjMatrix[cur][i] < 1000 && flag[i] == 0){
          flag[i] = 1;
          cout << i << "->";
          s.push(i);
          break;
         }
        }
        if (i==g.vexnum)
               s.pop();
     }
     cout << endl;
}

问题3、宽度优先遍历BFS

void BFS(Graph g){
    int *flag=new int[g.vexnum];
    memset(flag, 0, sizeof(int) * 5);
    flag[0]=1;
    cout<<"0->";
    queue<int>  q;
    q.push(0);
    while(!q.empty()){
        int cur=q.front();
        int index=-1;
        for(int i=0;i<g.vexnum;i++){
            if(g.AdjMatrix[cur][i]<1000&&flag[i]==0){
                    flag[i]=1;
                    cout<<i<<"->";
                    q.push(i);
            }
        }
        if(index==-1){
            q.pop();
        }
    }
}

问题4、图的最小生成树：在一个联通网的所有生成树中所有边的代价之和的那颗生成树。带权的最小生成树要求权重最小。Prime算法（针对于无向图）

void PrimeTree(Graph g,int start){
    int *path=new int[g.vexnum];
    memset(path,0,sizeof(int)*g.vexnum);
    for(int i=0;i<g.vexnum;i++){
            path[i]=g.AdjMatrix[start][i];
    }
    bool *tree=new bool[g.vexnum];
    memset(tree,0,sizeof(bool)*g.vexnum);
    tree[start]=1;  //遍历起点
    int next=0;
    cout<<start<<"->";
    int mindis=0;
    for(int i=1;i<g.vexnum;i++){
        //遍历下一个结点
        int min=INT_MAX;
        for(int j=0;j<g.vexnum;j++){
            if(!tree[j]&&min>path[j]){
                min=path[j];
                next=j;
            }
        }
        //更新path
        tree[next]=1;
        cout<<next<<"->";
        mindis+=min;
        for(int k=0;k<g.vexnum;k++){
            if(!tree[k]&&path[k]>g.AdjMatrix[next][k]){
                path[k]=g.AdjMatrix[next][k];
            }
        }
    }
    cout<<endl;
    cout<<"最小生成树权值为"<<mindis<<endl;
}

//问题5、最短路径Dijkstra算法

//求起点start到任何一点的最短路径
void Dijkstra(Graph g,int start){
        int  path[MAXSIZE];  //保存到当前结点的上一个结点是谁
        int flag[MAXSIZE];            //标记顶点是否被访问过
        memset(flag,0,sizeof(flag));  //
        int dist[MAXSIZE];            //dist保存的是start到当前位置的最短路径值
        for（int end=0;end<g.vexnum;end++）{
            dist[end]=h.AdjMatrix[start][end];
            if(dist[end]<1000)
                path[end]=start;    //初始化保存到达当前结点的上一个结点
            else 
                path[end]=-1;
        }
        dist[start]=0;    //将start到start的路径设为0
        flag[start]=1;    //访问了第一个结点，将结点并入s
        int next=start;
        for(int i=1;i<g.vexnum;i++){
            int min=INT_MAX;
            for(int j=0;j<g.vexnum;j++){
                if(!flag[j]&&min>dist[j]){
                    next=j;
                    min=dist[j];
                }
            }
            flag[next]=1; //将next并入s
            //更新最短路径信息
            for(int k=0;k<g.vexnum;k++){
                if(!flag[k]&&min<1000&&g.AdjMatrix[next][k]<1000&&g.AdjMatrix[next][k]+min<dist[next]){
                    dist[next]=min;
                    path[k]=next;
                }
            }
        }
   //打印路径信息
    for (int i = 0; i < g.vexnum; i++){
        cout << start << "到" << i << "的距离为："<<dist[i]<<",最短路径为:";
        for (int j = path[i]; j != -1; j = path[j])
            cout << j << "->";
        cout << endl;
    }
}

最后附上完整的代码

#include<iostream>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;

#define MAXSIZE 100        //定义最大顶点个数
typedef char   VertexType;  //顶点的类型
struct Graph
{
 VertexType Vertex[MAXSIZE];     //顶点
 int AdjMatrix[MAXSIZE][MAXSIZE];//两个顶点之间的权重
 int vexnum;   //实际顶点数
 int arcnum;   //实际的弧数
};
struct Info
{
 VertexType start;
 VertexType end;
 int weight;
};
void AddVextex(Graph *g){
 for (int i = 0; i<g->vexnum; i++){
  g->Vertex[i] = 'A' + i;
 }
}
void CreateGraph(Graph *g){
     g->vexnum = 5;//确定顶点个数
     g->arcnum = 6; //确定弧数
     //弧长初始化为1000
     for (int i = 0; i<g->vexnum; i++){
       for (int j = 0; j<g->vexnum; j++){
         g->AdjMatrix[i][j] = 1000;
       }
     }
     Info info[8] = { 'A', 'B', 6, 'A', 'E',12,
      'B', 'C', 8, 'C', 'D', 6, 'A', 'D', 7, 'E', 'D', 5, 'E', 'C', 4, 'E', 'B',9
      };
     for (int i = 0; i<8; i++){
          g->AdjMatrix[info[i].start - 'A'][info[i].end - 'A'] = info[i].weight;
          g->AdjMatrix[info[i].end - 'A'][info[i].start - 'A'] = info[i].weight;
      } 
}
void Display(Graph g){
    for (int i = 0; i<g.vexnum; i++){
       for (int j = 0; j<g.vexnum; j++){
          cout << g.AdjMatrix[i][j] << "\t";
      }
      cout << endl;
     }
}
int FindNext(Graph g, int cur){
 for (int i = 1; i<g.vexnum; i++){
  if (g.AdjMatrix[cur][i]<1000)
   return i;
 }
 return -1;
}
void DFS(Graph g){
    int *flag = new int[g.vexnum];//标记顶点是否被访问
    memset(flag, 0, sizeof(int) * 5);
    flag[0] = 1;//访问第一个顶点
    cout << "0" << "->";
    stack<int>   s;
    s.push(0);    //栈保存第一个顶点，先进后出
    while (!s.empty()){
        int cur = s.top();//栈中当前的顶点
        int i = 0;
        for (; i < g.vexnum; i++){
         if (g.AdjMatrix[cur][i] < 1000 && flag[i] == 0){
          flag[i] = 1;
          cout << i << "->";
          s.push(i);
          break;
         }
        }
        if (i==g.vexnum)
               s.pop();
     }
     cout << endl;
}
void BFS(Graph g){
 int *flag = new int[g.vexnum];
 memset(flag, 0, sizeof(int) * 5);
 flag[0] = 1;
 cout << "0->";
 queue<int>  q;
 q.push(0);
 while (!q.empty()){
  int cur = q.front();
  int index = -1;
  for (int i = 0; i<g.vexnum; i++){
   if (g.AdjMatrix[cur][i]<1000 && flag[i] == 0){
    flag[i] = 1;
    cout << i << "->";
    q.push(i);
   }
  }
  if (index == -1){
   q.pop();
  }
 }
 cout << endl;
}
void PrimeTree(Graph g,int start){
    int *path = new int[g.vexnum];
    memset(path, 0, sizeof(int)*g.vexnum);
    for (int i = 0; i<g.vexnum; i++){
        path[i] = g.AdjMatrix[start][i];
    }
    bool *tree = new bool[g.vexnum];
    memset(tree, 0, sizeof(bool)*g.vexnum);
    tree[start] = 1;  //遍历起点
    int next = 0;
    cout << start << "->";
    int mindis = 0;
    for (int i = 1; i<g.vexnum; i++){
        //遍历下一个结点
        int min = INT_MAX;
        for (int j = 0; j<g.vexnum; j++){
            if (!tree[j] && min>path[j]){
                min = path[j];
                next = j;
            }
        }
        //更新path
        tree[next] = 1;
        cout << next << "->";
        mindis += min;
        for (int k = 0; k<g.vexnum; k++){
            if (!tree[k] && path[k]>g.AdjMatrix[next][k]){
                path[k] = g.AdjMatrix[next][k];
            }
        }
    }
    cout << endl;
    cout << "最小生成树权值为" << mindis << endl;
}
//求起点start到任何一点的最短路径
void Dijkstra(Graph g, int start){
    int  path[MAXSIZE];  //保存start到end的最短路径
    int flag[MAXSIZE];            //标记顶点是否被访问过
    memset(flag, 0, sizeof(flag));  //
    int dist[MAXSIZE];            //dist保存的是start到当前位置的最短路径值
    for(int end = 0; end < g.vexnum; end++){
        dist[end] = g.AdjMatrix[start][end];
        //记录经过的路径
        if (dist[end] < 1000)
            path[end] = start;
        else
            path[end] = -1;

    }
    dist[start] = 0;    //将start到start的路径设为0
    flag[start] = 1;    //访问了第一个结点，将结点并入s
    int next = start;
    for (int i = 1; i<g.vexnum; i++){
        int min = INT_MAX;
        for (int j = 0; j<g.vexnum; j++){
            if (!flag[j] && min>dist[j]){
                next = j;
                min = dist[j];
            }
        }
        flag[next] = 1; //将next并入s
        //更新最短路径信息
        for (int k = 0; k<g.vexnum; k++){
            if (!flag[k] && min<1000 && g.AdjMatrix[next][k]<1000 && (g.AdjMatrix[next][k] + min)<dist[k]){
                dist[k] = min+g.AdjMatrix[next][k];
                path[k] = next;   //保存的是到达当前的结点的上一个结点，不断更新
            }
        }
    }
    //打印路径信息
    for (int i = 0; i < g.vexnum; i++){
        cout << start << "到" << i << "的距离为："<<dist[i]<<",最短路径为:";
        for (int j = path[i]; j != -1; j = path[j])
            cout << j << "->";
        cout << endl;
    }
}
int main(){
 Graph g;
 CreateGraph(&g);
 Display(g);
 DFS(g);
 BFS(g);
 //PrimeTree(g,0);
 Dijkstra(g, 0);

 system("pause");
 return 0;
}
血江南
关注
专栏目录
POJ1789（最小生成树,kruskal算法）
圣帝天龙之博客传奇
08-15 2185
 由于和结点联系非常密切，所以容易想到使用kruskal算法。 题意：编写程序输出最高质量的火车推导计划。火车推倒计划质量的求解公式中的分子为1，分母为t0,td的距离总和。 t0,td的距离就是两个输入字符串的字母不同位置的个数。想要推导计划的质量最高就是使分母最小。即t0,td的距离总和最小。 实质上是以任意两个字符串为结点，以字符串字母不同位置的个数为两节点之间边的权值，求解最小生成树...
数据结构---图的详细介绍
热门推荐
William
02-27 5万+
前言： In order to change we must be sick and tired of being sick and tired. Name：WIllam Time：2017/2/251、名词解释： 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V，E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。在图中的数据元素，我们称之为顶
数模算法-图论算法
Dompink的博客
09-02 993
这类问题算法有很多， 包括： Dijkstra 、 Floyd 、 Prim 、 Bellman-Ford ，最大流，二分匹配等问题。   关于此类图论算法，可参考Introduction to Algorithms–算法导论，关于图算法的第22章-第26章。同时，本BLOG内经典算法研究系列，对Dijkstra算法有所简单描述，经典算法研究系列：二、Dijkstra 算法初探 http:/
Transformer再下一城！MSRA提出用于图结构数据的Graphormer！斩获OGB-LSC图预测赛道冠军...
阿木寺的博客
06-21 985
点击下方卡片，关注“CVer”公众号AI/CV重磅干货，第一时间送达本文转载自：微软研究院AI头条编者按：在刚刚结束的由 KDD Cup 2021 和 Open Graph Benchma...
图论经典算法(通俗易懂）：最短路径和最小生成树
林夕
05-10 2万+
一、最短路问题 求图的最短路问题，几乎是图论的必学内容，而且在算法分析与设计中也会涉及。很多书上内容， 实在没法看，我们的图论教材，更是编的非常糟糕，吐槽，为啥要用自己学校编的破教材，不过据说 下一届终于要换书了。 言归正传，开始说明最短路问题。 1.问题描述： 对一幅图G，我们对每一条边赋权w(e)，成为一个赋权图。H是G的一个子图，则W(H) = sigma(w(e)), 也...
图论算法软件Graph.exe
最新发布
02-03
Graph.exe是一个图论算法软件，用于执行各种图论算法。它可以用来解决图论问题，如最短路径、最小生成树、网络流等。用户可以输入图的结构和权重，然后选择所需的算法进行计算，最后得到相应的结果。该软件可以帮助...
图论算法理论实现_图论及其_图论算法_图论_图论知识_
09-30
图论是数学的一个分支，主要研究点（顶点）与线（边）组成的结构，它在计算机科学中有着广泛的应用，特别是在...《图论算法理论实现及其应用》这本书无疑是一份宝贵的资源，它将帮助读者深入理解这一领域的核心内容。
图论算法及其MATLAB实现（完整版）
04-30
《图论算法及其MATLAB实现》是一本深入探讨图论算法与其实现的书籍，尤其强调了使用MATLAB这一强大的科学计算工具进行编程实践。图论是计算机科学和数学的一个重要分支，它研究的是点（节点）和点之间的连接线（边）...
数学建模算法培训 图论算法及其MATLAB程序代码 共12页.pdf
03-06
"数学建模算法培训 图论算法及其MATLAB程序代码" 本资源主要介绍了图论算法在数学建模中的应用，具体来说是 Warshall-Floyd 算法和 Kruskal 避圈法。 Warshall-Floyd 算法用于求解赋权图中的最短路问题，而 Kruskal...
Python 图论算法实现工具——NetworkX1
08-03
【Python 图论算法实现工具——NetworkX1】这篇文章主要介绍了Python中用于图论算法实现的工具NetworkX。NetworkX是一个强大的Python软件包，专门用于处理复杂网络的结构、动力学和功能。它支持多种图类型，如无向图...
图论：最短路径搜索--Dijkstra算法(c代码实现)
weixin_30258901的博客
03-12 330
　　最近因为辞职，有不少闲功夫，重温下数据结构，顺便练练手。今天说说最短路径搜索算法中的Dijkstra原理和实现。 一：简介 　　这个算法用于解决图中单源最短路径问题。所谓单源节点是指给定源节点，求图中其它节点到此源节点的最短路径。如下图所示：给定源节点a，求节点b到a的最短距离。 (图来自于参考资料2) 那么如何寻找？还是以上图为例： 1）初始化：设定除源节点以外的其它所有节点到...
图论 北师大 张秀平 自学 视频 NOIP
mrcrack的博客
06-04 4391
姐妹篇：组合数学 北师大 张秀平 自学 视频 NOIP 请看https://blog.csdn.net/mrcrack/article/details/80562324 图论 北师大 张秀平 自学 视频 NOIP 共60讲。2018-8-16 13:53 体会，虽然在书中，图论篇幅不大，但视频同样有60讲，原因是图论中算法特别多，学习的过程中，若无程序编出，感觉图论等同于没学，虽然编出的程序...
图论（六）图的两种表示方法
saltriver的专栏
01-17 2万+
如果要用图来解决问题，首先我们必须采用某种数据结构来存储和表示“图”。相对于数组、链表等来说，图的存储结构就复杂的多了。 首先，图上的任何一个顶点都可以被看作是第一个顶点，任意顶点的邻接顶点之间也不存在次序关系。还记得在《图论（一）基本概念》中的“同构图”吧，图的形状可以千变万化的。因此也就无法以数据元素在内存中的物理位置来表示元素之间的关系，也就是说，图不可能用数组这样简单的顺序存储结构来表示。
完美迷宫生成算法
mosquito_zm的博客
01-02 2948
完美迷宫生成算法 Perfect maze Perfect maze又称standard maze，指没有回路，没有不可达区域的迷宫。用图论的语言来说，就是可以用spanning tree表示的迷宫，保证迷宫中任意两个格子间都有唯一的路径。本文旨在探讨如何随机生成棋盘状perfect maze。迷宫格子的邻居的定义采用von Neumann neighborhood，即水平
递归算法的应用（迷宫）
southernriver的博客
08-09 2905
题目：给定一个m*n的迷宫，找到任意两个点之间的路径！如图所示 这是一个10*10的矩阵，标记为0的代表不可以走，1代表可以走，找出起点（1，1）到终点（8，8）的路径。 解题思路：对于任何一个位置(i,j)，下一步共有4个方向可以选择，包括向上(i-1,j),向下(i+1,j),向左(i,j-1),向右(i,j+1);走过的点必须标记出来，避免下一次重新走，如果走到某个位置走不通了，必
图论算法MATLAB实现指南
"图论算法及其MATLAB实现，王海英黄强李传涛褚宝增编著，北京航空航天大学出版社出版。本书详细介绍了图论的重要算法，并提供了MATLAB实现，适用于数学、计算机科学、工程科学等相关专业的学生和研究人员。" 本书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值