九度：1447<最短路径><Floyd><Dijstra>

题目简单，为了讲解2种算法而设计。

http://ac.jobdu.com/problem.php?pid=1447

Floyd使用邻接矩阵，Dijstra使用邻接表。当然，Dijstra也可使用邻接矩阵。

1. Floyd（邻接矩阵）

// 九度：1447
// 
// 无向图的最短路径
// Floyd算法：
// 1.时间复杂度O(N^3)，在节点不超过200时可以使用，超过后，由于算法效率不高，会超时。
// 2.如果两点之间存在多边，存小的那个边。
// 3.适合全源最短路径问题。求某两点之间效率，稍微低了。但只要数据量不大，还是可以的，本题就是例子。

#include <stdio.h>
#include <string.h>


#define SIZE 100+1 // 100个节点

int edge[SIZE][SIZE];

void Init(int n){
	for(int i=1; i<=n; i++)
	{
		for(int j=1; j<=n; j++)
		{
			edge[i][j] = -1;//-1代表无穷
		}
		edge[i][i]=0;//自己到自己为0
	}
}

int main()
{
#ifdef ONLINE_JUDGE
#else
	freopen("E:\\in.txt", "r", stdin);
#endif

	int n, m;
	while(scanf("%d%d", &n, &m) != EOF)
	{
		if(n == 0 && m ==0)
		{
			break;
		}
		Init(n);
		//printf("%d\n", edge[0][0]); // 测试初始化
		int x, y, cost;
		while(m-->0)
		{
			scanf("%d%d%d", &x, &y, &cost);
			edge[x][y] = edge[y][x] = cost;//无向图
		}

		for(int k=1; k<=n; k++)//点范围[1,n]
		{
			for(int i=1; i<=n; i++)
			{
				for(int j=1; j<=n; j++)
				{
					if(edge[i][k] == -1 || edge[k][j] == -1)
					{
						continue;
					}
					if(edge[i][j] == -1 || edge[i][k]+edge[k][j] < edge[i][j])
					{
						edge[i][j] = edge[i][k]+edge[k][j];
					}
				}
			}
		} //Floyd

		printf("%d\n", edge[1][n]);
	}
	return 0;
}

2. Dijstra（邻接表）

// Dijstra适合求单源最短路径，效率较高
// 
#include <stdio.h>
#include <vector>
 
using namespace std;
 
#define SIZE 100+10
 
struct Edge{
    int next;
    int cost;
};
 
vector<Edge> edge[SIZE];
bool mark[SIZE];    // 是否属于结合K
int Dis[SIZE];      // 1到点i的距离，-1为无穷。
 
void Init(int n)
{
    for(int i=1; i<=n; i++)
    {
        edge[i].clear();//清空节点i所连接的边的链表
    }
}
 
int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("E:\\in.txt", "r", stdin);
#endif
 
    int n, m;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        if(n == 0 && m ==0)
        {
            break;
        }
        Init(n);
     
        while(m-->0)
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            Edge temp;
            temp.cost=c;
            temp.next=b;
            edge[a].push_back(temp);
            temp.next=a;
            edge[b].push_back(temp); // 无向图，分别加入两边点的链表中
        }// read
 
        ///  Dijstra  核心
        int i;
        for(i=1; i<= n; i++)
        {
			Dis[i]= -1;
            mark[i]=false;
        }// Init
 
        Dis[1] = 0;
        mark[1]=true;// 将自己加入集合K
        int newP=1;  // 新加入的节点
        for(i=1; i<n; i++)
        {
            int j;
            for(j=0; j < edge[newP].size(); j++)
            {
                int t = edge[newP][j].next;
                int c = edge[newP][j].cost;
                if(mark[t] == true)
                {
                    continue;
                }
                if(Dis[t] == -1 || Dis[t] > Dis[newP]+c)
                {
                    Dis[t] = Dis[newP]+c;
                }
            }
 
            int min=123123123;// 最小值初始化为一个大整数，为找最小值做准备,只需大于边的长度即可
            for(j = 1; j <= n; j++)// 遍历所有接节点
            {
				if(mark[j] == true)
				{
					continue;// 跳过已是结合的点
				}
				if(Dis[j] == -1)
				{
					continue;// 跳过不可达的点
				}
				
                if(Dis[j] < min)
                {
                    min = Dis[j];
                    newP = j; //记录可能加入的下一个节点
                }
            }
            mark[newP] = true;//加入集合K
        }
        /// Dijstra 结束
 
        // 现已求出，节点1到所有节点的最短距离
        printf("%d\n", Dis[n]);
 
    }
    return 0;
}

3.Dijstra（邻接矩阵）

#include <stdio.h>
#include <vector>

using namespace std;

#define SIZE 100+10

int edge[SIZE][SIZE];
bool mark[SIZE];	// 是否属于结合K
int Dis[SIZE];		// 1到点i的距离，-1为无穷。

void Init(int n){
	for(int i=1; i<=n; i++)
	{
		for(int j=1; j<=n; j++)
		{
			edge[i][j] = -1;//-1代表无穷
		}
		edge[i][i]=0;//自己到自己为0
	}
}


int main()
{
#ifdef ONLINE_JUDGE
#else
	freopen("E:\\in.txt", "r", stdin);
#endif

	int n, m;
	while(scanf("%d%d", &n, &m) != EOF)
	{
		if(n == 0 && m ==0)
		{
			break;
		}
		Init(n);
	
		while(m-->0)
		{
			int a, b, c;
			scanf("%d%d%d", &a, &b, &c);
			edge[a][b] = edge[b][a] = c;
		}// read

		///  Dijstra  核心
		int i;
		for(i=1; i<= n; i++)
		{
			mark[i]=false;
			Dis[i]=-1;
		}// Init

		Dis[1] = 0;
		mark[1]=true;// 将自己加入集合K
		int newP=1;  // 新加入的节点
		for(i=1; i<n; i++)
		{
			///
			// 中间这段，是使用邻接矩阵后，Dijstra算法的变化部分
			int j;
			for(j=1; j <= n; j++)
			{
				if(edge[newP][j] == -1)
				{
					continue;
				}// 新加入节点与节点j没有边相连
				if(mark[j] == true)
				{
					continue;
				}//  跨过已是集合K的点
				if(Dis[j]==-1 || Dis[j] > Dis[newP]+edge[newP][j])
				{
					Dis[j] = Dis[newP]+edge[newP][j];
				}
			}
			///

			int min=123123123;//最小值初始化为一个大整数，为找最小值做准备,只需大于边的长度即可
			for(j = 1; j <= n; j++)// 遍历所有接节点
			{
				if(mark[j] == true)
				{
					continue;// 跳过已是结合的点
				}
				if(Dis[j] == -1)
				{
					continue;// 跳过不可达的点
				}
				if(Dis[j] < min)
				{
					min = Dis[j];
					newP = j; //记录可能加入的下一个节点
				}
			}
			mark[newP] = true;//加入集合K
		}
		/// Dijstra 结束

		// 现已求出，节点1到所有节点的最短距离		
		printf("%d\n", Dis[n]);

	}
	return 0;
}