一。图论

1.DijStla

void dijstra(){
	int i,j,ans=-1,min,v;
	int d[MAXV],vis[MAXV];
	//d数组表示从原点到i点的最短距离
	//vis用于表达这个点是否已经被选中
	for(i=1;i<=n;i++){
		d[i]=INF;
		vis[i]=0;
	}
	d[1]=0;		//因为start到start的距离为0，这里源点为1

	for(i=1;i<=n;i++){
		min=INF;
		for(j=1;j<=n;j++){		//每次找点的过程，首先这个点没有被发现，然后找一个最小点
			if(!vis[j] && d[j]<min){
				min=d[j];
				v=j;
			}
		}
		//这里为什么找的最小的边就一定是最短路呢
		//因为一个图要连通起来，就必须有一条边和已知点集连起来，所以找的最小的未知点必是最短路
		vis[v]=1;

		for(j=1;j<=n;j++)		//加进最小点后，再修改从源点没有被发现的点的最短路径
			if(!vis[j] && d[v]+map[v][j]<d[j])
				d[j]=d[v]+map[v][j];
	}

	for(i=2;i<=n;i++)
		if(d[i]>ans) ans=d[i];
	printf("%d\n",ans);
}

http://blog.csdn.net/challenchenzhipeng/article/details/8100454

2. bellman-ford

typedef struct{  
    int a,b,w;  
}Edge;  
  
Edge edge[MAXM];  
int n,m;  
  
void bellman_ford(){  
    int i,j;  
    int d[MAXV];  
    for(i=2;i<=n;i++) d[i]=inf;  
    d[1]=0;  
  
    for(i=1;i<=n;i++){  
        for(j=1;j<=m;j++){  
            if(d[edge[j].a]>edge[j].w+d[edge[j].b]) d[edge[j].a]=edge[j].w+d[edge[j].b];  
            if(d[edge[j].b]>edge[j].w+d[edge[j].a]) d[edge[j].b]=edge[j].w+d[edge[j].a];  
        }  
    }  
    printf("%d\n",d[n]);  
}  

http://blog.csdn.net/wangjian8006/article/details/7871889

3. floyd

void floyd(){  
    int i,j,k;  
    for(k=1;k<n;k++)  
        for(i=1;i<n;i++)  
            for(j=1;j<n;j++)  
                if(map[i][j]>map[i][k]+map[k][j])  
                    map[i][j]=map[i][k]+map[k][j];  
}  

4. prim

void Prim(MGraph g,int v,int ∑)
 /*
 *LowCost[i]:当前生成树（U集合）到顶点i的多条边中最短的一条边。
 *VexSet[i]:顶点i不在生成树中。1表示在里面，0反之。
 *MGraph用的邻接矩阵表示，其中用edges[i][j]来记录i-->j是否有关系。n表示顶点个数，e表示边的个数。
 */
 void Prim(MGraph g,int v,int ∑)
  {
       int LowCost[Max],VexSet[Max],v;
       int i,j,k,min;
 
      //初始化LowCost,VexSet数组  
 ​    for(i=0;i<g.n;i++)
 ​    {
 ​    ​    LowCost[i]=g.edges[v][i];
 ​    ​    VexSet[i]=0;
 ​    }​ 
 
    ​ ​ VexSet[v]=1;
 ​    ​  sum=0;
    /*------------------------------------------------我是分割线---------------------------------------------------------*/
      for(i=0;i<g.n;i++)
       {
            min = INF;//表示无穷或者大于所有的权值就行
 
           //找出LowCost的最短代价（权值）即找出最短边中的最短的一条。​    
           for(j=0;j<g.n;j++)
            {
                 if(VexSet[j]==0&&LowCost[j]<min)
                 {
                      min = LowCost[j];
                      k=j;
                 }
            }
    
           //将该条边加入生成树中
            VexSet[k]=1;
            v=k;
            sum+=min;//这个可以根据需要调整，这里做的是计算min的和。
 
           //加入一个顶点v之后，生成树到各个不在生成树的顶点的最小值也会变。
            //即更新LowCost数组（只计算不在生成树的顶点且只要更新与新添进去的顶点相关的边）。
            for(j=0;j<g.n;j++)
            {
                 if(VexSet[j]==0&&g.edges[v][j]<LowCost[j])
                 {
                      LowCost[j]=g.edges[v][j];
                 }
            }
 
       }
  }