《算法笔记》第4章 入门篇（2）---算法初步 10.4 最短路径

1.Dijkstra算法：

我的理解：

找出中介点，使原本从起点到目标点的距离能够通过中间点减少，从而超出两点之间的最短路径

引子：

最短路径的方法：

低级斯特拉算法策略：

低级斯特拉算法的伪代码：

上面例子的具体实现代码：（邻接矩阵法）

#include<iostream>
using namespace std;

const int maxn=10000;
const int INF=10000000000;

int G[maxn][maxn],d[maxn],n,m,start;

bool vis[maxn]={
   false};

void D(int s)
{
   
    fill(d,d+maxn,INF);
    d[s]=0;
    for(int i=0; i<n; i++)
    {
   
        int u=-1,MIN=INF;
        for(int j=0; j<n; j++)
        {
   
            if(vis[j]==false && d[j]<MIN)
            {
   
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1)
        {
   
            return ;
        }

        vis[u]=true;
        for(int v=0; v<n; v++)
        {
   
            if(vis[v]==false && G[u][v]!=INF && d[u]+G[u][v]<d[v])
                d[v]=d[u]+G[u][v];
        }
    }
}

int main()
{
   
    cin >> n >> m >> start;
    fill(G[0],G[0]+maxn*maxn,INF);         //初始化图G
    for(int i=0; i<m; i++)
    {
   
        int a,b,c;
        cin >> a >> b >> c;
        G[a][b]=c;
    }
    D(start);
    for(int i=0; i<n; i++)
        cout << d[i] << " ";
}

使用邻接矩阵和邻接表的区别：

邻接矩阵法：

//设置int类型 n， 邻接矩阵G, 起点到大各顶点的最小距离d 
//全局变量 MAXV为1000 INF为1000000000
/*
    void函数类型： 参数为 int类型 s
        1.使用fill函数：形参1：d  形参2:d+MAXV 形参3:INF
        2.双层for循环：知道距起点距离最短的顶点
            1.设置u为-1 MIN为INF
            2.for:如果j未被访问且距离小于最小值MIN
                1.则让u=j，且将MIn改为d[j]
    
    如果u任为-1，return则放回
    在vis中标记u已被访问过
    
    for循环：
        1.若果vis中顶点未被访问过，u可到达v 同时d[u]+G[u][v]小于d[v] 则优化d[v]
*/

const int MAXV=1000;
const int INF=10000000000;

int n,G[MAXV][MAXV],d[MAXV];
bool vis[MAXV]={
   false};

void D(int s)
{
   
    fill(d,d+MAXV,INF);
    d[s]=0;
    for(int i=0; i<n; i++)
    {
   
        int u=-1,MIN=1000000;
        for(int j=0; j<n; j++)
        {
   
            if(vis[j]==false && d[j]<MIN)
            {
   
                u=j;
                MIN=d[j];
            }
        }
    }
    if(u==-1)
        return ;
    vis[u]=true;
    for(int v=0; v<n; v++)
    {
   
        if(vis[v]==false && G[u][v]!=INF && d[u]+G[u][v]<d[v])
            d[v]=d[u]+G[u][v];
    }
}

邻接表法：

//struct结构 成员：顶点v dis为边权

//vector的结构数组 Adj

//顶点数 n  最短路径数组 d  vis

const int MAXV=1000;
const int INF=1000000000000;

struct node
{
   
    int v;
    int dis;
};

vector<node> Adj[MAXV];

int n,d[MAXV];

bool vis[MAXV]={
   false};

void D(int s)
{
   
    fill(d,d+MAXV,INF);
    d[s]=0;
    for(int i=0; i<n; i++)
    {
   
        int u=-1,MIN=INF;
        for(int j=0; j<n; j++)
        {
   
            if(vis[j]==false && d[j]<MIN)
            {
   
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1)
            return ;
        vis[u]=true; 
        for(int v=0; v<Adj[u].size(); v++)
        {
   
            int k=Adj[u][v].v;
            if(vis[k]==false && d[u]+Adj[u][v].dis<d[k])
                d[k]=d[u]+Adj[u][k].dis;
        }
    }
}

如何将无向图改为有向图

最短路径求法：

const int maxn=1000;
const int INF=10000000000;

int G[maxn][maxn],d[maxn],pre[maxn];
bool vis[maxn]={
   false};


void D(int s)
{
   
    fill(d,d+maxn,INF);
    d[s]=0;
    for(int i=0; i<n; i++)
    {
   
        int u=-1,MIN=INF;
        for(int j=0; j<n; j++)
        {
   
            if(vis[j]==false && MIN<d[j])
            {
   
                u=j;
                MIN=d[j];
            }
        }
        
        if(u==-1)
            return ;
        vis[u]=true;
        for(int v=0; v<n; v++)
        {
   
            if(vis[v]==false && G[u][v]!=INF && d[u]+G[u]