图的最短路径Dijkstra

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;

const int MAXV = ;
const int INF = ; 

struct Node
{
    int v,dis;
};

vector<Node> Adj[MAXV];

int n;//n为顶点数,图G使用邻接表实现,MAXV为最大顶点数(点数决定如何遍历边)
int m;// 边数(决定输入什么样的图)
int s;//起点

int d[MAXV];//起点到达各个点的最短路径长度
bool vis[MAXV] = {false};//标记数组,vis[i]==true表示已访问,初值均为false

int pre[MAXV]={}; //记录到某一个点的前驱 

void Dijkstra(int s)
{
    fill(d,d+MAXV,INF);
    d[s] = ;//起点s到达自身的距离为0

    //遍历所有的点
    for(int i=;i<n;i++)
    {
        //u为使得d[u]最小的点,MIN存放该最小的d[u]
        int u = -,MIN = INF;
        //每一趟找一个已连通的最短路径的点出来
        for(int j=;j<n;j++)
        {

            if(vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
         } 

         //找不到小于INF的d[u],说明剩下的顶点和起点s不连通
         if(u == -)
         {
             return;
         }
         //找到了
         else
         {
             vis[u] = true;//找到则标记成已访问,每一趟可以确定一个最短点

             //遍历u能到达的所有顶点v,并判断以u为中转到j的距离是否比原来的小,如果小则更新
            for(int j=;j < Adj[u].size();j++)
            {

                int v = Adj[u][j].v;

                //以当前最短路径的点为中转,看看是否比原来的距离小 ,如果小,则优化d[v]
                if(vis[v] == false && d[u] + Adj[u][j].dis < d[v])
                {
                    d[v] = d[u] + Adj[u][j].dis;

                    //记录前驱
                    pre[v] = u;
                 }
             }
         }
     }
 } 

 //输出从起点到v的最短路径
 void print(int s,int v)
 {
     if(v == s)
     {
         cout << s << endl;
         return;
     }

     print(s,pre[v]);
     cout<< v << endl;
 } 

int main()
{
    //顶点个数,边数,起点编号
    cin >> n >> m >> s;

    int u,v,w;
    Node tmp;
    for (int i=;i<m;i++)
    {
        cin >> u >> v >> w;
        tmp.v = v;
        tmp.dis = w;
        Adj[u].push_back(tmp);
    }

    Dijkstra(s);

    for(int i=;i<n;i++)
    {
        cout << d[i] << " ";
    }

    cout << endl;
    print(,);
    return ;

}

练习： PAT A1003 Emergency

#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAXV = ;
const int INF = ;

//n为点数,m为边数,st和ed分别为起点和终点
//G为邻接矩阵,weight为点权
//d[]记录最短距离,w[]记录最大点权之和
int n,m,st,ed,G[MAXV][MAXV],weight[MAXV];
int d[MAXV],w[MAXV];
//vis[i] == true 表示顶点i已访问
bool vis[MAXV] = {false}; 

vector<int> pre[MAXV];

void Dijkstra(int s)
{
    fill(d,d+MAXV,INF);
    d[s] = ;

    //每次找出一个最短的点,一共找n个 ,最短的点就是在最短路径中的点,设置为访问
    for(int i=;i<n;i++)
    {
        int u = -,MIN = INF;
        //找最短的点
        for(int j=;j<n;j++)
        {
            if(vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }

        if(u == - ) return;
        vis[u] = true;

        //看u能到哪些点 ,并以u为中转,更新其他距离
        //以u为中转,到v
        for(int v=;v<n;v++)
        {
            if(vis[v] == false && G[u][v] != INF)
            {
                if(d[u] + G[u][v] < d[v])
                {
                    d[v] = d[u] + G[u][v];
                    pre[v].clear();
                    //令v的前驱为u
                    pre[v].push_back(u);
                }
                else if(d[u]+G[u][v] == d[v])
                {
                    pre[v].push_back(u);
                 }
             }
        }
    }
}

//求最大值
int optvalue = -INF;
//最优路径及临时路径
vector<int> path,tempPath;
//路径数+1
int totalCount = ;

void DFS(int v)
{

    //    cout << endl;
    //到达叶子节点,即起点
    if(v == st)
    {
        totalCount++;
        tempPath.push_back(v);
        int value = ;
        for(int i=;i<tempPath.size();i++)
        {
//            value = value + G[ tempPath[i] ][ tempPath[i+1] ];
            value = value + weight[tempPath[i]];
         } 

         if(value > optvalue)
         {
             optvalue = value;
             path = tempPath;
         }

         //回溯
         tempPath.pop_back();
         return;
    }
    //将当期访问的点加入临时路径
    tempPath.push_back(v);
    //访问所有前驱
    for(int i=;i<pre[v].size();i++)
    {
        //递归遍历所有前驱
        DFS(pre[v][i]);
    }
    tempPath.pop_back();
 } 

int main()
{
    cin >> n >> m >> st >> ed;
    for(int i=;i<n;i++)
    {
        cin >> weight[i];
    }

    int u,v;
    fill(G[],G[] + MAXV * MAXV,INF);

    for(int i=;i<m;i++)
    {
        cin >> u >> v;
        cin >> G[u][v];
        G[v][u] = G[u][v];
     } 

    Dijkstra(st);

    DFS(ed);

    cout << totalCount << " " << optvalue << endl;
    return ;
}

PAT A1030 Travel Plan

#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXV = ;
const int INF = ;

//n为顶点数,m为边数,st和ed分别为起点和终点
//G为距离矩阵,cost为花费矩阵
//d[]用来记录最短距离,minCost记录最短路径上的最小花费
int n,m,st,ed,G[MAXV][MAXV],cost[MAXV][MAXV];
int d[MAXV],minCost = INF;
//是否被访问过
bool vis[MAXV] = {false};
//前驱
vector<int> pre[MAXV];
vector<int> tempPath,path;//临时路径与最优路径 

void Dijkstra(int s)
{
    fill(d,d+MAXV,INF);
    d[s] = ;
    //找出n个点
    for(int i=;i<n;i++)
    {
        int  u = -,MIN = INF;
        //找最小路径且没有被访问的点
        for(int j=;j<n;j++)
        {
                if(vis[j] == false && d[j] < MIN)
                {
                    u = j;
                    MIN = d[j];
                }
        }

         //找不到则说明剩下的顶点和起点不连通
        if(u == -)
        {
            return;
         } 

         vis[u] = true;

         //更新d[]
         for(int v = ;v < n;v++)
         {
             //如果能到达则做为中转 ,看能否到达v,并判断以此为中转到v的距离是否比之前的d要小,如果小则更新
             if(vis[v] == false && G[u][v] != INF)
            {
                  if(d[u] + G[u][v] < d[v])
                  {
                      d[v] = d[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(d[u] + G[u][v] == d[v])
                {
                    pre[v].push_back(u);
                }
            }
         }
     }
}

//v为当前节点
void DFS(int v)
{
    //到达叶节点
    if(v == st)
    {
        tempPath.push_back(v);
        int tempCost = ;//记录当前路径的花费之和
        for(int i = tempPath.size() - ;i > ;i--)
        {
            int id = tempPath[i],idNext = tempPath[i-];
            tempCost += cost[id][idNext];
        }

        //如果小,则备份
        if(tempCost < minCost)
        {
            minCost = tempCost;
            path = tempPath;
         } 

         //回溯
         tempPath.pop_back() ;
         return;
    }

    tempPath.push_back(v);
    for(int i=;i<pre[v].size();i++)
    {
        DFS(pre[v][i]);
    }

    tempPath.pop_back();
} 

int main()
{

    cin >> n >> m >> st >> ed;
    int u,v;
    fill(G[],G[]+MAXV*MAXV,INF) ;

    for(int i=;i<m;i++)
    {
        cin >> u >> v;
        cin >> G[u][v];
        cin >> cost[u][v];
        G[v][u] = G[u][v];
        cost[v][u] = cost[u][v];
    }

    Dijkstra(st);

    DFS(ed);//获取最优路径

    for(int i=path.size() - ;i>=;i--)
    {
        cout << path[i] << " ";
     }
     cout << d[ed] << " " << minCost << endl;
    return ;
}