杭电3790 最短路径问题（djstra过）

最开始看到这个题还是直接想的弗洛伊德算法去解.虽然是O（n^3）的时间复杂度0.0还是大胆的试了一发（其实最开始看着1000^3的复杂度就已经怂了）撞一发试了一下 果然TLE- -

蓝后默默的准备djstra的模板.......

这里先介绍一下dijstra.

dijstra是一种解最短路问题比较常用的算法（以下是个人理解，有错误的地方欢迎指导（毕竟新手））

先找到一条最短路径~（从起点到当前最短路径的点）.然后从这条最短路径开始寻找一个点 （连接完保证还是最短路径）进行连接.

也可以理解为 找到了这条最短路径之后 有能通过这条路径压缩权值的点  就要进行压缩.

最短路径问题

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

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
      
      
      
      
 
    
   
   
   
   

 

#include<stdio.h>
#include<string.h>
using namespace std;
#define inf 0x1f1f1f1f
int a[1005][1005];
int b[1005][1005];
int d[1005];
int p[1005];
int v[1005];
int n,m;
void init(int n)
{
	for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			{
				a[i][j]=inf;
				b[i][j]=inf;
			}
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n==0||m==0)break;
        init(n);
        int x,y,z,q;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d%d",&x,&y,&z,&q);
            if(a[x][y]==inf)
            {
                a[x][y]=a[y][x]=z;
                b[x][y]=b[y][x]=q;
            }
            else
            {
                if(a[x][y]>z||a[x][y]==z&&b[x][y]>q)
                {
                    a[x][y]=a[y][x]=z;
                    b[x][y]=b[y][x]=q;
                }
            }
        }
        int s,t;
        scanf("%d%d",&s,&t);
        memset(v,0,sizeof(v));
        memset(p,0,sizeof(p));
        for(int i=1;i<=n;i++)
        {
            d[i]=inf;
            p[i]=inf;
        }
        //要点1 初始化起点为0.
        /*zhongdian*/d[s]=0;
        /*zhongdian*/p[s]=0;
        //表示s是起点
        for(int i=1;i<=n;i++)//我们将要松弛所有点.
        {
            int w,m=inf,t;
            for(int j=1;j<=n;j++)
            {
                if(v[j]==0&&d[j]<m)//先找到目前最短路径~
                {
                    w=j;
                    m=d[j];
                    t=p[j];
                }
                if(v[j]==0&&d[j]==m&&p[j]<t)
                {
                    w=j;
                    m=d[j];
                    t=p[j];
                }
            }
            v[w]=1;
            for(int j=1;j<=n;j++)
            {
                if(d[w]+a[w][j]<d[j])//到j的路径能够通过当前最短路径进行权值压缩.就要进行压缩
                {
                    d[j]=d[w]+a[w][j];
                    p[j]=p[w]+b[w][j];
                }
                if(d[w]+a[w][j]==d[j])
                {
                    if(p[j]>p[w]+b[w][j])
                    {
                        p[j]=p[w]+b[w][j];
                    }
                }
            }
        }
       printf("\n");
        printf("%d %d\n",d[t],p[t]);
    }
}