HDU 3790 最短路径问题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define NIL 100000
struct Node
{
int d;  //记录最短路径长度
int m; //记录最小花费
int pre; //记录前驱
int flag; //标记所属集合
}node[1001];
/*
初始化操作，把源点初始化为0，其他正无穷
@param n 结点个数
@param s 源点
*/
int init_shortpath_source(int n, int s)
{
int i = 1;
for(i = 1; i <= n; ++i)
{
node[i].d = NIL;  //开始置最短路径为正无穷
node[i].m = NIL; //最小花费为正无穷
node[i].flag = 0; //所属 0 集合
node[i].pre = 0; //前驱为 0
}
node[s].d = 0;  //源点最短路径置为 0
node[s].m = 0;//最小花费置为 0
return 1;
}

/*松弛操作
*@param u 路径起始点
*@param v 路径结束点
*@param gp 路径图
*@param gm 花费图
*/
int relax(int u, int v, int** gp, int** gm)
{
if(node[v].d > node[u].d + gp[u][v]) //对路径进行松弛
{
node[v].d = node[u].d + gp[u][v];
node[v].m = node[u].m + gm[u][v];
node[v].pre = u;
}
else if(node[v].d == node[u].d + gp[u][v]) //对花费进行松弛
{
if(node[v].m >= node[u].m + gm[u][v])
{
node[v].d = node[u].d + gp[u][v];
node[v].m = node[u].m + gm[u][v];
node[v].pre = u;
}
}
return 1;
}
/*申请二维数组空间， 大小为n*n

@param n 二维数组空间的 大小
@result 返回一个 (n+1)*(n+1) 大小的 二维数组，下标从1开始到n
*/
int** apply_malloc(int n)
{
int **p;
int i;
p = (int**)malloc(sizeof(int)*(n+1));
for(i = 0; i<=n; ++i)
{
p[i] = (int *)malloc(sizeof(int)*(n+1));
}
return p;
}

/*初始化二维数组
@param gp 存储路径权值
@param gm 存储花费权值
*/
int init(int **gp, int **gm, int n)
{
int i = 1,j = 1;
for(i = 1;i <= n; ++i)
{
for(j = i; j <= n; ++j)
{
gp[i][j] = NIL;
gp[j][i] = NIL;
gm[i][j] = NIL;
gm[j][i] = NIL;
}
}
return 1;
}

/**
Dijkstra 算法
*/
int dijkstra(int ** gp, int ** gm, int s, int n)
{
int flag = n;
int index = 0;
int i,j,min;
init_shortpath_source(n,s);
while(flag--)
{
/*查找集合 0 中，路径上界最小的结点*/
for(i = 1; i <= n; ++i)
{
if(node[i].flag == 0)
{
min = node[i].d;
index = i;
break;
}
}
for(++i; i <= n; ++i)
{
if(node[i].flag == 0 && min > node[i].d)
{
min = node[i].d;
index = i;
}
}

/*将该点 加入 1 集合*/
node[index].flag = 1;

/*对每个以该点为起点的路径进行松弛操作*/
for(j = 1; j <= n; ++j)
{
if(node[j].flag == 0 && gp[index][j] != NIL)
{
relax(index,j,gp,gm);
}
}
}
return 1;
}

/*打印一个二维数组*/
int printf_array_2(int ** array, int n)
{
int i,j;
for(i = 1; i <= n; ++i)
{
for(j = 1; j <= n; ++j)
{
printf("%d\t", array[i][j]);
}
printf("\n");
}
return 1;
}

/*主方法*/
int main()
{
int n,m,a,b,p,q,i,s,e;
int **gp, **gm;
/*输入 结点个数， */
scanf("%d%d",&n,&m);
while(n||m)
{
/*申请两个二维数组空间， 一个存放路径权值， 一个存放花费权值*/
gp = apply_malloc(n);
gm = apply_malloc(n);
/*初始化二维表*/
init(gp,gm,n);
for(i = 1; i <= m; ++i)
{
/*输入路径和花费*/
scanf("%d%d%d%d",&a,&b,&p,&q);
/*解决有多条路径的问题，取权值最小的一条路径进行运算*/
if(gp[a][b] > p)
{
gp[a][b] = p;
gm[a][b] = q;
gp[b][a] = p;
gm[b][a] = q;
}
/*解决多条路径具有相同权值问题，取花费最小的一条路径进行运算*/
else if(gp[a][b] == p && gm[a][b] > q)
{
gm[a][b] = q;
gm[b][a] = q;
}
}
/*输入源点和终点*/
scanf("%d%d",&s,&e);
/*进行Dijkstra运算*/
dijkstra(gp,gm,s,n);
/*输出结果*/
printf("%d %d\n",node[e].d, node[e].m);
/*释放空间*/
free(gm);
free(gp);
/*等待下组数据*/
scanf("%d%d",&n,&m);
}
}