spfa算法

1.spfa算法可以很好的替代“地接斯科拉”算法。（虽然很相似，都是求出到每个点的最大值）
简单粗暴！！！ 

2.用队列进行调用，首先将点x出队，如果f[x]（到点x的最小值）+边权值 可以更小，则该点入队，一直循环

以下为正常spfa（标准）打法：

#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;


struct node
{
	int y,data;
};


const int maxSize=10000,maxValue=0x7fffffff;
vector <node> f[maxSize+5];
queue <int> q;
int n,m,a[maxSize+5],s,t,lj[maxSize+5];


void spfa()
{
	int i,x;
	
	q.push(s);
	while (!q.empty())
	{
		x=q.front();
		q.pop();
		for (i=0;i<f[x].size();i++)		//向量下标从0开始，大小为size 
		{
			if (a[f[x][i].y]>a[x]+f[x][i].data)
			{
				a[f[x][i].y]=a[x]+f[x][i].data;
                                lj[f[x][i].y]=x;//记录路径（通过记录前驱！！！）
                               q.push(f[x][i].y);
			}
		}
		
	}
	cout<<a[t]<<endl;
	while (t!=s)
	{
		cout<<t<<" ";
		t=lj[t];
	}
	cout<<s<<endl;
	
	return ;
}




int main()
{
	int i,x,y,d;
	node n1;
	
	ifstream cin("a.txt");
	cin>>n>>m;
	cin>>s>>t;
	
	for (i=0;i<m;i++)
	{
		cin>>x>>y>>d;
		n1.y=y;		n1.data=d;
		f[x].push_back(n1);
		
//		cout<<f[x][0].y<<" "<<f[x][0].data<<endl;
		
	}
	for (i=2;i<=n;i++)
		a[i]=maxValue;
		
	spfa();
	
	
	return 0;
}

题目来啦：http://www.gdfzoj.com/oj/code/87033

此题看似与spfa无关，但是看看范围觉得spfa能做，也可以直观说明：

图论题都可以试试spfa（说不定就ac了呢！！！orz）

PS：由于此题的边集很规律而且范围不大，可以用三维边集存（二维点，一维方向）

代码coming：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

struct node
{
	int x,y;
};

const int maxSize=500,maxValue=1000;
char c[maxSize+5][maxSize+5];
int fx[4][2]={{-1,0},{0,1},{0,-1},{1,0}};
int ex,ey,sx,sy,n,m,t=0;
int edge[maxSize+5][maxSize+5][4];//将矩阵上下左右相邻的点用边连，权值为 0or1 
//直接开三维，即记录每个点四个方向的权值 
int dis[maxSize+5][maxSize+5];//spfa记录到每个点的距离 
 
queue <node> q;

void spfa(int x,int y)//spfa算法
{
	int i;
	node n1,q1,p;
	
	n1.x=x;	n1.y=y;	q.push(n1);
	while (!q.empty())
	{
		q1=q.front();		q.pop();
		for (i=0;i<4;i++)
		{
			p.x=q1.x+fx[i][0];
			p.y=q1.y+fx[i][1];
			if (p.x<0||p.x==n||p.y<0||p.y==n)
				continue;
			if (dis[p.x][p.y]>dis[q1.x][q1.y]+edge[q1.x][q1.y][i])
			{
				dis[p.x][p.y]=dis[q1.x][q1.y]+edge[q1.x][q1.y][i];
				q.push(p);
			}
		}
	}
	printf("%d\n",dis[ex][ey]);
}

int main()
{
    int i,j,i1,j1,k;
    node n1;
   
    freopen("a.txt","r",stdin);
    while (scanf("%d%d",&n,&m))
    {
        if (n==0)
            break;
        memset(edge,0,sizeof(edge));
        for (i=0;i<n;i++)
            scanf("%s",&c[i]);
        for (i=0;i<n;i++)
        {
            for (j=0;j<m;j++)
            {
            	for (k=0;k<4;k++)
            	{
            		i1=i+fx[k][0];	j1=j+fx[k][1];
	                if (i1<0||i1==n||j1<0||j1==m)
	                	continue;
	                if (c[i][j]!=c[i1][j1])//如果相邻两点不同新建一条权为1的边
	                {                       //相同需新建权为0的边，此处略
	                	edge[i][j][k]=1;
	                	edge[i1][j1][3-k]=1;
	                }
            	}
            	dis[i][j]=maxValue;//初始值 
            }
        }
        scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
        dis[sx][sy]=0;
        spfa(sx,sy);
    }
    
    return 0;
}

对于spfa求出的最短路径的存储及处理：

用一个prepoint向量！！！

prepoint[i]记录i的最短路的前驱（遇到多条最短路也不方）

最后用个dfs搜一遍处理即可（是不是很妙？！orz）

题目：http://www.gdfzoj.com/oj/contest/150/problems/5

代码coming（一次就ac 高兴~~~）

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

const int maxSize=100000,maxValue=0x7fffffff;
vector <int> M[maxSize+5];
vector <int> prepoint[maxSize+5];//记录每个点前驱（多个） 
queue <int> q;
int disr[maxSize+5],dis[maxSize+5];//disr预处理r到每个点的距离，dis算s->e最短路 
int ans[maxSize+5];//ans[i]记录终点到i点的答案最小值 
int s,e,r,t,n,m;

void dfsr(int x)//prepoint处理完后的dfs
{
	int i,y;
	
	for (i=0;i<prepoint[x].size();i++)
	{
		y=prepoint[x][i];
		if (ans[y]==maxValue)//还没赋值，直接赋min值
			ans[y]=min(ans[x],disr[y]);
		else//赋了值，与原ans[y]对应的最短路不同-->max
			ans[y]=max(ans[y],min(ans[x],disr[y]));
		dfsr(y);
	}
}

void spfa()//先预处理每个点到R的最短距离
{
	int i,x,y;
	
	while (!q.empty())
	{
		x=q.front();	q.pop();
		for (i=0;i<M[x].size();i++)
		{
			y=M[x][i];
			if (disr[y]>disr[x]+1)
			{
				disr[y]=disr[x]+1;
				q.push(y);
			}
		}
	}
}
void spfa1()//搜 起点->终点的最短路，用prepoint存储路径
{
	int i,x,y;
	
	while (!q.empty())
	{
		x=q.front();	q.pop();
		for (i=0;i<M[x].size();i++)
		{
			y=M[x][i];
			if (dis[y]>dis[x]+1)
			{
				dis[y]=dis[x]+1;
				prepoint[y].clear();//更新前的前驱不是最短路前驱---清 
				prepoint[y].push_back(x);//加入正确前驱 
				q.push(y);
			}
			else if (dis[y]==dis[x]+1)
				prepoint[y].push_back(x);//多个最短路的前驱同进 
		}
	}
	ans[e]=disr[e];
	dfsr(e);//从终点深搜到r最大的最小的点 
	printf("%d",ans[s]);
}


int main()
{
	int i,x,y;
	
	freopen("a.txt","r",stdin);
	scanf("%d%d",&n,&m);
	
	for (i=0;i<m;i++)
	{
		scanf("%d%d",&x,&y);
		M[x].push_back(y);
		M[y].push_back(x);
	}
	scanf("%d%d%d",&s,&e,&r);
	for (i=1;i<=n;i++)
	{
		dis[i]=maxValue;
		disr[i]=maxValue;
		ans[i]=maxValue;
	}
	disr[r]=0;
	q.push(r);
	spfa();
	
	dis[s]=0;
	q.push(s);
	spfa1();
	
	return 0;
}