C++博客-yuanyuelang-文章分类-图论

每对顶点间的最短路径之Floyd-Warshall算法

原语饿狼 — Wed, 23 Sep 2009 03:35:00 GMT

        Floyd-Warshall算法的基本思路是：
   1.用D[v][w]记录每对顶点间的最短距离
   2.对每一个图中的顶点，以其作为基点扫描每一对D[v][w]，检验是否通过该基点可以使得这对顶点间的距离变小。

我们实际是很容易就可以写出这个算法的代码：

#define N 100
void Floyd(int dist[N][N],int n)
{
  int i,j,k;
  for(k=0;k<n;k++)
    for(i=0;i<n;i++)
      for(j=0;j<n;j++)
        if(dist[i][k]+dist[k][j]<dist[i][j])
           dist[i][j]=dist[i][k]+dist[k][j];

}

我们还面临一个保存路径的问题,如何来做呢？

#define N 100
int map[N][N];
void Floyd(int dist[N][N],int path[N][N],int n)
{
  int i,j,k;
  for(i=0;i<n;i++)
    for(j=0;j<n;j++)
      dist[i][j]=map[i][j],path[i][j]=0;
  for(k=0;k<n;k++)
    for(i=0;i<n;i++)
      for(j=0;j<n;j++)
        if(dist[i][k]+dist[k][j]<dist[i][j]){
           dist[i][j]=dist[i][k]+dist[k][j];
           path[i][j]=k;

}

void output(int i,int j)
{
  if(i==j) return;
  if(path[i][j]==0) cout<<j<<" ";
  else{
    output(i,path[i][j]);
    output(path[i][j],j);
  }
}

原语饿狼 2009-09-23 11:35 发表评论

单源最短路径之Dijkstra算法

原语饿狼 — Mon, 14 Sep 2009 13:21:00 GMT

单源最短路径，解决的是什么问题呢？
顾名思义，单源说明从一个源出发，出发到哪里呢？不管到哪里我都要求得一个最短的路径。

比较正式的说法：
对于有向图G={V,E},带权，注意Dijkstra算法要求所有的权值非负，
假设我们的源是s，源点要到达的点集合是S，我们每次选择具有最短路径估计的顶点u(u在V-S中，并将u加入到S中，然后此时要对u所有的出边进行处理，怎么处理，我们要最短路径，所以此时要判断s经过u到达V-S中的点会不会比不经过u到达来的小，更新呵呵..

那么怎么写成代码呢？
1.我们需要二维数组graph[][]表示图，用distance[]数组来表示源点V0到其它顶点的最短路径distance[v]，我们还要保存具体路径，我们用path[][]二维bool数组来表示,path[1]就表示源点到顶点V1的路径，path[1][0,n-1]数组里面的元素如果为true表示V0有经过那些顶点到达V1
2.我们还要考虑到顶点是否已经加到S中，用一个flag数组来标志顶点是否已经求的最短路径了。

还要分清是有向图还是无向图，这对于入边和出边在程序处理的时候要注意。

#define MAXN 100
#define INF 0xfffffff

//注意graph里面的数据，两顶点i指向j有边，长为r，则graph[i][j]=r,其余情况graph为INF，包括i==j

void dijkstra(int graph[MAXN][MAXN],bool path[MAXN][MAXN],int distance[],int n)
{
    int i,j,min,vertex;
    bool flag[MAXN];
    for(i=0;i<n;i++){//初始化
        distance[i]=graph[0][i];
        flag[i]=false;
        for(j=0;j<n;j++) path[i][j]=false;
        if(distance[i]<INF){ //路径必定至少有v0和vi两个顶点
            p[i][0]=true;p[i][i]=true;
        }
    }

    flag[0]=true;
    distance[0]=0;//注意一定要初始化distance[0]
    for(i=1;i<n;i++){
        min=INF;
        for(j=1;j<n;j++)
            if(!flag[j]&&distance[j]<min){//找到最近的点
                min=distance[j];
                vertex=j;
            }
        flag[vertex]=true;
        for(j=1;j<n;j++)
            if(!flag[j]&&graph[vertex][j]+min<distance[j]){//如果可以通过vertex更近的话,更新
                distance[j]=graph[vertex][j]+min;
                for(int k=0;k<n;k++) path[j][k]=path[vertex][k];
                path[j][j]=true;
            }
    }

}

请读者务必自己举个例子，运行看看，这样子才能理解好理解的根深蒂固，还有一定要自己不断的写，自己平常要锻炼，做ACM题目时最好自己再写一遍，不要太依赖模板了哈哈。。

原语饿狼 2009-09-14 21:21 发表评论

最小生成树之Prim算法

原语饿狼 — Mon, 14 Sep 2009 10:47:00 GMT

最小生成树是图论的一个重要部分，解决这个问题的算法主要有Kruskal算法和Prim算法。

最小生成树:顾名思义是一棵树，该树是图中权值和最小的。

这篇文章介绍Prim算法，Kruskal算法请参阅最小生成树之Kruskal算法。

Prim算法的主要思路：
1.图G={V,E},V表示节点集，E表示边集，初始时将V0从V中拿出，放入空集合U中，U={V0}，T(E)空
2.选择和集合U有连接的且最近的点Vx（在V中），放入U，U={V0,Vx},并将边加入到T(E)中。
3.重复第二步，直到U=V
很明显需要n-1步，n为图的节点数。

现在我们就是要如何把它变成代码的问题了。
1.存储问题，我们需要一个二元数组graph下标存放节点，数组值存放权值。比如(1,2)有边，权值为3，则graph[1][2]=3,同时graph[2][1]=3，没有边的点用INF（无穷大）表示咯。
2.如何判断和最近的点，由于每一次进来都会改变情况，所以每次都要更新，我们用一个一元数组opt[n]来表示，数组下标表示节点号，值表示该节点到U的最短距离。记住，加入到U集合的点是不用再管它的了，所以，我们还要设置一个数组flag[n]，来设置标志位，看是否已经加入到U集合了。
3.这样的话大功也就告成了，一般就会写了吧。如果要保存各个边的话，还要添加一个数组line[n]来表示节点到U的最短距离到底是连接U中哪一个节点的。

看看代码，分析分析吧。。记住很重要的，自己举个例子看看。最后一定要熟练掌握其原理，并且快速的写出代码。

#define MAXN 100
#define INF 0xfffffff

int result_s[MAXN],result_e[MAXN];//保存边

void prim(int graph[MAXN][MAXN],int opt[],int n)
{
  int i,j,min,vertex，line[n];
  bool flag[n];

  for(i=0;i<n;i++){ //初始化
    opt[i]=graph[0][i];
    line[i]=0;
    flag[i]=false;
   }
  flag[0]=true;
  for(i=1;i<n;i++){
    min=INF;
    for(j=1;j<n;j++){
      if(!flag[j]&&opt[j]<min){//选择最优点
        min=opt[j];
        vertex=j;
      }
    }
    flag[vertex]=true; //加入到U集合
    result_s[i]=line[vertex];//保存
    result_e[i]=vertex;
    for(j=1;j<n;j++){//更新
      if(!flag[j]&&graph[vertex][j]<opt[j])
         opt[j]=graph[vertex][j];
         line[j]=vertex;
    }
  }
}

因为代码是自己当场写出来，写出来和原来正确代码相比较了，如果读者发现有错，还望指正。
我想我们就是要锻炼这种写代码的能力，不能太依靠模板，不然忘得快。
注意：最后结果都知道了，opt[]保存的是最小生成树的选入的各个边的权值，result_s[]和result_e保存了到底是哪些点组成的最小生成树。

原语饿狼 2009-09-14 18:47 发表评论

最小生成树之Kruskal算法

原语饿狼 — Sun, 13 Sep 2009 13:18:00 GMT

最小生成树是图论的一个重要部分，解决这个问题的算法主要有Kruskal算法和Prim算法。

最小生成树:顾名思义是一棵树，该树是图中权值和最小的。

我们先来介绍Kruskal算法，Prim算法请参阅最小生成树之Prim算法

该算法的基本思路：贪心，如何贪心呢？
它的贪心准则是：
1.每次从剩下的边中选择一个不会产生环路而且权值最小的边加入到已经选择好的边的集合中。
2.它需要e步的操作，e表示图的边数，我们可以按权值排好序后，对每一条边进行选择，如果加入到已经选择好的边中会产生回路的现象，就不要了。。。否则加入到已经选择好的边中。
3.我们还需用到并查集的思想，有关并查集的介绍，请查看我的另一篇博文不相交集合数据结构
4.复杂度：O(ElgE)，其中E为图的边数

接下来我们引用POJ上的一个经典题目来分析，题目网址http://acm.pku.edu.cn/JudgeOnline/problem?id=1861

题目大意是：题目给出的是图的顶点和所有边的集合，要求输出的是最小生成树的边

我们来看下源码啦：

#include<iostream>
using namespace std;
#include<algorithm>
#include <memory.h>

#define MAXEDGE 15001//最大边数
#define MAXNODE 1001 //最大节点数

int p[MAXNODE],rank[MAXNODE];//用于不相交集合
int start[MAXEDGE],end[MAXEDGE],weight[MAXEDGE],VNum,ENum;//分别为边的起点，终点，权重，节点数和边数
int result_s[MAXEDGE],result_e[MAXEDGE];//分别为存储最小生成树的起点，终点
int max_weight,id[MAXEDGE];

void make_set(int x)
{
    p[x]=x;
    rank[x]=0;
}

int find_set(int x)
{
    if(p[x]!=x)
        p[x]=find_set(p[x]);
    return p[x];
}

void Union(int x,int y)
{
    x=find_set(x);
    y=find_set(y);
    if(rank[x]>rank[y])
        p[y]=x;
    else if(rank[x]<rank[y])
        p[x]=y;
    else if(rank[x]==rank[y])
    {
        p[x]=y;
        rank[y]++;
    }
}

bool cmp(int i,int j)//用于sort函数
{
    return weight[i]<weight[j];
}
void Kruskal()
{
    int i,min,index=0,count=0,k=0;

    max_weight=0;
        for(i=1;i<=VNum;i++)
          make_set(i);

        sort(id,id+ENum,cmp);//对所有边进行排序，注意id数组的妙用
    while(true){
      min=id[index++];
      if(find_set(start[min])!=find_set(end[min])){ //对每条边进行处理，如果起点和终点不在同一集合合并之
        Union(start[min],end[min]);
        result_s[k]=start[min];//保存结果
                result_e[k++]=end[min];
                count++;
        if(max_weight<weight[min])
                max_weight=weight[min];
       }

        if(count==VNum-1) break;//当边数等于节点数-1的时候表示已经完成
    }
}

int main()
{
    int i;
    cin>>VNum>>ENum;
    for(i=0;i<ENum;i++){
        cin>>start[i]>>end[i]>>weight[i];
        id[i]=i;
    }
        Kruskal();
        cout<<max_weight<<endl<<VNum-1<<endl;
        for(i=0;i<VNum-1;i++)
       cout<<result_s[i]<<" "<<result_e[i]<<endl;

        return 0;
}

原语饿狼 2009-09-13 21:18 发表评论