题目1008：最短路径问题

单源最短路径问题 Dijstra算法

贪心法  最优子结构

在求一点到另一点的最短距离时必须要确定该点到所有点的最短距离

优先队列 每次选出未遍历的权值最小的点

参考博客 http://www.cnblogs.com/dolphin0520/archive/2011/08/26/2155202.html

我的白痴代码：

#include <iostream>

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
using namespace std;
#define N 1024
#define M 1024
typedef struct node
{
    int n;
    int m;
}Graph;
int martrix[N][N];
int quanzhi[N][N];
void Dijstra(Graph g,int *dist,int *path,int *hff,int v)
{
    int i,j,k;
    int mins=INT_MAX;
    bool *visited = (bool*)malloc(sizeof(bool)*g.n);


    for(i=1;i<=g.n;i++)
    {
        if(i!=v&&martrix[v][i]>0)
        {
            path[i]=v;
            dist[i]=martrix[v][i];
            hff[i]=quanzhi[v][i];
        }
        else
        {
            path[i]=-1;
            dist[i]=mins;
            hff[i]=mins;
        }
        visited[i]=false;
        path[v]=v;
        dist[v]=0;
        hff[v]=0;
    }
    visited[v]=true;


    for(i=1;i<g.n;i++)
    {
        int u;
        int mis=INT_MAX;
        int hf=INT_MAX;
        for(j=1;j<=g.n;j++)     //寻找权值最小未被扩展的点
        {
            if(visited[j]==false&&dist[j]<mis)//找最小值
            {
                u=j;
                mis=dist[j];
                hf=hff[j];
            }
            if(visited[j]==false&&dist[j]==mis&&hff[j]<hf)//找最小值
            {
                u=j;
                hf=hff[j];
            }
        }
        visited[u]=true;
        for(k=1;k<=g.n;k++)
        {
            if(visited[k]==false&&martrix[u][k]>0&&martrix[u][k]+mis<dist[k])
            {
                dist[k]=martrix[u][k]+mis;
                path[k]=u;
                hff[k]=quanzhi[u][k]+hf;


            }
            if(visited[k]==false&&martrix[u][k]>0&&martrix[u][k]+mis==dist[k]&&hf+quanzhi[u][k]<hff[k])
            {
                path[k]=u;
                hff[k]=quanzhi[u][k]+hf;
            }
        }
    }
}
void showpath(Graph g,int *path,int vt,int v)
{
    /*int m=vt;
stack<int> s;
    while(m!=v)
    {
        s.push(m);
        m=path[m];
    }
    s.push(m);
    while(!s.empty())
    {
        cout<<s.top()<<" ";
        s.pop();
    }*/
    int mm=vt;
    int zhan[N];
    int op=0;
    while(mm!=v)
    {
        zhan[op++]=mm;
        mm=path[mm];
    }
    zhan[op++]=mm;
    op--;
    while(op>=0)
    {
        cout<<zhan[op--]<<" ";
    }
}
int main()
{
    int n,m;
    int a,b,d,p,s,t;
    Graph g;
    int *dist=(int*)malloc(sizeof(int)*M);
    int *path=(int*)malloc(sizeof(int)*M);
    int *hff=(int*)malloc(sizeof(int)*M);
    while(scanf("%d %d",&n,&m)!=EOF){
    if(n==0&&m==0) break;
    g.n=n;
    g.m=m;
    int i;
    for(i=0;i<m;i++)
    {
        scanf("%d %d %d %d",&a,&b,&d,&p);
        martrix[a][b]=d;
        quanzhi[a][b]=p;
    }
    scanf("%d %d",&s,&t);


    //cout<<"******************input finished*********\n";
    Dijstra(g,dist,path,hff,s);
    //showpath(g,path,t,s);
    cout<<dist[t]<<" "<<hff[t]<<endl;
    }
    return 0;
}