NOJ-Dijkstra算法-西工大数据结构

最新推荐文章于 2024-09-18 10:21:37 发布
最新推荐文章于 2024-09-18 10:21:37 发布
阅读量4.7k 收藏 11
点赞数 3
分类专栏： 数据结构 文章标签： NOJ 数据结构 西工大
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30180107/article/details/80206892
版权

    前几天就讲了，考电路的前一天晚上写了一下，但是因为54的活动，今天才有空写下来。题目如下：


    看一下题，就是用邻接表存一个图，然后用dj算法来求出0节点到其他节点的最短路径，最后的输出格式要求从短到长，最后输出不可到达，所以最后要排一下序。

    首先创建3  3      1  2  1       1  3  4       2  3  2的邻接表如下图：


    dj算法其实是贪心，通过寻找当前节点到四周节点的最小步数节点，以其更新四周的路径长度，不断循环，直到无路可走。过程如下：


    最后的输出使用了一个快速排序，之后先输出大于0的，在输出-1即可。

    以下是我的实现：

#include <stdio.h>
#include <stdlib.h>

struct edgeNode
{
    int headVex;
    int weight;
    struct edgeNode *next;
};

struct vexNode
{
    int vex;
    struct edgeNode *head;
};

struct graphList
{
    struct vexNode vex[3000];
    int vexNum;
    int edgeNum;
};

struct step
{
    int flags[3000];
    int stepN[3000];
};

void run ();
void createNewGraphList (struct graphList *gList);
void clearVexNodes (struct graphList *gList);
void createNewEdgeNode (int n,struct graphList *gList);
void DJ(struct step *S,struct graphList *gList);
void clearStep(struct step *S,struct graphList *gList);
void initializeStep(struct step *S,struct graphList *gList);
int judgeStep(struct step *S,struct graphList *gList);
int findMinStepN(struct step *S,struct graphList *gList);
void updateStepN(struct step *S,struct graphList *gList,int min);
void print(struct step *S,struct graphList *gList);
void swap(int *a,int *b);
void quicksort(int array1[],int array2[],int maxlen,int begin,int end);

int main()
{
    run ();
    return 0;
}

void run ()
{
    struct graphList gList;
    struct step S;
    createNewGraphList (&gList);
    DJ (&S,&gList);
    print (&S,&gList);
}

void createNewGraphList (struct graphList *gList)
{
    scanf ("%d%d",&(gList->vexNum),&(gList->edgeNum));

    clearVexNodes (gList);

    int i,vex;
    for (i=0;i<gList->edgeNum;i++)
    {
        scanf ("%d",&vex);
        gList->vex[vex-1].vex=vex;
        createNewEdgeNode (vex-1,gList);
    }
}

void clearVexNodes (struct graphList *gList)
{
    int i;
    for (i=0;i<gList->vexNum;i++)
    {
        gList->vex[i].vex=0;
        gList->vex[i].head=NULL;
    }
}

void createNewEdgeNode (int n,struct graphList *gList)
{
    struct edgeNode *p,*q;
    int headVex;
    p=(struct edgeNode *)malloc(sizeof(struct edgeNode));
    scanf ("%d",&headVex);
    p->headVex=headVex-1;
    scanf ("%d",&(p->weight));
    p->next=NULL;
    if (gList->vex[n].head==NULL)
    {
        gList->vex[n].head=p;
    }
    else
    {
        q=gList->vex[n].head;
        while (q->next)
        {
            q=q->next;
        }
        q->next=p;
    }
}

void DJ(struct step *S,struct graphList *gList)
{
    int min;
    clearStep (S,gList);
    initializeStep (S,gList);
    while (judgeStep (S,gList))
    {
        min=findMinStepN (S,gList);
        updateStepN (S,gList,min);

    }
}

void clearStep(struct step *S,struct graphList *gList)
{
    int i;
    for (i=0;i<gList->vexNum;i++)
    {
        S->flags[i]=-1;
        S->stepN[i]=0;
    }
}

void initializeStep(struct step *S,struct graphList *gList)
{
    struct edgeNode *p;
    p=gList->vex[0].head;
    while (p)
    {
        S->flags[p->headVex]=1;
        S->stepN[p->headVex]=p->weight;
        p=p->next;
    }
}

int judgeStep(struct step *S,struct graphList *gList)
{
    int i;
    for (i=1;i<gList->vexNum;i++)
    {
        if (S->flags[i]==1)
        {
            return 1;
        }
    }
    return 0;
}

int findMinStepN(struct step *S,struct graphList *gList)
{
    int i,min=99999,n=-1;
    for (i=1;i<gList->vexNum;i++)
    {
        if (S->flags[i]==1)
        {
            if (S->stepN[i]<min)
            {
                min=S->stepN[i];
                n=i;
            }
        }
    }
    return n;
}

void updateStepN(struct step *S,struct graphList *gList,int min)
{
    struct edgeNode *p;
    int minStepN=S->stepN[min];
    p=gList->vex[min].head;
    S->flags[min]=0;
    while (p)
    {
        if (S->flags[p->headVex]==1)
        {
            if (p->weight+minStepN<S->stepN[p->headVex])
            {
                S->stepN[p->headVex]=p->weight+minStepN;
            }
        }
        else
        {
            if (S->flags[p->headVex]==-1)
            {
                S->flags[p->headVex]=1;
                S->stepN[p->headVex]=p->weight+minStepN;
            }
        }
        p=p->next;
    }
}

void print(struct step *S,struct graphList *gList)
{
    int i;
    int nList[3000]={0};
    int noList[3000]={0};
    for (i=1;i<gList->vexNum;i++)
    {
        if (S->flags[i]==-1)
        {
            nList[i]=-1;
        }
        else
        {
            nList[i]=S->stepN[gList->vex[i].vex-1];
        }
        noList[i]=i+1;
    }
    quicksort (nList,noList,gList->vexNum,1,gList->vexNum-1);
    for (i=1;i<gList->vexNum;i++)
    {
        if (nList[i]>0)
        {
            printf ("1 %d %d\n",noList[i],nList[i]);
        }
    }
    for (i=1;i<gList->vexNum;i++)
    {
        if (nList[i]==-1)
        {
            printf ("1 %d %d\n",noList[i],nList[i]);
        }
    }
}

void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

void quicksort(int array1[],int array2[],int maxlen,int begin,int end)
{
    int i,j;
    if(begin<end)
    {
        i=begin + 1;
        j=end;
        while(i<j)
        {
            if(array1[i]>array1[begin])
            {
                swap(&array1[i],&array1[j]);
                swap(&array2[i],&array2[j]);
                j--;
            }
            else
            {
                i++;
            }
        }
        if(array1[i]>=array1[begin])
        {
            i--;
        }
        swap(&array1[begin],&array1[i]);
        swap(&array2[begin],&array2[i]);
        quicksort(array1,array2,maxlen,begin,i);
        quicksort(array1,array2,maxlen,j,end);
    }
}

    以下是各函数的注释：

void run ()
{
    struct graphList gList;
    struct step S;
    createNewGraphList (&gList);//创建图
    DJ (&S,&gList);//dj算法
    print (&S,&gList);//输出结果
}
void createNewGraphList (struct graphList *gList)
{
    scanf ("%d%d",&(gList->vexNum),&(gList->edgeNum));//输入顶点数边数

    clearVexNodes (gList);//清空

    int i,vex;
    for (i=0;i<gList->edgeNum;i++)
    {
        scanf ("%d",&vex);
        gList->vex[vex-1].vex=vex;//循环输入顶点
        createNewEdgeNode (vex-1,gList);//创建边表节点
    }
}
void clearVexNodes (struct graphList *gList)
{
    int i;
    for (i=0;i<gList->vexNum;i++)//循环清空
    {
        gList->vex[i].vex=0;
        gList->vex[i].head=NULL;
    }
}
void createNewEdgeNode (int n,struct graphList *gList)
{
    struct edgeNode *p,*q;
    int headVex;
    p=(struct edgeNode *)malloc(sizeof(struct edgeNode));//创建节点
    scanf ("%d",&headVex);//输入指向的节点
    p->headVex=headVex-1;//录入指向节点的序号
    scanf ("%d",&(p->weight));//输入权值
    p->next=NULL;
    if (gList->vex[n].head==NULL)
    {
        gList->vex[n].head=p;//若表空，就是头结点
    }
    else//否则连接到最后
    {
        q=gList->vex[n].head;
        while (q->next)
        {
            q=q->next;
        }
        q->next=p;
    }
}
void DJ(struct step *S,struct graphList *gList)
{
    int min;
    clearStep (S,gList);//清空步数
    initializeStep (S,gList);//初始化步数
    while (judgeStep (S,gList))//当有路走就循环
    {
        min=findMinStepN (S,gList);//的到最小步数节点的序号
        updateStepN (S,gList,min);//以其更新步数
    }
}
void clearStep(struct step *S,struct graphList *gList)
{
    int i;
    for (i=0;i<gList->vexNum;i++)
    {
        S->flags[i]=-1;//-1表无路，0表以找到最短路径，1表未找到最短路径
        S->stepN[i]=0;//到此节点的步数为0
    }
}
void initializeStep(struct step *S,struct graphList *gList)
{
    struct edgeNode *p;
    p=gList->vex[0].head;
    while (p)//循环边表
    {
        S->flags[p->headVex]=1;//设置为未找到最短路径
        S->stepN[p->headVex]=p->weight;//设置到此节点步数
        p=p->next;
    }
}
int judgeStep(struct step *S,struct graphList *gList)
{
    int i;
    for (i=1;i<gList->vexNum;i++)//循环所有节点
    {
        if (S->flags[i]==1)//若有节点被设为未找到最短路径
        {
            return 1;//返回1，继续循环
        }
    }
    return 0;//返回0，结束循环
}
int findMinStepN(struct step *S,struct graphList *gList)
{
    int i,min=99999,n=-1;
    for (i=1;i<gList->vexNum;i++)//循环所有节点
    {
        if (S->flags[i]==1)//若被设为未找到最短路径
        {
            if (S->stepN[i]<min)//若比已知最小小，就替换
            {
                min=S->stepN[i];
                n=i;
            }
        }
    }
    return n;//返回得到的最小步数的节点的编号
}
void updateStepN(struct step *S,struct graphList *gList,int min)
{
    struct edgeNode *p;
    int minStepN=S->stepN[min];
    p=gList->vex[min].head;
    S->flags[min]=0;
    while (p)//循环边表
    {
        if (S->flags[p->headVex]==1)//若未找到最短路径
        {
            if (p->weight+minStepN<S->stepN[p->headVex])//若新的走法的步数较少
            {
                S->stepN[p->headVex]=p->weight+minStepN;//就更新到此节点的步数
            }
        }
        else
        {
            if (S->flags[p->headVex]==-1)//若此节点无路到达
            {
                S->flags[p->headVex]=1;
                S->stepN[p->headVex]=p->weight+minStepN;//新的走法有路到达，更新其步数
            }
        }
        p=p->next;
    }
}
void print(struct step *S,struct graphList *gList)
{
    int i;
    int nList[3000]={0};//步数
    int noList[3000]={0};//节点编号
    for (i=1;i<gList->vexNum;i++)
    {
        if (S->flags[i]==-1)//若无路到达，步数就是-1
        {
            nList[i]=-1;
        }
        else
        {
            nList[i]=S->stepN[gList->vex[i].vex-1];//否则就是步数
        }
        noList[i]=i+1;//节点编号赋值
    }
    quicksort (nList,noList,gList->vexNum,1,gList->vexNum-1);将步数从小到大排，编号随之改变
    for (i=1;i<gList->vexNum;i++)
    {
        if (nList[i]>0)//先输出有路到达的
        {
            printf ("1 %d %d\n",noList[i],nList[i]);
        }
    }
    for (i=1;i<gList->vexNum;i++)
    {
        if (nList[i]==-1)//再输出无路到达的
        {
            printf ("1 %d %d\n",noList[i],nList[i]);
        }
    }
}
void swap(int *a,int *b)//交换数值
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void quicksort(int array1[],int array2[],int maxlen,int begin,int end)//以array1排序，同时改变array2
{
    int i,j;
    if(begin<end)
    {
        i=begin + 1;
        j=end;
        while(i<j)
        {
            if(array1[i]>array1[begin])
            {
                swap(&array1[i],&array1[j]);
                swap(&array2[i],&array2[j]);
                j--;
            }
            else
            {
                i++;
            }
        }
        if(array1[i]>=array1[begin])
        {
            i--;
        }
        swap(&array1[begin],&array1[i]);
        swap(&array2[begin],&array2[i]);
        quicksort(array1,array2,maxlen,begin,i);
        quicksort(array1,array2,maxlen,j,end);
    }
}
    以上就是我的实现。













FREEstriker
关注
专栏目录
『西工大-数据结构-NOJ』 022-Dijkstra算法(耿7.42) 『西北工业大学』
LanXiu_的博客
07-10 2676
解题思路： 这道题要求使用邻接来作为储存结构，使用Dijkstra算法计算源点到其余各点的最短距离，无法到达时令距离为-1. 了解一下Dijkstra算法： 而根据题目预期的Output来看，输出数据是按照最短路径升序输出的，因此我们还要对数据进行一次排序，最短路径升序优先，其次是目标点序号，之后将最短路径为-1的放在最后输出。 具体操作见代码，代码中有部分注释。 题解代码： #include<stdio.h> #include<stdlib.h> #define MAX..
『西工大-数据结构-NOJ』 023-构造哈希表(耿8.12) 『西北工业大学』
LanXiu_的博客
07-11 2255
解题思路： 这道题要求对给定关键字序列使用哈希映射函数，并运用线性探测再散列法构造该关键字序列的哈希表，并求出查找成功的平均查找长度。 这道题还是比较简单，没有复杂的数据结构要求和算法，只要对哈希算法比较了解，知道线性探测再散列法，这道题就比较简单了。 具体操作见代码，代码中有部分注释。 题解代码： #include <stdio.h> #include <stdlib.h> #define DATANUM 8 #define HASHTABLENUM 11 typedef ..
数据结构 —— Dijkstra算法
qq_67693066的博客
07-09 821
数据结构 —— Dijkstra算法
Dijkstra算法详解（附代码）
最新发布
tecoes的博客
09-18 421
1、从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径。
数据结构__dijkstra算法
My Struggle
01-21 2067
注释很详尽了： #include&lt;iostream&gt; #include&lt;vector&gt; #define maxn 1000//最大节点数 #define inf 1000000000//模拟距离无限大 int G[maxn][maxn];//邻接阵，用于比较时提取G[u][v] using namespace std; struct node { int adjve...
数据结构--最短路径（Dijkstra算法）
Dream
03-02 794
// Dijkstra.cpp : Defines the entry point for the console application. /*-----CODE FOR FUN----------------- -------CREATED BY Dream_Whui-------- -------2015-2-15--------------------*/ //最短路径 Dijkstra
【数据结构与算法】迪杰斯特拉(Dijkstra)算法
qq_48848473的博客
10-20 3169
一，应用场景 二，基本介绍 三，基本步骤 四，思路图解 五，代码实现 六，运行结果
西北工业大学数据结构noj_1-6题
04-27
在“西北工业大学数据结构noj_1-6题”中，我们可以推测这是一系列与数据结构相关的编程练习题目，旨在帮助学生理解和应用各种数据结构。以下是基于这些题目可能涵盖的一些关键知识点的详细解释： 1. **线性数据结构...
『西工大-数据结构-NOJ』 024-二叉排序树的判别(耿8.6) 『西北工业大学』
LanXiu_的博客
07-11 2179
解题思路： 这道题要求用判别输入的二叉树是否为二叉排序树。 跟二叉树有关的题其实都不是很难，合理使用递归的思想去构造相关函数即可。 二叉排序树，即需要满足(T->left->data)<=(T->data)<=(T->right->data)即可。 (这道题好像题库有点问题，直接printf(“yes”)就能通过) //因为我们无法将指针变量的本身传入函数，因此直接将指针传入函数可能会造成无效的处理 //因为在C语言中，所有非数组形式的数据实参均以传值形式调用（..
西北工业大学 C++程序设计 noj习题答案
10-19
《西北工业大学 C++程序设计 noj习题答案》是一份针对C++程序设计课程的练习题解答集，包含了150道题目，旨在帮助学生深入理解C++编程语言，提升编程技能和解决问题的能力。这份资源按照题目的名字首字母排序，并...
数据结构--Dijkstra算法最清楚的讲解
热门推荐
heroacool的专栏
03-30 15万+
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止基本思想 通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该
西北工业大学数据结构及实验答案.7z
05-12
其中37道数据结构及实验代码亲测去全部可AC，其中部分题用的不是正统数据结构知识，但是能达到输出效果，如果有人想参考或者是题目快过期可直接拿来使用。
数据结构 第一章习题及答案
12-15
数据结构 第一章习题及答案，学习数据结构的童鞋可以下载下来看看
西工大noj答案
01-04
不太全 但很有用 第一季10题全（注：第五题问题已经解决,确认AC!)
西北工业大学，C/C++程序设计，NOJ答案最全最新版本
06-11
西北工业大学，C/C++程序设计，NOJ答案最全最新版本，欢迎大家下载！
西工大noj部分题答案
03-04
西工大noj作业答案，适用于各级学习c语言，c++等练习noj使用。
西工大NOJ数据结构实验——实验 2.4稀疏矩阵的乘法
a15735748145a的博客
04-09 2220
西工大NOJ数据结构实验——实验 2.4稀疏矩阵的乘法
西工大NOJ数据结构实验——2.1稀疏矩阵转置
a15735748145a的博客
04-01 4827
西工大NOJ数据结构实验——2.1稀疏矩阵转置
NOJ数据结构2
zhangxintongzxt的博客
06-28 955
示例：代码如下：顺序表：#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;#define MAX 200typedef struct{ int array[MAX]; int num;}seqlist;initlist(seqlist *l){ int num,i; scanf("%d",&amp;num); l-&gt;num=num; for(i=0...
西工大noj数据结构
06-09
西北工业大学NOJ（Northwestern Polytechnical Online Judge）是一个专门为大学生和编程爱好者设计的在线编程竞赛平台，它提供丰富的数据结构和算法题目，覆盖了多种编程语言。NOJ不仅有助于提升参赛者的编程技巧，还通过实践锻炼了解决实际问题的能力，比如数组、链表、树、图、哈希表、堆栈、队列、排序算法（如冒泡、快速、归并等）、搜索算法（如二分查找、深度优先搜索、广度优先搜索等）、动态规划等数据结构和基本算法。 在NOJ上学习数据结构，你可以： 1. **理解理论**：通过做题，深入理解数据结构的概念，如不同数据结构的存储结构和操作效率。 2. **动手实践**：通过编程实现数据结构的典型操作，比如插入、删除、查找等。 3. **解决实际问题**：将数据结构应用于实际的编程挑战，提高抽象思维和问题解决能力。 4. **参与竞赛**：参加定期的比赛，与其他选手切磋，提升竞赛心理素质和团队合作能力。 如果你对特定的数据结构或算法感兴趣，记得明确提问，我可以提供更详细的解释和示例。以下是几个相关问题： 1. 你在NOJ上遇到过哪些有趣的关于数据结构的题目？ 2. 数据结构的学习过程中，你觉得哪部分最难理解和应用？ 3. 对于想要准备NOJ比赛的学生，你有什么建议或资源推荐？
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值