简单图论（模板题）

弗洛伊德
HDU - 2544

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
#include<cstdio>
#include<vector>
#include<set>
#include<cstring>
#include<cstdlib>
#include<time.h>
#include<stack>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn=1005;
int dp[maxn][maxn];
int mp[maxn][maxn];
int n,m,start,end;
void floyd(){
	for(int u=1;u<=n;u++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				dp[i][j]=min(dp[i][j],dp[i][u]+dp[u][j]);
			}
		}
	}
}
void init(){
	memset(dp,INF,sizeof(dp));
	memset(mp,INF,sizeof(mp));
}
int main(){
	while(scanf("%d%d",&n,&m)!=EOF){
		if(n==0&&m==0) break;
		init();
		int u,v,cost;
		for(int i=1;i<=m;i++){
			scanf("%d%d%d",&u,&v,&cost);
			if(dp[u][v]>cost){
				dp[u][v]=cost;
				dp[v][u]=cost;
			}	
		}
		floyd();
		cout<<dp[1][n]<<endl;
	}
		return 0;
}

dij
HDU - 4725

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
#include<cstdio>
#include<vector>
#include<set>
#include<cstring>
#include<cstdlib>
#include<time.h>
#include<stack>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn=7e5+5;
int t,n,m,c,tot,cnt,head[maxn],Next[maxn],ver[maxn],edge[maxn],p[maxn];
int d[maxn],layer[maxn];
bool jg[maxn],vis[maxn];
void init(){
	memset(edge, INF, sizeof(edge));
    memset(head, 0, sizeof(head));
	memset(jg,0,sizeof(jg));
	memset(p,0,sizeof(p));
	cnt=0;
}
void add(int u,int v,int w)
{
    ver[++cnt]=v;
	edge[cnt]=w;
	Next[cnt]=head[u];
	head[u]=cnt;
}
void dij()
{
    memset(vis,0,sizeof(vis));
    priority_queue<pair<int,int>>q;
    memset(d,0x3f,sizeof(d));
    int k=d[0];
    d[1]=0;
    q.push(make_pair(0,1));
    while(q.size())
    {
        int x=q.top().second;q.pop();
        if(vis[x])continue;
        for(int i=head[x];i;i=Next[i])
        {
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z)
            {
                d[y]=d[x]+z;
                q.push(make_pair(-d[y],y));
            }
        }
    }
	if(k==d[n])
		printf("-1\n");
	else
    	printf("%d\n",d[n]);
}
int main(){
	int t,tot=1;
	cin>>t;
	while(t--){
		init();	
		cin>>n>>m>>c;
		for(int i=1;i<=n;i++){
			scanf("%d",&p[i]);
			p[i]+=n;
			jg[p[i]]=1;
			add(p[i],i,0);
		}
		for(int i=1;i<=n;i++){
			if(jg[p[i]+1])add(i,p[i]+1,c);
			if(jg[p[i]-1])add(i,p[i]-1,c);
		}
		for(int i=1;i<=m;i++){
			int x,y,z;
			scanf("%d%d%d",&x,&y,&z);
			add(x,y,z);add(y,x,z);
		}
		 printf("Case #%d: ",tot);
		 tot++;
		 dij();
	}
	return 0;
}

spfa
HDU - 1874

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
#include<cstdio>
#include<vector>
#include<set>
#include<cstring>
#include<cstdlib>
#include<time.h>
#include<stack>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn=2005;
ll dp[maxn][maxn];
ll a[maxn],ans[maxn];
ll n,m,start,end;
struct node{
	int x,y,cost;//边的右端点，边下一条边，边权
}n1[maxn];
int head[205],tot=0,dis[205],N,M,vis[205];
void add(int from,int to,int dis){
	n1[++tot].y = head[from];
	n1[tot].x = to;
	n1[tot].cost = dis;
	head[from] = tot;
}
void spfa(int s){
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	memset(vis,0,sizeof(vis));
	vis[s]=0;
	queue<int>qu;
	qu.push(s);
	while(!qu.empty()){
		int u=qu.front();
		qu.pop();
		vis[u]=0;
		for(int i=head[u];i;i=n1[i].y){
			int to=n1[i].x;
			int di=n1[i].cost;
			if(dis[to]>dis[u]+di){
				dis[to]=dis[u]+di;
				if(!vis[to]){
					vis[to]=1;
					qu.push(to);
				}
			}
		}
	}
}
int main(){
	while(scanf("%d%d",&n,&m)!=EOF){
		memset(head,0,sizeof(head));
		for(int i=1;i<=m;i++){
			int a,b,dis;
			cin>>a>>b>>dis;
			a++;b++;
			add(a,b,dis);add(b,a,dis);
		}
		int s,e;
		cin>>s>>e;
		s++;e++;
		spfa(s);
		if(dis[e]==INF)
			cout<<"-1"<<endl;
		else
			cout<<dis[e]<<endl;
	}
	return 0;
}

最小生成树prim
POJ - 1251

#include<algorithm>
#include<cstring>
#include<vector>
#include<map>
#include<cmath>
#include<cstdio>
#include<queue>
#include<iostream>
typedef long long ll;
const int mod = 150;
const int maxn = 2500;
const int inf = 0x3f3f3f3f;
using namespace std;
int n,m;
int dis[maxn],road[maxn][maxn];
bool vis[maxn];
int prim()
{
    int mi, v,ans=0;
    for(int i = 0; i < n; i++)
    {
        dis[i] = road[0][i];
        vis[i] = false;
    }
	vis[0]=true;
    for(int i = 1; i < n; i++)//包括第一个点在内，一共要纳入n个点
    {
        mi = inf;
        for(int j = 0; j < n; j++)//每次找出未纳入顶点集与已知顶点集构成的权值最小的一条边
        {
            if(!vis[j] && mi > dis[j])
            {
                v = j;
                mi = dis[j];
            }
        }
		if(mi==inf) return -1;
		ans+=mi;
        vis[v] = true;//把该顶点纳入已知集合
        for(int j = 0; j < n; j++)//更新与未纳入集合中的顶点的边的最小权值
        {
            if(!vis[j] && dis[j] > road[v][j])
                dis[j] = road[v][j];
        }
    }
    return ans;
}
int main()
{
	while(scanf("%d",&n)){//道路 城镇
		if(n==0)break;
		for(int i=0;i<n;i++)
			for(int j=0;j<n;j++)
				road[i][j]=inf;
		for(int i=1;i<n;i++){
			char u,v;
			int w,x;
			cin>>u>>w;
			while(w--){
				cin>>v>>x;
				road[u-'A'][v-'A']=road[v-'A'][u-'A']=min(road[v-'A'][u-'A'],x);
			}
		}
		cout<<prim()<<endl;
	}
	return 0;
}

并查集
HDU - 1232

#include<algorithm>
#include<cstring>
#include<vector>
#include<map>
#include<cmath>
#include<cstdio>
#include<queue>
#include<iostream>
typedef long long ll;
const int mod = 150;
const int maxn = 2500;
const int inf = 0x3f3f3f3f;
using namespace std;
int n,m;
int pre[maxn];
bool vis[maxn];
int find(int x){
    int r=x;
    while(r!=pre[r])
        r=pre[r];
    int i=x,j;
    while(pre[i]!=r){
        j=pre[i];
        pre[i]=r;
        i=j;
    }
    return r;
}
void join(int x,int y){
    int fx=find(x),fy=find(y);
    if(fx!=fy)
        pre[fy]=fx;
}
int main()
{
    int n,m,a,b;
    while(scanf("%d%d",&n,&m)&&n){
        for(int i=1;i<=n;i++)
            pre[i]=i;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            join(a,b);
        }
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
            vis[find(i)]=1;
        int ans=0;
        for(int i=1;i<=n;i++){
            if(vis[i])
                ans++;
        }
        cout<<ans-1<<endl;
    }
	return 0;
}

bfs图
HDU - 1242

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<vector>
#include<cmath>
#include<algorithm>
#define maxn 300    
using namespace std;
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
char a[maxn][maxn];
int mp[maxn][maxn];
int n,m;
struct node{
    int x,y,step;
    friend bool operator<(node a,node b){
        return a.step>b.step;
    }
};
int bfs(int sx,int sy,int ex,int ey){
    node tx,ty;
    memset(mp,0,sizeof(mp));
    priority_queue<node>qu;
    while(!qu.empty()) qu.pop();
    tx.x=sx;tx.y=sy;tx.step=0;
    qu.push(tx);
    mp[sx][sy]=1;
    while(!qu.empty()){
        tx=qu.top();
        qu.pop();
        if(tx.x==ex&&tx.y==ey)
            return tx.step;
        for(int i=0;i<4;i++){
            ty.x=tx.x+dir[i][0];
            ty.y=tx.y+dir[i][1];
            ty.step=tx.step+1;
         if(a[ty.x][ty.y]!='#'&&ty.x>=0&&ty.x<n&&ty.y>=0&&ty.y<m&&!mp[ty.x][ty.y]){
            if(a[ty.x][ty.y]=='x'){
                ty.step++;
                mp[ty.x][ty.y]=1;
                qu.push(ty);
            }
            else{
                mp[ty.x][ty.y]=1;
                qu.push(ty);
            }
         }
    }
    }
    return -1;
}
int main()
{
    int ex,ey,sx,sy;
   while(scanf("%d%d",&n,&m)!=EOF){
       for(int i=0;i<n;i++){
           scanf("%s",&a[i]);
           for(int j=0;j<m;j++){
               if(a[i][j]=='a'){
                   ex=i;ey=j;
               }
               if(a[i][j]=='r'){
                   sx=i;sy=j;
               }
           }
       }
       int cnt=bfs(sx,sy,ex,ey);
       if(cnt!=-1)
        printf("%d\n",cnt);
        else
            printf("Poor ANGEL has to stay in the prison all his life.\n");
   }
	return 0;
}

这里链接两个图论板子
图论
dij的优化