图论几大重点算法

最小生成树算法

1、普利姆算法
“走一步看一步，逐步生成最小生成树”

#include
#include
#define  N 1000
#define  MAX 65535
using namespace std;

int arc[N][N];
int num;//顶点数
int n;//边数
int low_price=0;
void MiniSpanTree_Prim(){
    int min,i,j,k;
    int adjvex[N];/* 保存相关顶点下标 */
    int lowcost[N];/* 保存相关顶点间边的权值 */
    adjvex[0]=0;/* 初始化第一个权值为0，即v0加入生成树 */
    lowcost[0]=0;/* lowcost的值为0，在这里就是此下标的顶点已经加入生成树 */
    for(int i=1;i<num;i++){
        lowcost[i]=arc[0][i];
        adjvex[i]=0;
    }
    for(int i=1;i<num;i++){
        min=MAX;
        j=1;k=0;
        while(j<num){
            if(lowcost[j]!=0&&min>lowcost[j]){
                min=lowcost[j];
                k=j;
            }
            j++;
        }
        low_price+=min;//累加进入顶点集的最小边的数值
        printf("(%d,%d)\n",adjvex[k],k);/* 打印当前顶点边中权值最小的边 */
        lowcost[k]=0;
        for(int j=1;j<num;j++){
            if(lowcost[j]!=0&&arc[k][j]<lowcost[j]){
                lowcost[j]=arc[k][j];
                adjvex[j]=k;
            }
        }
    }
}
int main()
{
    cin>>num;
	cin>>n;
	for(int i=0;i<num;i++)
        for(int j=0;j<num;j++)
            arc[i][j]=MAX;
	for(int i=0;i<n;i++){
        int x,y,length;
        cin>>x>>y>>length;
        arc[x][y]=arc[y][x]=length;
	}
	MiniSpanTree_Prim();
	cout<<low_price<<endl;
	return 0;
}
/*
测试样例1：
9 15
0 1 10
0 5 11
1 6 16
5 6 17
1 2 18
1 8 12
2 8 8
2 3 22
3 8 21
3 6 24
3 7 16
3 4 20
6 7 19
4 7 7
5 4 26
*/
/*
测试样例2：
9 14
0 1 4
1 2 8
2 3 7
3 4 9
4 5 10
5 6 2
6 7 1
7 8 7
1 7 11
2 8 2
6 8 6
2 5 4
3 5 14
0 7 8*/

测试样例1输出：37
测试样例2输出：99

2、布鲁斯卡尔算法
“全局意识，从图中最短权值的边入手”

#include
#include
#define  N 1000
#define  MAX 65535
using namespace std;

int arc[N][N];
int num;//顶点数
int nb;//边数
int low_price=0;
int parent[N];/* 定义一数组用来判断边与边是否形成环路 */
struct bian
{
    int begin;
    int end;
    int weight;
}edge[N];
bool cmp(bian a,bian b)
{
    return a.weight<b.weight;
}
int Find(int f)
{
    while(parent[f]>0)
        f=parent[f];
    return f;
}
void MiniSpanTree_Kruskal(){
    int i,j,m,n,k=0;
    for(int i=0;i<num-1;i++){
        for(int j=i+1;j<num;j++){
            if(arc[i][j]<MAX){
                edge[k].begin=i;
                edge[k].end=j;
                edge[k].weight=arc[i][j];
                k++;
            }
        }
    }
    sort(edge,edge+nb,cmp);
    for (i = 0; i<num; i++)
		parent[i] = 0;	/* 初始化数组值为0 */
    for(int i=0;i<nb;i++){
        n=Find(edge[i].begin);
        m=Find(edge[i].end);
        if(n!=m){/* 假如n与m不等，说明此边没有与现有的生成树形成环路 */
            parent[n]=m;/* 将此边的结尾顶点放入下标为起点的parent中。 */
            /* 表示此顶点已经在生成树集合中 */
            printf("(%d,%d) %d\n",edge[i].begin,edge[i].end,edge[i].weight);
            low_price+=edge[i].weight;
        }
    }
}
int main()
{
    cin>>num;
	cin>>nb;
	for(int i=0;i<num;i++)
        for(int j=0;j<num;j++){
            if(i==j)arc[i][j]=0;
            else arc[i][j]=MAX;
        }
	for(int i=0;i<nb;i++){
        int x,y,length;
        cin>>x>>y>>length;
        arc[x][y]=arc[y][x]=length;
	}
	MiniSpanTree_Kruskal();
	cout<<low_price<<endl;
	return 0;
}
/*
9 15
0 1 10
0 5 11
1 6 16
5 6 17
1 2 18
1 8 12
2 8 8
2 3 22
3 8 21
3 6 24
3 7 16
3 4 20
6 7 19
4 7 7
5 4 26
*/
/*9 14
0 1 4
1 2 8
2 3 7
3 4 9
4 5 10
5 6 2
6 7 1
7 8 7
1 7 11
2 8 2
6 8 6
2 5 4
3 5 14
0 7 8*/

运行结果同上，同样为最小生成树算法，只是方法不同。

最短路径算法

1、迪杰斯特拉算法
“强调单源顶点查找路径的方式”

#include
#include
#define  N 1000
#define  MAX 65535
using namespace std;

int arc[N][N];
int num;//顶点数
int nb;//边数
int dis[N];/* 用于存储到各点最短路径的权值和 */
int path[N];/* 用于存储最短路径下标的数组 */
void ShortestPath_Dijkstra(){
    int v,w,k,min;
    int fina[N];
    for(v=0;v<num;v++){
        path[v]=0;
        dis[v]=arc[0][v];
        fina[v]=0;
    }
    fina[0]=1;
    for(v=1;v<num;v++){
        min=MAX;
        for(w=0;w<num;w++){
            if(!fina[w]&&min>dis[w]){
                min=dis[w];
                k=w;
            }
        }
        fina[k]=1;
        for(w=0;w<num;w++){
            if(!fina[w]&&min+arc[k][w]<dis[w]){
                dis[w]=min+arc[k][w];
                path[w]=k;
            }
        }
    }
}
int main()
{
    cin>>num;
	cin>>nb;
	for(int i=0;i<num;i++)
        for(int j=0;j<num;j++){
            if(i==j)arc[i][j]=0;
            else arc[i][j]=MAX;
        }
	for(int i=0;i<nb;i++){
        int x,y,length;
        cin>>x>>y>>length;
        arc[x][y]=arc[y][x]=length;
	}
	ShortestPath_Dijkstra();
	for(int i=0;i<num;i++)
        cout<<dis[i]<<' ';
    cout<<endl;
    for(int i=0;i<num;i++)
        cout<<path[i]<<' ';
	return 0;
}
/*
9 16
0 1 1
0 2 5
1 2 3
1 4 5
1 3 7
2 4 1
2 5 7
3 4 2
3 6 3
4 5 3
4 6 6
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4
*/

样例输出：

2、佛洛依德算法
“巧妙利用矩阵变换”

#include
#include
#define  N 1000
#define  MAX 65535
using namespace std;

int arc[N][N];
int num;//顶点数
int nb;//边数
int dis[N][N];/* 用于存储到各点最短路径的权值矩阵 */
int path[N][N];/* 对应顶点最小路径的前驱矩阵 */
void ShortestPath_Floyd(){
    int v,w,k,min;
    for(v=0;v<num;v++){
        for(w=0;w<num;w++){
            dis[v][w]=arc[v][w];
            path[v][w]=w;
        }
    }
    for(k=0;k<num;k++){
        for(v=0;v<num;v++){
            for(w=0;w<num;w++){
                if(dis[v][w]>dis[v][k]+dis[k][w]){
                    dis[v][w]=dis[v][k]+dis[k][w];
                    path[v][w]=path[v][k];
                }
            }
        }
    }
}
int main()
{
    int v,w;
    cin>>num;
	cin>>nb;
	for(int i=0;i<num;i++)
        for(int j=0;j<num;j++){
            if(i==j)arc[i][j]=0;
            else arc[i][j]=MAX;
        }
	for(int i=0;i<nb;i++){
        int x,y,length;
        cin>>x>>y>>length;
        arc[x][y]=arc[y][x]=length;
	}
	ShortestPath_Floyd();
	for(v=0;v<num;v++){
        for(w=0;w<num;w++){
            printf("%d ",dis[v][w]);
        }
        printf("\n");
    }
    for(v=0;v<num;v++){
        for(w=0;w<num;w++){
            printf("%d ",path[v][w]);
        }
        printf("\n");
    }
    
	return 0;
}
/*
9 16
0 1 1.
0 2 5
1 2 3
1 4 5
1 3 7
2 4 1
2 5 7
3 4 2
3 6 3
4 5 3
4 6 6
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4
*/

for(v=0;v<num;v++){
        for(w=v+1;w<num;w++){
            printf("\nV%d-V%d weight:%d\n",v,w,dis[v][w]);
            k=path[v][w];
            printf("path: %d",v);
            while(k!=w){
                printf("->%d",k);
                k=path[k][w];
            }
            printf("->%d",w);
        }
        printf("\n");
    }

有向无环图的应用

1、拓扑排序
可以判断一个有向图是否存在环

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 14
#define INFINITY 65535

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

/* 邻接矩阵结构 */
typedef struct
{
	int vexs[MAXVEX];
	int arc[MAXVEX][MAXVEX];
	int numVertexes, numEdges;
}MGraph;

/* 邻接表结构****************** */
typedef struct EdgeNode /* 边表结点  */
{
	int adjvex;    /* 邻接点域，存储该顶点对应的下标 */
	int weight;		/* 用于存储权值，对于非网图可以不需要 */
	struct EdgeNode *next; /* 链域，指向下一个邻接点 */
}EdgeNode;

typedef struct VertexNode /* 顶点表结点 */
{
	int in;	/* 顶点入度 */
	int data; /* 顶点域，存储顶点信息 */
	EdgeNode *firstedge;/* 边表头指针 */
}VertexNode, AdjList[MAXVEX];

typedef struct
{
	AdjList adjList; 
	int numVertexes,numEdges; /* 图中当前顶点数和边数 */
}graphAdjList,*GraphAdjList;
/* **************************** */


void CreateMGraph(MGraph *G)/* 构件图 */
{
	int i, j;
	
	/* printf("请输入边数和顶点数:"); */
	G->numEdges=MAXEDGE;
	G->numVertexes=MAXVEX;

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		G->vexs[i]=i;
	}

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		for ( j = 0; j < G->numVertexes; j++)
		{
			G->arc[i][j]=0;
		}
	}

	G->arc[0][4]=1;
	G->arc[0][5]=1; 
	G->arc[0][11]=1; 
	G->arc[1][2]=1; 
	G->arc[1][4]=1; 
	G->arc[1][8]=1; 
	G->arc[2][5]=1; 
	G->arc[2][6]=1;
	G->arc[2][9]=1;
	G->arc[3][2]=1; 
	G->arc[3][13]=1;
	G->arc[4][7]=1;
	G->arc[5][8]=1;
	G->arc[5][12]=1; 
	G->arc[6][5]=1; 
	G->arc[8][7]=1;
	G->arc[9][10]=1;
	G->arc[9][11]=1;
	G->arc[10][13]=1;
	G->arc[12][9]=1;

}

/* 利用邻接矩阵构建邻接表 */
void CreateALGraph(MGraph G,GraphAdjList *GL)
{
	int i,j;
	EdgeNode *e;

	*GL = (GraphAdjList)malloc(sizeof(graphAdjList));

	(*GL)->numVertexes=G.numVertexes;
	(*GL)->numEdges=G.numEdges;
	for(i= 0;i <G.numVertexes;i++) /* 读入顶点信息，建立顶点表 */
	{
		(*GL)->adjList[i].in=0;
		(*GL)->adjList[i].data=G.vexs[i];
		(*GL)->adjList[i].firstedge=NULL; 	/* 将边表置为空表 */
	}
	
	for(i=0;i<G.numVertexes;i++) /* 建立边表 */
	{ 
		for(j=0;j<G.numVertexes;j++)
		{
			if (G.arc[i][j]==1)
			{
				e=(EdgeNode *)malloc(sizeof(EdgeNode));
				e->adjvex=j;					/* 邻接序号为j  */                        
				e->next=(*GL)->adjList[i].firstedge;	/* 将当前顶点上的指向的结点指针赋值给e */
				(*GL)->adjList[i].firstedge=e;		/* 将当前顶点的指针指向e  */  
				(*GL)->adjList[j].in++;
				
			}
		}
	}
	
}


/* 拓扑排序，若GL无回路，则输出拓扑排序序列并返回1，若有回路返回0。 */
Status TopologicalSort(GraphAdjList GL)
{    
	EdgeNode *e;    
	int i,k,gettop;   
	int top=0;  /* 用于栈指针下标  */
	int count=0;/* 用于统计输出顶点的个数  */    
	int *stack;	/* 建栈将入度为0的顶点入栈  */   
	stack=(int *)malloc(GL->numVertexes * sizeof(int) );    

	for(i = 0; i<GL->numVertexes; i++)                
		if(0 == GL->adjList[i].in) /* 将入度为0的顶点入栈 */         
			stack[++top]=i;    
	while(top!=0)    
	{        
		gettop=stack[top--];        
		printf("%d -> ",GL->adjList[gettop].data);        
		count++;        /* 输出i号顶点，并计数 */        
		for(e = GL->adjList[gettop].firstedge; e; e = e->next)        
		{            
			k=e->adjvex;            
			if( !(--GL->adjList[k].in) )  /* 将i号顶点的邻接点的入度减1，如果减1后为0，则入栈 */                
				stack[++top]=k;        
		}
	}   
	printf("\n");   
	if(count < GL->numVertexes)        
		return ERROR;    
	else       
		return OK;
}


int main(void)
{    
	MGraph G;  
	GraphAdjList GL; 
	int result;   
	CreateMGraph(&G);
	CreateALGraph(G,&GL);
	result=TopologicalSort(GL);
	printf("result:%d",result);

	return 0;
}

2、关键路径算法

注：本文的所有算法借鉴《大话数据结构》