单源最短路径算法之dijstra

最新推荐文章于 2023-03-14 20:52:35 发布

jieyu3890551

最新推荐文章于 2023-03-14 20:52:35 发布

阅读量436

点赞数

分类专栏：算法模板文章标签：单源最短路之dijstra算法模板

本文链接：https://blog.csdn.net/jieyu3890551/article/details/39136083

版权

算法模板专栏收录该内容

2 篇文章 0 订阅

订阅专栏

//dijstra算法（邻接矩阵）
//以poj 2387为例
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 1001;
int graph[N][N];
int dist[N];
//int pre[N];
bool visit[N];
int n, m;

//void dijstra( int v0, int v1 )
void dijstra( int v0 )
{
for ( int i = 1; i <= n; i++ )
{
    dist[i] = graph[v0][i];
    /*
    if ( dist[i] == -1 )
    {
      pre[i] = -1;
    }
    else
    {
      pre[i] = v0;
    }
    */
}
//pre[v0] = 0;
dist[v0] = 0;
visit[v0] = 1;
for ( int i = 1; i < n; i++ )
{
    int mindist = -1;
    int u = v0;
    for ( int j = 1; j <= n; j++ )
    {
      if ( visit[j] || dist[j] == -1 )
      {
        continue;
      }
      if ( mindist == -1 || dist[j] < mindist )
      {
        mindist = dist[j];
        u = j;
      }
    }
    if ( u == v0 )
    {
      return ;
    }
    visit[u] = 1;
    //if ( u == v1 )
    //{
    // return ;
    //}
    for ( int j = 1; j <= n; j++ )
    {
      if ( visit[j] || graph[u][j] == -1 )
      {
        continue;
      }
      if ( dist[j] == -1 || dist[j] > dist[u] + graph[u][j] )
      {
        dist[j] = dist[u] + graph[u][j];
        //pre[j] = u;
      }
    }
}
}

int main ()
{
while ( scanf("%d%d", &m, &n) != EOF )
{
    memset( visit, 0, sizeof(visit) );
    memset( graph, -1, sizeof(graph) );
    int a, b, c;
    while ( m-- )
    {
      scanf("%d%d%d", &a, &b, &c);
      if ( graph[a][b] == -1 || c < graph[a][b] )
      {
        graph[a][b] = graph[b][a] = c;
      }
    }
    //1到n的最短路
    dijstra(1);
    printf("%d\n", dist[n]);
}
return 0;

}

//优先队列优化的dijstra算法（邻接表）：

//还是poj 2387

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

const int N = 1001;
const int M = N * 3;
int head[N];
int dist[N];
bool visit[N];
int n, m, e;

inline void init()
{
e = 0;
memset( head, -1, sizeof(head) );
memset( dist, -1, sizeof(dist) );
memset( visit, 0, sizeof(visit) );
}

struct Edge
{
int v;
int d;
int next;
} edge[M];

void addEdge( int u, int v, int d )
{
edge[e].v = v;
edge[e].d = d;
edge[e].next = head[u];
head[u] = e++;
}

struct V
{
int id;
int val;
friend bool operator < ( const V & a, const V & b )
{
    return a.val > b.val;
}
};

//void dijstra( int v0, int v1 )
void dijstra( int v0 )
{
priority_queue<V> q;
dist[v0] = 0;
V t;
t.id = v0;
t.val = 0;
q.push(t);
for ( int i = 1; i <= n; i++ )
{
    while (1)
    {
      if ( q.empty() )
      {
        return ;
      }
      t = q.top();
      q.pop();
      if ( !visit[t.id] )
      {
        break;
      }
    }
    visit[t.id] = 1;
    //if ( t.id == v1 )
    // return ;
    int u = t.id;
    for ( int j = head[u]; j != -1; j = edge[j].next )
    {
      int v = edge[j].v;
      if ( visit[v] )
      {
        continue;
      }
      if ( dist[v] == -1 || dist[v] > dist[u] + edge[j].d )
      {
        dist[v] = dist[u] + edge[j].d;
        t.id = v;
        t.val = dist[v];
        q.push(t);
      }
    }
}
}

int main ()
{
while ( scanf("%d%d", &m, &n) != EOF )
{
    init();
    int a, b, c;
    while ( m-- )
    {
      scanf("%d%d%d", &a, &b, &c);
      addEdge( a, b, c );
      addEdge( b, a, c );
    }
    dijstra(n);
    printf("%d\n", dist[1]);
}
return 0;
}