第13周实验数据结构

最新推荐文章于 2022-11-16 18:05:18 发布
最新推荐文章于 2022-11-16 18:05:18 发布
阅读量322 收藏 2
点赞数 3
分类专栏： 笔记 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LPRICKY/article/details/124896754
版权

13.1 迪杰斯特拉最短路径（一点到其他所有点）

【输入形式】

输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。

以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j相等的时候，保证对应的整数为0。

【输出形式】

只有一行，共有n-1个整数，表示源点至其它每一个顶点的最短路径长度。如果不存在从源点至相应顶点的路径，输出-1。

请注意行尾输出换行。

【样例输入】

4 1
0 3 0 1
0 0 4 0
2 0 0 0
0 0 1 0

【样例输出】

6 4 7

【样例说明】

在本题中，需要按照题目描述中的算法完成迪杰斯特拉算法，并在计算最短路径的过程中将每个顶点是否可达记录下来，直到求出每个可达顶点的最短路径之后，算法才能够结束。 

迪杰斯特拉算法的特点是按照路径长度递增的顺序，依次添加下一条长度最短的边，从而不断构造出相应顶点的最短路径。 

另外需要注意的是，在本题中为了更方便的表示顶点间的不可达状态，可以使用一个十分大的值作为标记。

#include <iostream>
using namespace std;
#define MAX 32765
typedef struct graph
{
    int arc[55][55];
    int vexnum;
}Gragh;
int path[50]={0};
int dist[50]={0};
bool flag[50]={0};
void Indist(Gragh gn,int s)//初始化距离数组
{
    for(int i=0;i<gn.vexnum;i++)
    {
        if(i!=s)
        {
            dist[i]=gn.arc[s][i];
        }
    }
}
int findmin(Gragh gn,int s)
{
    int min=32765;
    int k;
    for(int i=0;i<gn.vexnum;i++)
    {
        if(!flag[i]&&gn.arc[s][i]<min)
        {
            min=gn.arc[s][i];
            k=i;
        }
    }
    flag[k]=1;
    return k;
}
void DIJ(Gragh gn,int s)//求最短路径
{
    flag[s]=1;
    Indist(gn,s);
    for(int i=1;i<=gn.vexnum-1;i++)
    {
        int m=findmin(gn,s);
        for(int j=0;j<gn.vexnum;j++)
        {
            if(gn.arc[s][j]>gn.arc[s][m]+gn.arc[m][j])
            {
                gn.arc[s][j]=gn.arc[s][m]+gn.arc[m][j];
                dist[j]=gn.arc[s][j];
                path[j]=m;
            }
        }
    }
    for(int x=0;x<gn.vexnum;x++)
    {
        if(dist[x]==MAX)
            dist[x]=-1;
        if(x!=s)
        {
            cout<<dist[x]<<" ";
        }
    }
}
int main()
{
    int n,s;
    cin>>n>>s;
    Gragh gn;
    gn.vexnum=n;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            cin>>gn.arc[i][j];
            if(gn.arc[i][j]==0&&i!=j)
                gn.arc[i][j]=MAX;
        }
    }
   /* cout<<n<<s<<endl;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
            cout<<gn.arc[i][j]<<" ";
        cout<<endl;
    }*/
    DIJ(gn,s);
    return 0;
}

13.2：弗洛伊德最短路径（任意两个点的最短路径）

【问题描述】

对于下面一张若干个城市，以及城市之间距离的地图，请采用弗洛伊德算法求出所有城市之间的最短路径。

【输入形式】

顶点个数n，以及n*n的邻接矩阵，其中不可达使用9999代替

【输出形式】

每两个顶点之间的最短路径和经过的顶点

注意：顶点自身到自身的dist值为0，path则为该顶点的编号

【样例输入】

4

9999 4 11 9999

6 9999 2 9999

1 9999 9999 1

9999 3 9999 9999

【样例输出】

from 0 to 0: dist = 0 path:0
from 0 to 1: dist = 4 path:0 1
from 0 to 2: dist = 6 path:0 1 2
from 0 to 3: dist = 7 path:0 1 2 3
from 1 to 0: dist = 3 path:1 2 0
from 1 to 1: dist = 0 path:1
from 1 to 2: dist = 2 path:1 2
from 1 to 3: dist = 3 path:1 2 3
from 2 to 0: dist = 1 path:2 0
from 2 to 1: dist = 4 path:2 3 1
from 2 to 2: dist = 0 path:2
from 2 to 3: dist = 1 path:2 3
from 3 to 0: dist = 6 path:3 1 2 0
from 3 to 1: dist = 3 path:3 1
from 3 to 2: dist = 5 path:3 1 2
from 3 to 3: dist = 0 path:3

#include<iostream>

using namespace std;
#define MAX 9999
typedef struct gragh
{
           int arc[55][55];
           int vexnum;
}Gragh;
int main()
{
           int path[55][55];
           int dist[55][55];
           int n;
           cin>>n;
           Gragh gn;
           gn.vexnum=n;
           for(int i=0;i<n;i++)//输入＋初始化
           {
                      for(int j=0;j<n;j++)
                      {
                                 cin>>gn.arc[i][j];
                                 if(i==j)
                                            gn.arc[i][j]=0;
                                 dist[i][j]=gn.arc[i][j];
                                 if(i==j||gn.arc[i][j]==MAX)//这里题目要求i==j时路径就是它本身
                                 {
                                            path[i][j]=i;
                                 }
                                 else
                                            path[i][j]=i;
                      }
           }
           for(int k=0;k<n;k++)
                      for(int i=0;i<n;i++)
                                 for(int j=0;j<n;j++)
                                 {
                                            if(dist[i][k]+dist[k][j]<gn.arc[i][j])
                                            {
                                                       gn.arc[i][j]=dist[i][k]+dist[k][j];
                                                       dist[i][j]=gn.arc[i][j];
                                                       path[i][j]=k;
                                            }
                                 }
           for(int i=0;i<n;i++)
           {
                      for(int j=0;j<n;j++)
                      {
                                 cout<<"from "<<i<<" to "<<j<<": dist = "<<gn.arc[i][j]<<" path:";
                                 int c=j;
                                 int Path[55];
                                 Path[0]=j;
                                 int x=0;
                                 if(i==j)
                                 {
                                            cout<<i<<endl;
                                 }
                                 else
                                 {
                                             while(path[i][c]!=i)
                                 {
                                            Path[++x]=path[i][c];
                                            c=path[i][c];
                                 }
                                 Path[++x]=i;
                                 for(int y=x;x>=0;x--)
                                 {
                                            cout<<Path[x]<<" ";
                                 }
                                 cout<<endl;
                                 }
                      }
           }
          /* for(int i=0;i<n;i++)
           {
                      for(int j=0;j<n;j++)
                                 cout<<path[i][j]<<" ";
                      cout<<endl;
           }*/
}

13.3关键路径：

【问题描述】若在带权的有向图中，以顶点表示事件，以有向边表示活动，边上的权值表示活动的开销（如该活动持续的时间），则此带权的有向图称为AOE网。如果用AOE网来表示一项工程，那么，仅仅考虑各个子工程之间的优先关系还不够，更多的是关心整个工程完成的最短时间是多少；哪些活动的延期将会影响整个工程的进度，而加速这些活动是否会提高整个工程的效率。因此，通常在AOE网中列出完成预定工程计划所需要进行的活动，每个活动计划完成的时间，要发生哪些事件以及这些事件与活动之间的关系，从而可以确定该项工程是否可行，估算工程完成的时间以及确定哪些活动是影响工程进度的关键。
【输入形式】第一行输入两个数字，分别表示顶点数和边数；从第二行开始，输入边的信息，格式为（i，j, weight）
【输出形式】关键路径的总时间（最大路径长度），代表关键活动的边，格式为（顶点1，顶点2），按大小顺序排列
【样例输入】
6 8
0 1 3
0 2 2
1 3 2
1 4 3
2 3 4
2 5 3
3 5 2
4 5 1
【样例输出】

8

0 2

2 3

3 5

【问题描述】若在带权的有向图中，以顶点表示事件，以有向边表示活动，边上的权值表示活动的开销（如该活动持续的时间），则此带权的有向图称为AOE网。如果用AOE网来表示一项工程，那么，仅仅考虑各个子工程之间的优先关系还不够，更多的是关心整个工程完成的最短时间是多少；哪些活动的延期将会影响整个工程的进度，而加速这些活动是否会提高整个工程的效率。因此，通常在AOE网中列出完成预定工程计划所需要进行的活动，每个活动计划完成的时间，要发生哪些事件以及这些事件与活动之间的关系，从而可以确定该项工程是否可行，估算工程完成的时间以及确定哪些活动是影响工程进度的关键。
【输入形式】第一行输入两个数字，分别表示顶点数和边数；从第二行开始，输入边的信息，格式为（i，j, weight）
【输出形式】关键路径的总时间（最大路径长度），代表关键活动的边，格式为（顶点1，顶点2），按大小顺序排列
【样例输入】
6 8
0 1 3
0 2 2
1 3 2
1 4 3
2 3 4
2 5 3
3 5 2
4 5 1
【样例输出】

8

0 2

2 3

3 5

#include<iostream>
#include<stdlib.h>
using namespace std;
#define MAX 100
int ve[MAX]={0};
int vl[MAX]={0};
int n,m;
typedef struct arcnode
{
    int data;
    int weight;
    struct arcnode *next=NULL;
}ArcNode;
typedef struct vertexnode
{
    int  data;//顶点
    ArcNode *first=NULL;
}VertexNode;
typedef struct stack
{
    VertexNode point[99];
    int top;
}Stack;
void push(Stack &a,VertexNode point)
{
    if(a.top>=99)
        exit(0);
    else
    {
        a.top++;
        a.point[a.top]=point;
    }
}
void pop(Stack &a,VertexNode &point)
{
    if(a.top==-1)
        exit(0);
    else
    {
        point=a.point[a.top];
        a.top--;
    }
}
//算每个顶点的入度
void Jindegree(int indegree[],VertexNode List[])
{
    for(int i=0;i<n;i++)
    {
        ArcNode *p=List[i].first;
        while(p!=NULL)
        {
            indegree[p->data]++;
            p=p->next;
        }
    }
}
int main()
{
    cin>>n>>m;//顶点数和边数
    VertexNode point[n];
    for(int i=0;i<n;i++)
        point[i].data=i;
    //建立邻接表
    for(int i=0;i<m;i++)
    {
        int x,y,weight;
        cin>>x>>y>>weight;
        //cout<<1<<endl;
        ArcNode *p=NULL;
        p=new ArcNode;
        p->data=y;
        p->weight=weight;
        p->next=NULL;

        if(point[x].first==NULL)
        {
            point[x].first=p;
        }
        else
        {
            ArcNode *pp=point[x].first;
            while(pp->next!=NULL)
                pp=pp->next;
            pp->next=p;
        }
    }
    /*for(int i=0;i<n;i++)
    {
        ArcNode *q=point[i].first;
        cout<<i<<" : ";
        while(q!=NULL)
        {
            cout<<q->data<<" "<<q->weight<<endl;
            q=q->next;
        }
    }*/
    int indegree[n]={0};
    Jindegree(indegree,point);//算各点入度
    Stack a,b;//a：存入度为0的顶点。b：存入逆序且修改后的拓扑排序
    a.top=-1;b.top=-1;
    for(int i=0;i<n;i++)
    {
        if(indegree[i]==0)
            push(a,point[i]);
    }
    while(a.top!=-1)
    {
        VertexNode j;
        pop(a,j);
        push(b,j);//逆序记录拓扑排序
        ArcNode *t=j.first;
        while(t!=NULL)
        {
            int k=t->data;
            if(--indegree[k]==0)
                push(a,point[k]);
            if(ve[j.data]+t->weight>ve[k])//计算每个顶点的最早发生时间
                ve[k]=ve[j.data]+t->weight;
            t=t->next;
        }
    }
    //计算每个顶点的最晚发生时间，计算每个活动的最早和最晚发生时间
    for(int i=0;i<n;i++)
    {
        vl[i]=ve[n-1];
    }
    while(b.top!=-1)
    {
        VertexNode h;
        pop(b,h);
        ArcNode *d=h.first;
        while(d!=NULL)
        {
            int g=d->data;
            if(vl[g]-d->weight<vl[h.data])
                vl[h.data]=vl[g]-d->weight;
            d=d->next;
        }
    }
    cout<<ve[n-1]<<endl;
    for(int i=0;i<n;i++)
    {
        ArcNode *f=point[i].first;
        int ei,li;
        while(f!=NULL)
        {
            ei=ve[i];
            li=vl[f->data]-f->weight;
            if(ei==li)
            cout<<i<<" "<<f->data<<endl;
            f=f->next;
        }
    }
}

注释：先求最早发生事件，再求最晚发生事件，最后根据前面两个求出每个活动的最早发生时间和最晚发生时间，然后活动这两个时间相同的就是关键路径。

LPRICKY
关注
专栏目录
数据结构作业——第八周-BF算法与KMP算法
qq_46476515的博客
10-26 768
数据结构第八周作业
山东大学数据结构实验要求指导书
02-03
- **实验时间**：安排在第5至13周进行。 - **实验要求**： - 采用良好的编程风格，并确保关键操作有适当的注释。 - 程序需能够正常运行，并显示正确的运行结果。 - 标记为“*”的内容为选做项。 #### 三、实验...
图及其应用
最新发布
Talking999的博客
11-16 3781
头歌数据结构实验课
数据结构（图）
梦码城博客中心
01-04 1183
1. 基于邻接矩阵存储的有向图，求出度为零的顶点个数 【问题描述】基于邻接矩阵存储的有向图，设计算法求出度为零的顶点个数。 【输入形式】第一行输入图的顶点个数verNum和边的个数edgeNum，用于构造图。 第二行顶点信息；接下来edgeNum行，每行描述一条边的信息，即起点、终点，以及边上的整型权值。 【输出形式】出度为零的顶点个数。 【样例输入】 6 9 A B C D E F A B 34 A C 46 A F 19 B E 12 C D 17 C F 25 D E 38 D F
数据结构第四次实验报告
weixin_51753366的博客
05-28 674
7-1 连通分量 (100 分) 无向图 G 有 n 个顶点和 m 条边。求 G 的连通分量的数目。 输入格式: 第1行，2个整数n和m，用空格分隔，分别表示顶点数和边数， 1≤n≤50000， 1≤m≤100000. 第2到m+1行，每行两个整数u和v，用空格分隔，表示顶点u到顶点v有一条边，u和v是顶点编号，1≤u,v≤n. 输出格式: 1行，1个整数，表示所求连通分量的数目。 输入样例: 在这里给出一组输入。例如： 6 5 1 3 1 2 2 3 4 5 5 6 输出样例:
迪杰斯特拉最短路径算法
yangke
02-20 381
题目 读入一个有向图的带权邻接矩阵（即数组表示），建立有向图并算法求用迪杰斯特拉求出源点至每一个其它顶点的最短路径长度。 输入 输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。 以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向...
问题 C: 算法7-15：迪杰斯特拉最短路径算法
qq_43660826的博客
05-19 719
题目描述 在带权有向图G中，给定一个源点v，求从v到G中的其余各顶点的最短路径问题，叫做单源点的最短路径问题。 在常用的单源点最短路径算法中，迪杰斯特拉算法是最为常用的一种，是一种按照路径长度递增的次序产生最短路径的算法。 可将迪杰斯特拉算法描述如下： 在本题中，读入一个有向图的带权邻接矩阵（即数组表示），建立有向图并按照以上描述中的算法求出源点至每一个其它顶点的最短路径长度。 输入...
数据结构实验报告-图-求最短回路5分(第13周完成)-实验内容与要求_数据结构课程设计实验报告
12-28
实验报告的主题是“数据结构”，具体涉及图的最短回路问题。实验要求学生通过字符文件构建带权网络存储结构，并使用迪杰斯特拉算法或弗洛依德算法寻找图中的最短回路。这个实验的目标是让学生掌握图的存储结构和最短...
数据结构实验报告-数组与广义表-基于十字链表的稀疏矩阵转置5%(第8周完成)-实验内容及要求.docx
11-03
《数据结构实验报告-基于十字链表的稀疏矩阵转置》 本实验报告主要探讨了如何使用十字链表来实现稀疏矩阵的转置操作，同时涉及到了文件的读写操作。实验的核心是理解稀疏矩阵的十字链表存储结构，并在此基础上设计...
数据结构实验
04-13
（第十三周星期三7、8节） 一 、实验目的 1．学会实现二叉树结点结构和对二叉树的基本操作。 2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。 二 、实验要求 1．...
C++最小生成树、单元点最短路径、两点之间最短路径
10-04
用C++求图的最小生成树、单元点最短路径、两点之间最短路径
最短路径问题（Dijkstra算法、Floyd算法）
serendipity的博客
07-15 1704
最短路径问题（Dijkstra算法、Floyd算法） 将近一天的时间（其实中间大部分看手机去了）终于把最短路径这个经典问题算搞懂了吧 一、Dijkstra算法 简单介绍: Dijkstra算法（即迪杰斯特拉算法）时间复杂度(O(n^2))主要就是解决从单一源点到其他各点的最短路径问题； 基本思路: 设置两个顶点的集合：S和T（S+T=V）（也就是说S和T集合的元素个数的和为：总结点个数），集合...
数据结构上机实验6.29
qq_53134669的博客
06-30 1840
写的是真的丑，就冲着能跑而已，大概意会一下，一切为了做题服务，这周末考完试会去把图的代码敲好，为实验考试做准备 问题 C: 算法7-10,7-11：关节点和重连通分量 题目描述 假若在删去顶点v以及和v相关联的各边之后，将图的一个连通分量分割成两个或两个以上的连接分量，则称顶点v为该图的一个关节点。一个没有关节点的连通图称为重连通图。在重连通图上，任意一对顶点之间至少存在两条路径，则在删去某个顶点以及依附于该顶点的各边时也不会破坏图的连通性。 利用深度优先搜索可以求出图的关节点，并由此可以判断图是否
【数据结构】树和图02——最短路径问题
jxyyyy的博客
04-11 1153
/最短路径的floyd和dijstra算法实现/ 1.使用了graph邻接矩阵数组作为存储结构。 2.输入为一个矩阵，点的权为最短路径。输出结果为最短路径的长度。 3.其中定义的maxcost意义为没有直接路径。 输入 输入的第一行包含2个正整数n和s，表示图中共有n个顶点，且源点为s。其中n不超过50，s小于n。 以后的n行中每行有n个用空格隔开的整数。对于第i行的第j个整数，如果大于0，则表示第i个顶点有指向第j个顶点的有向边，且权值为对应的整数值；如果这个整数为0，则表示没有i指向j的有向边。当i和j
《算法笔记》10.4小节——图算法专题-＞最短路径
susuate的博客
08-29 232
10.4.1 Dijkstra算法 解决单源最短路径问题 D算法可以用堆进行排序优化；D算法只能应对所有边权都是非负数的情况，如果边权出现负数，那么D算法很容易出错，最好使用SPFA算法 PAT A1003 Emergency 题目见书上P378 #define _CRT_SECURE_NO_WARNINGS 1 #include <cstdio> #include<cstring> #include<algorithm> using namespace std; con
[D-OJ练习] 求无向图中某顶点的度
☆迷茫Dog的秘密基地☆
10-26 1400
已知无向图的顶点为字符型，要求采用邻接矩阵表示，图中顶点序号按字符顺序排列，从键盘输入图中顶点的个数、边的条数、顶点的信息和边的组成等。求某顶点的度是多少？ 输入描述 第一行输入无向图的顶点数和边的条数，以空格隔开 第二行输入每个顶点的数据，中间没有空格 第三行输入每条边，每条边的格式为i j，中间有空格，所有边占一行 第四行输入某个顶点的序号 输出描述 输出要求顶点的度，占一行 输入样例 5 5 ABCDE 0 1 0 4 1 2 2 3 3 4 0 输出样例 2 ..
1768 Problem A 算法7-15：迪杰斯特拉最短路径算法
fantasydreams的专栏
02-27 1226
问题 A: 算法7-15：迪杰斯特拉最短路径算法 时间限制: 1 Sec 内存限制: 32 MB 献花: 37 解决: 23 [献花][花圈][TK题库] 题目描述 在带权有向图G中，给定一个源点v，求从v到G中的其余各顶点的最短路径问题，叫做单源点的最短路径问题。 在常用的单源点最短路径算法中，迪杰斯特拉算法是最为常用的一种，是一种按照路径长度递增的次序产生最短路径的算法。 ...
1399 最小生成树（Prim2）
qq_43633434的博客
08-15 151
1399 最小生成树 描述： 给出含n个顶点的图，打印最小生成树的所有边 输入：输入的第一行包含一个正整数n，表示图中共有n个顶点。其中n不超过50。 以后的n行中每行有n个用空格隔开的整数，对于第i行的第j个整数，如果不为0，则表示第i个顶点和第j个顶点有直接连接且代价为相应的值，0表示没有直接连接。当i和j相等的时候，保证对应的整数为0。 输入保证邻接矩阵为对称矩阵，即输入的图一定是无向图，且保证图中只有一个连通分量。 输出：每一行输出一条边 输入示例 4 0 2 4 0 2 0 3 5
【数据结构】实验六：图论
Lenhart001的博客
10-28 2308
【数据结构】实验六：图论
编程实现哈夫曼编码：数据压缩与二叉树构造
"周玉川_2017221302006_第二次上机实验1" 实验报告的作者周玉川是电子科技大学信息与软件工程学院的学生，他在2018年4月13日进行了一个关于哈夫曼编码算法的实验。实验的目的是让学生通过实际编程来理解和掌握...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值