从拓扑排序到广度优先搜索到单源最短路径
一.图
一个图G(Graph)=(V,E) 即由顶点与边的集合组成，每一条边都是一个点对（u,w) 如果点是有序的，那么图就是有向的。 在无向图中，若具有边（u,v) 那u与v邻接且v也与u邻接。边还有第三成分，即权值。
图的实现：
表示图的一个简单方法是使用一个二维数组，称为邻接矩阵，对于每条边（u,v)，我们置A[u][v]=权值，否则即为0或者正无穷或负无穷大。这样表示图的方法虽然十分简单，但所需的空间则为O（V²）
二.拓扑排序
拓扑排序是对有向无权圈图的顶点的一种排序，他使得如果存在一条从vi到vj的路径，那么在排序中vj出现在vi的后面，举一个简单地例子，以大学选课为例，有许多专业课的选择前提条件是满足某些基础课程，那么拓扑排序则是将课程从基础到专业，按照前置条件的需求一个一个排序，所以拓扑排序的前提条件是图是不能组成一个圈，否则则不存在前置条件。此外，拓扑排序并不是唯一的。若u->v,x->y 那么u x v y 或者x u v y 都是合理的排序。
原理：
一个简单的求拓扑排序的算法是先找出一个任意一个没有入边的顶点，然后我们显示出该顶点，并将他和他的边一起从图中删除，其余的部分用同样地方法处理。我们把顶点v的入读定义为边（u,v)的条数。
以HDU1285 例题为例：
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。
4 3 1 2 2 3 4 3
1 2 4 3
题目分析：
将队伍按照获胜情况排序其实本质上还是拓扑排序，输入P1 P2就相当于点（u,v) 那么最后的获胜方一定是没有被打败过，则第一名的对应点所在入度为0，将第一名排除在外看，那么第二名则不会被剩下的人打败过，那么在去除第一名的图中，第二名的入度为0，以此往下递归直至所有点被排序完。
代码：
#include <stdio.h>
#include <string.h>
#define MAXN 600
int n, m, indegree[MAXN], G[MAXN][MAXN], q[MAXN];
int toposort(){
int i, j, k;
i=0;
while(i<n){
for(j=1; j<=n; j++){
if(indegree[j] == 0){
indegree[j]--;
q[i++] = j;
for(k=1; k<=n; k++) if(G[j][k]) indegree[k]--;
break;
}
}
}
return 1;
}
int main(){
int i, a, b;
while(scanf("%d%d", &n, &m) == 2){
memset(G, 0, sizeof(G));
memset(indegree, 0, sizeof(indegree));
for(i=1; i<=m; i++){
scanf("%d %d", &a, &b);
if(G[a][b] == 0){
G[a][b] = 1;
indegree[b]++;
}
}
toposort();
for(i=0; i<n; i++){
if(i != n-1) printf("%d ", q[i]);
else printf("%d\n", q[i]);
}
}
return 0;
}三. 单源有向无权最短路径.
一个无权的图G，使用某个顶点S作为输入参数，我们想要找出从S到其他顶点的最短路径，我们只对包含在路径中得边感兴趣，因此边并不存在权，或者换一句话说，所有边的权都有1。 现在我们对最短路径的长而不是具体的路径有兴趣，记实实际的路径只不过是简单的簿记问题。我们选择一个图中得一个顶点u作为起点，那么这个点到其本身的距离为0。然后将所有（u,v)权值为1的点遍历，依次判断是否为终点，若是，则终止，否则将继续判断（v,x)权值为1，即距离起点的u的距离为2的所有点，依次遍历判断是否为终点，依次递归直至找到终点。
由此算法实现可以看出，所找到的终点所到起点的路径，一定是最短的路径，设长度为n，若是存在一条长为n+1的起点至终点的路径，他的判断一定是来自于一个与起点u距离为n且不是终点的点，那么在判断这个点得时刻，所有与起点距离为n的点都会在判断这个点的之前抑或是之后被判断，那么距离为n的终点路径一定会被遍历到，所以BFS（breadth-first search)广度优先搜索一定是得到距离最短的路径。
实现：
实现BFS的关键点在与先判断所有距离为n的点后再开始遍历判断距离为n+1的点，所以我们常用的存在点得数据结构为队列。先将起点压入队列，随后进入while循环，条件即为队列不为空（即所有点没有被遍历完），将每个压出队列的点进行判断，若不是终点，则将与其邻接的点压入队列，这样的实现方式正实现了将所有距离为n的点遍历判断为在开始判断距离为n+1的点的次序。
例题：
Description
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
Input
Output
Sample Input
0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0
Sample Output
(0, 0) (1, 0) (2, 0) (2, 1) (2, 2) (2, 3) (2, 4) (3, 4) (4, 4)
没啥好说的，就是从起点，开始一步一步走，距离为n的点遍历判断完开始判断距离为n+1的点，直至找到终点。
代码：
#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
int N,K;
int vis[1000010];
int par[1000010];
int dir[3][2]={{1,1},{1,-1},{2,0}};
bool bfs(int a,int b)
{
queue<int> Q;
Q.push(a);
vis[a]=1;
while(!Q.empty())
{
int t=Q.front();
Q.pop();
if(t==K)
{ return 1;}
for(int i=0;i<3;i++)
{
int CA;
CA=t*dir[i][0];
CA=CA+dir[i][1];
if(vis[CA]==1||CA>100000||CA<0)
continue ;
par[CA]=t;
vis[CA]=1;
Q.push(CA);
}
}
return 0;
}
int main ()
{
while(scanf("%d%d",&N,&K)==2)
{
memset(vis,0,sizeof(vis));
memset(par,-1,sizeof(par));
int time=0;
bfs(N,K);
int t=K;
while(1)
{
if(par[t]==-1)
break;
t=par[t];
time++;
}
cout<<time<<endl;
}
return 0;
}四.单源有向有权最短路径 Dijstra算法。
如果图是赋权图，那么问题就明显的复杂了起来。不过我们依旧可以从无权图的基础上延续。我们保留所有之前的信息，因此所有的点都变为已知的或者标记为未知的，像以前一样，我们对每一个顶点都保留一个临时距离d。这个距离实际上是使用已知顶点作为中间顶点从s到v得最短路径的长。和以前一样，我们记录为p0，他是引起dv变化的顶点。解决单源最短路径的一半方法为Dijstra算法，这个算法是贪婪算法的最好的例子。
贪婪算法是将一个问题分成阶段性的问题，在每个阶段他都把当前出现的当做最好的去处理，即是每一阶段都取该阶段的最优解。值得一提的是，贪婪算法并不是总能成功地。
Dijstra算法像无权最短路径一样按阶段进行，在每个阶段，Dij算法选择一个顶点v,他再所有未知顶点中具有最小的dv，同时算法声明从S到V得最短路径是已知的，阶段的其他部分由dw值得更新工作组成。
形象的说，我们在构造图的时候将边的领接与权值构造完以后，在从起点开始依次遍历时，我们都会得到一个当前点得距离值，我们会将这个距离值与一开始构造所得到的权值进行比较 ，然后将该点得权值更新为较小的值。 举一个简单的例子我们有顶点 u v w 其中(u v)=1 (v w) =2 (u w)=4 即一开始Dw的权值为4 当我们的遍历从v点进行到w点时候我们得到dw=1+2=3 此时所得到值dw会与一开始构造时所得到的权值进行比较 最后Dw的权值更新为3. Dij算法可以将每个点到原点的距离都更新为最短的路径 ，直至终点，这样我们所得到的终点路径即为最小值。
题目：
Description
现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。
Input
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。
Output
Sample Input
3 3
0 1 1
0 2 3
1 2 1
0 2
3 1
0 1 1
1 2
分析：
构造图后，领接点得权值赋值，未领接得点权值赋值为INF（即无穷大） 在经过Dij算法后，终点D的距离则为最短路径值，若终点D的路径值为INF ，则说明不存在路径，即起点无法到达终点。
代码：
#include <iostream>
#include <sstream>
#include <ios>
#include <iomanip>
#include <functional>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <cctype>
using namespace std;
#define XINF INT_MAX
#define INF 0x3FFFFFFF
#define MP(X,Y) make_pair(X,Y)
#define PB(X) push_back(X)
#define REP(X,N) for(int X=0;X<N;X++)
#define REP2(X,L,R) for(int X=L;X<=R;X++)
#define DEP(X,R,L) for(int X=R;X>=L;X--)
#define CLR(A,X) memset(A,X,sizeof(A))
#define IT iterator
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<int> VI;
const int MAXN = 100010;
vector<PII> G[MAXN];
void add_edge(int u,int v,int d){
G[u].PB(MP(v,d));
}
void init(int n){
for(int i=0;i<n;i++){
G[i].clear();
}
}
int vis[MAXN];
int dis[MAXN];
void dijkstra(int s,int n){
for(int i=0;i<n;i++)vis[i] = 0;
for(int i=0;i<n;i++)dis[i] = (i == s ? 0 : INF);
priority_queue<PII,VII,greater<PII> >q;
q.push(MP(dis[s],s));
while(!q.empty()){
PII p = q.top();
int x = p.second;
q.pop();
if(vis[x])continue;
vis[x] = 1;
for(int i=0;i<G[x].size();i++){
int y = G[x][i].first;
int d = G[x][i].second;
if(!vis[y]&&dis[x] + d < dis[y]){
dis[y] = dis[x] + d;
q.push(MP(dis[y],y));
}
}
}
}
int main(){
ios::sync_with_stdio(0);
int n,m;
while(cin>>n>>m){
init(n);
int u,v,d;
for(int i=0;i<m;i++){
cin>>u>>v>>d;
//u--;v--;
add_edge(u,v,d);
add_edge(v,u,d);
}
int s,t;
cin>>s>>t;
dijkstra(s,n);
int ans = dis[t];
if(ans == INF)ans = -1;
cout<<ans<<endl;
}
}
3857
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
