HDU 3790 最短路径问题 (SPFA)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3790

最短路径问题

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 12813    Accepted Submission(s): 3902

Problem Description

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

 

Input

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)

 

Output

输出 一行有两个数， 最短距离及其花费。

 

Sample Input

  
  

   
   3 2
1 2 5 6
2 3 4 5
1 3
0 0
  
  

 

Sample Output

  
  

   
   9 11
  
  

刚开始用的是链式向前星+SPFA写的，第一次基础这两种数据结构和算法，思考了一上午，但是用链式向前星储存无向图和重向边的时候出了点问题，所以改用了两个邻接矩阵来存储这个图；值得注意的是输入时考虑重向边；还有松弛改变最短路径的时候同时花费也要改变，路径相同时在判断花费的大小

还有，代码里面被注释掉的是链式向前星；

//http://acm.hdu.edu.cn/showproblem.php?pid=3790

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#define INF 0xfffffff

using namespace std;
/*struct Edge
{
    int to,dis,cost,next;
}edge[100005]; //存放边信息*/

//int headList[1010]; //存放edge节点信息,并不是图的节点信息,图的节点保存在edge[i].to

int n;//节点数
int m;//边数
//int top; //edge数下标

int path[1010][1010];
int cost[1010][1010];

int dpath[1010];
int dcost[1010];
int vis[1010]; //标记一个点进出队列的状态
//int c[1010];  //保存一个点进出队列的次数

void bfs_spfa(int start)
{
    memset(vis,0,sizeof(vis));
    for(int k = 1; k <= n; k++)
    {
        dpath[k]=INF;
        dcost[k]=INF;
    }

    queue <int> qu;
    qu.push(start);
    vis[start]=1;
    //  c[start]=1;
    dpath[start]=0;
    dcost[start]=0;

    while(!qu.empty())
    {
        int x = qu.front();

        qu.pop();
        vis[x]=0;

        int i;
        for(i=1; i<=n; i++)
        {
            if(path[x][i]<INF)
            {
                if(dpath[i] > dpath[x] + path[x][i])
                {
                    dpath[i] = dpath[x] + path[x][i];

                    dcost[i] = dcost[x] + cost[x][i];

                    if(!vis[i])
                    {
                        qu.push(i);
                        vis[i]=1;
                    }
                }
                else if( dpath[i] == dpath[x] + path[x][i] && dcost[i] > dcost[x] + cost[x][i])
                {
                    dcost[i] = dcost[x] + cost[x][i];
                }
            }
        }
    }

    /*int ok = 1; //记录
    while(!qu.empty())
    {
        int x = qu.front();
        qu.pop();

       // printf("x = %d\n",x);
        vis[x]=0;//队头元素出队，并消除标记；

     /*   for(int k = headList[x] ; k!=-1 ; k = edge[x].next) //遍历顶点x的链式向前星
        {

            int y = edge[k].to; //找到与x相连的下一个节点；
            printf("y == %d\n",y);

            if(dpath[y] > dpath[x] + edge[k].dis)
            {
                dpath[y] = dpath[x] + edge[k].dis;

                if(dcost[y] > dcost[x] + edge[k].cost)
                {
                    dcost[y] = dcost[x] + edge[k].cost;
                }

                if(!vis[y])
                {
                    qu.push(y);
                    vis[y]=1;

                    c[y]++;
                    if(c[y]>n)
                        return ok=0;
                }
            }
        }
    }
    return ok;*/


}

/*void show()
{
    int i,j;
    for(i=1;i<=n;i++)
    {
        for(j=headList[i]; j!=-1; j=edge[j].next)
        {
            printf("%d---->%d == %d  %d\n",i,edge[j].to,edge[j].dis,edge[j].cost);
            //printf("i==%d  j==%d\n",i,j);
           // printf("next=%d\n",edge[j].next);
        }

    }
}

int addList(int s,int t,int d,int p)  //建立链式向前星邻接表
{
    edge[top].to = t;
    edge[top].dis = d;
    edge[top].cost = p;
    edge[top].next = headList[s]; //当前节点指向以前的头结点

    headList[s] = top++;  //当前节点变为头结点
}*/

int main()
{
    int i,j;
    int s,t,d,p,a,b;

    while(scanf("%d %d",&n,&m)&& (n||m))
    {

        for(i=1; i<=n; i++)
        {
            //headList[i]=-1;
            for(j=1; j<=n; j++)
            {
                path[i][j]=INF;
                cost[i][j]=INF;
            }
            // c[i]=0;
        }
        for(i=1; i<=m; i++)
        {
            scanf("%d %d %d %d",&s,&t,&d,&p);

            if(d<path[s][t])
            {
                path[s][t]=d;
                path[t][s]=d;
                cost[s][t]=p;
                cost[t][s]=p;
            }
            // addList(s,t,d,p);
            // addList(t,s,d,p);

        }

        scanf("%d %d",&a,&b);

        //  show();

        bfs_spfa(a);

        printf("%d %d\n",dpath[b],dcost[b]);

    }
    return 0;
}