最短路模板BF和SPFA，poj3259测

分别用BF和SPFA处理带负权图，自己写的模板，哎也WA 了N多次呀，测试题目是poj3259

Bellman-ford：

#include <iostream>
#include <cstdio>
#include <cstring>
#define MAX 1<<28
using namespace std;
const int maxn=7010;
int N,M,W;
int dis[maxn];
int edgenum;
struct Edge{
	int st,ed;
	int val;
}edge[maxn];

void addedge(int st,int en,int w)
{
	edgenum++;
	edge[edgenum].st=st;
	edge[edgenum].ed=en;
	edge[edgenum].val=w;
}

bool bellman_Ford(int start)
{
	memset(dis,MAX,sizeof(dis));

	dis[start]=0;
	for(int i=1;i<N;i++)
		{
			for(int j=1;j<=edgenum;j++)
			{
				int st=edge[j].st;
				int en=edge[j].ed;
				int w=edge[j].val;
				if(dis[en]>dis[st]+w)
					dis[en]=dis[st]+w;
			}
		}
		//判断是否存在负环


			for(int j=1;j<edgenum;j++)
			{
				if(dis[edge[j].ed]>dis[edge[j].st]+edge[j].val)
				{
					return true;
				}
			}
		return false;
}
int main() {
	int NUM;
	scanf("%d",&NUM);
	while(NUM--)
	{
		scanf("%d%d%d",&N,&M,&W);
		edgenum=0;
		for(int i=1;i<=M;i++)
		{
			int a,b,v;
			scanf("%d%d%d",&a,&b,&v);
			addedge(a,b,v);
			addedge(b,a,v);
		}
		for(int i=1;i<=W;i++)
		{
			int a,b,v;
			scanf("%d%d%d",&a,&b,&v);
			addedge(a,b,-v);
		}
		if(bellman_Ford(1))
			printf("YES\n");
		else
			printf("NO\n");


	}

	return 0;
}

BF（java）：

import java.util.Arrays;
import java.util.Scanner;


public class Main {
	static int maxn=7010;
	static int dis[]=new int[maxn];
	static int Max=10000000;
	static int node;
	class Edge
	{
		int st,ed;
		int val;
		Edge(int st,int ed,int val)
		{
			this.st=st;
			this.ed=ed;
			this.val=val;
		}
	}
	
	 Edge data[]=new Edge[maxn];
	static int edgenum;
	void addedge(int st,int ed,int val)
	{
		edgenum++;
		data[edgenum]=new Edge(st,ed,val);
		
	}
	
	boolean bellman_ford(int start)
	{
		Arrays.fill(dis, Max);
		dis[start]=0;
		for(int i=1;i<node;i++)
			for(int j=1;j<=edgenum;j++)
			{
				if(dis[data[j].ed]>dis[data[j].st]+data[j].val)
					dis[data[j].ed]=dis[data[j].st]+data[j].val;
			}
		for(int j=1;j<edgenum;j++)
			if(dis[data[j].ed]>dis[data[j].st]+data[j].val)
				return false;
		
		return true;
	}
	
	 void run()
	{
		Scanner in=new Scanner(System.in);
		int casenum=in.nextInt();
		while(casenum--!=0)
		{
			node=in.nextInt();
			int M=in.nextInt();
			int W=in.nextInt();
			edgenum=0;
			for(int i=1;i<=M;i++)
			{
				int a=in.nextInt();
				int b=in.nextInt();
				int val=in.nextInt();
				addedge(a,b,val);
				addedge(b,a,val);
			}
			for(int i=1;i<=W;i++)
			{
				int a=in.nextInt();
				int b=in.nextInt();
				int val=in.nextInt();
				addedge(a,b,-val);
			}
			if(bellman_ford(1))
				System.out.println("NO");
			else
				System.out.println("YES");
		}
	}
	public static void main(String[] args) {
		new Main().run();
	}
}

SPFA

//============================================================================
// Name        : SPFA.cpp
// Author      : xinge
// Version     :矩阵存图
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <set>
#define MAX 1<<28;
using namespace std;
const int maxn=1010;
int map[maxn][maxn];
int dis[maxn];
int cnt[maxn];
bool used[maxn];
int node;
void init()
{
	for(int i=0;i<maxn;i++)
	{
		dis[i]=MAX;
		used[i]=false;
		cnt[i]=0;
		for(int j=0;j<maxn;j++)
			map[i][j]=MAX;
		map[i][i]=0;

	}

}

bool SPFA(int start)
{
	cnt[start]++;
	used[start]=true;
	dis[start]=0;
	queue<int> q;
	q.push(start);
	int cur;
	while(!q.empty())
	{
		cur=q.front();
		q.pop();
		used[cur]=false;
		for(int i=1;i<=node;i++)
		{
			if(map[cur][i]&&dis[i]>dis[cur]+map[cur][i])
			{
				dis[i]=dis[cur]+map[cur][i];
				if(!used[i])
				{
					cnt[i]++;
					used[i]=true;
					q.push(i);
					if(cnt[i]>node)
						return false;
				}


			}


		}


	}

	return true;
}


int main() {
	int T,M,W;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d%d",&node,&M,&W);
		init();
		for(int i=1;i<=M;i++)
		{
			int a,b,v;
			scanf("%d%d%d",&a,&b,&v);
			if(map[a][b]>v)
				map[a][b]=map[b][a]=v;
		}
		for(int i=1;i<=W;i++)
				{
					int a,b,v;
					scanf("%d%d%d",&a,&b,&v);
					if(map[a][b]>-v)
						map[a][b]=-v;
				}
		if(SPFA(1))
		{
			printf("NO\n");
		}else
			printf("YES\n");

	}
	return 0;
}

SPFA  java

import java.util.ArrayList;
import java.util.Scanner;

public class Main{
	static int MAX=1<<29;
	static int map[][]=new int[1010][1010];
	static int node;
	static int dis[]=new int[1010];
	static boolean used[]=new boolean[1010];
	static int cnt[]=new int[1010];
	
	static void init()
	{
		for(int i=0;i<1010;i++)
		{
			dis[i]=MAX;
			used[i]=false;
			cnt[i]=0;
			for(int j=0;j<1010;j++)
				map[i][j]=MAX;
			map[i][i]=0;
		}
	}
	
	static boolean relax(int a,int b,int c)
	{
		if(dis[b]>dis[a]+c)
		{
			return true;
		}
		
		return false;
	}
	
	static boolean SPFA(int start)
	{
		used[start]=true;
		cnt[start]++;
		dis[start]=0;
		ArrayList<Integer>lis=new ArrayList<Integer>();
		lis.add(start);
		int cur;
		while(!lis.isEmpty())
		{
			cur=lis.remove(0);
			used[cur]=false;
			for(int i=1;i<=node;i++)
			{
				if(map[cur][i]!=0&&relax(cur,i,map[cur][i]))
				{
					dis[i]=dis[cur]+map[cur][i];
					if(!used[i])
					{
						used[i]=true;
						lis.add(i);
						cnt[i]++;
						if(cnt[i]>node)
							return false;
					}
				}
			}
		}
		return true;
	}
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int casenum=in.nextInt();
		while(casenum--!=0)
		{
			node=in.nextInt();
			int M=in.nextInt();
			int W=in.nextInt();
			init();
			for(int i=1;i<=M;i++)
			{
				int a=in.nextInt();
				int b=in.nextInt();
				int val=in.nextInt();
				if(map[a][b]>val)
			map[a][b]=map[b][a]=val;
			}
			for(int i=1;i<=W;i++)
			{
				int a=in.nextInt();
				int b=in.nextInt();
				int val=in.nextInt();
				if(map[a][b]>-val)
				map[a][b]=-val;
			}
			if(SPFA(1))
				System.out.println("NO");
			else
				System.out.println("YES");
		}
	}

}