POJ 3159 candies总结
此题使用BellmanFord算法效果不佳，POJ提示超时，下面有一个算法使用dijkstra算法速度较快
/*-------------------------------------------------------------------
* Purpose:
* POJ 3159 candies 做了一些优化
* Time:
* 2012年3月21日 9:27:16
* Author:
* 张彦升
-------------------------------------------------------------------*/
#include <iostream>
using namespace std;
const int INF = 0x3f3f3f3f;
const int V = 30001;
const int E = 150001;
int pnt[E],cost[E],nxt[E];
int e,head[V];
int dist[V];
bool vis[V];
int relax(int u,int v,int c)
{
if (dist[v] > dist[u] + c)
{
dist[v] = dist[u] + c;
return 1;
}
return 0;
}
void addedge(int u,int v,int c)
{
pnt[e] = v;
cost[e] = c;
nxt[e] = head[u];
head[u] = e++;
}
int SPFA(int src,int n)
{
int i;
for (i = 1;i <= n;i ++)
{
vis[i] = 0;
dist[i] = INF;
}
dist[src] = 0;
int Q[E],top = 1;
Q[0] = src;
vis[src] = true;
while (top)
{
int u,v;
u = Q[--top];
vis[u] = false;
for (i = head[u];i != -1;i = nxt[i])
{
v = pnt[i];
if (1 == relax(u,v,cost[i]) && !vis[v])
{
Q[top++] = v;
vis[v] = true;
}
}
}
return dist[n];
}
int main()
{
int n,m;
while (scanf("%d%d",&n,&m) != EOF)
{
int i,a,b,c;
e = 0;
memset(head,-1,sizeof(head));
for (i = 0;i < m;++i)
{
cin >> a >> b >> c;
addedge(a,b,c);
}
cout << SPFA(1,n) << endl;
}
return 0;
}
使用dijkstra算法实现
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
//邻接表+优先级队列+dijkstra
const int maxn=160000;
const int inf=(1<<27);
struct edge
{
int t,w;//s->t=w;
int next;//s->的下一个定点
};
int p[maxn];//表头结点 初值-1
edge G[maxn];//邻接表
int l;//邻接表 初值0
int V,E;//点数 边数
//添加边
void addedge(int u,int v,int w)
{
G[l].t=v;
G[l].w=w;
G[l].next=p[u];
p[u]=l++;
}
//计算从s0到其他点的最短距离
struct CNode
{
int k,w;//s0->k=w;
};
bool operator < ( const CNode & d1, const CNode & d2 ) {
return d1.w > d2.w; //priority_queue总是将最大的元素出列
}
priority_queue<CNode> q;
bool vis[maxn];
int dis[maxn];//s0到其他点的最短距离
CNode tmp;//temp
void priority_queue_dijkstra(int s0)
{
memset(vis,0,sizeof(vis));
memset(dis,-1,sizeof(dis));
tmp.k=s0,tmp.w=0;
q.push(tmp);
while(!q.empty())
{
tmp=q.top();q.pop();
if(vis[tmp.k]) continue;
vis[tmp.k]=true;
dis[tmp.k]=tmp.w;
for(int i=p[tmp.k];i!=-1;i=G[i].next)
{
CNode t;
t.k=G[i].t;
if(vis[t.k]) continue;
t.w=tmp.w+G[i].w;
q.push(t);
}
}
}
int main()
{
while(scanf("%d%d",&V,&E)==2)
{
memset(p,-1,sizeof(p));//important
l=0;//important
for(int i=0;i<E;i++)
{
int u,v,w;scanf("%d%d%d",&u,&v,&w);//从1开始
//u->v=w
addedge(u,v,w);
}
priority_queue_dijkstra(1);
printf("%d\n",dis[V - 2]);
}
return 0;
}
下面版本是由我写的，没有做任何优化
/*-------------------------------------------------------------------
* Purpose:
* Candies Bellman Ford
* 为了竞赛，必须适应不用类封装而使用全局数据
* Time:
* 2012年3月21日 18:46:30
* Author:
* 张彦升
-------------------------------------------------------------------*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
using namespace std;
/*我们需要顶点信息和边信息*/
struct Edge
{
int u;
int v;
int w;
Edge(int t_u,int t_v,int t_w)
:u(t_u),
v(t_v),
w(t_w)
{
return;
}
};
typedef vector<Edge> VecEdge;
typedef vector<int> VecInt;
class Candies
{
public:
/**
*
**/
Candies(int t_n,int t_m)
:n(t_n),
m(t_m),
dist(n,inf)
{
dist[0] = 0;
return;
}
/**
*
**/
~Candies()
{
return;
}
/**
* 添加一条新边
*/
int addedge(int u,int v,int w)
{
edge.push_back(Edge(u,v,w));
return 0;
}
/**
* bellman ford algorithm
*/
int bellman_ford()
{
/*对于每个节点松弛一次所有边*/
for (int i = 0;i < n;i ++)
{
relax_edge();
}
/*如果一切正常，返回到此点的最短路径*/
if (is_relax_ok() == true)
{
return 1;
}
return -1;
}
/**
* 返回路径
*/
int get_dis(int pos)
{
return dist[pos];
}
/**
* 松弛每条边
*/
int relax_edge()
{
VecEdge::iterator iter = edge.begin();
int ret = 1;
for (;iter != edge.end();++iter)
{
if (0 == relax(*iter))
{
ret = 0;
}
}
return ret;
}
/**
* 松弛改变
*/
int relax(Edge ed)
{
int v = ed.v - 1,u = ed.u - 1,w = ed.w;
if (dist[v] > dist[u] + w)
{
dist[v] = dist[u] + w;
return 1;
}
return 0;
}
/**
* 对负权回路进行检查
*/
bool is_relax_ok()
{
if (relax_edge() == 1)
{
return false;
}
return true;
}
protected:
VecEdge edge; /*记录所有的边信息*/
int n,m; /*n is kids number,m is cases number*/
VecInt dist;
static const int inf = 0x3f3f3f3f;
private:
};
/**
* 此题中我们不需要保存前点的信息
*/
int main()
{
/*n child and m cases*/
int n,m;
//fstream cin("data.txt",ios_base::in);
while (cin >> n >> m)
{
Candies candies(n,m);
int u,v,w; /*w = (u,v)*/
for (int i = 0;i < m;i++)
{
cin >> u >> v >> w;
candies.addedge(u,v,w);
}
/*加入所有边之后开始执行BellmanFord算法*/
/*计算得出结果*/
if (candies.bellman_ford() == -1)
{
cout << "此图存在错误" << endl;
}
cout << candies.get_dis(n - 1) << endl;
/*
for (int i = 0;i < n;i++)
{
cout << candies.get_dis(i) << endl;
}
*/
}
return 0;
}
上面的算法基本上都会出现TLE，使用栈要比队列好，具体为什么可能是测试数据的原因，使用队列的时候要对堆进行push_heap和pop_heap，这儿pop_heap实际上可以省略，那么将意味着效果更好，但是对SPFA优先队列无用，但此方案对Dijkstra有用，而此题目的意思是使用SPFA解决（因为其中有负边），虽然我写的Dijkstra算法也提交成功了，但我认为使用Dijkstra是不对的，使用map对查找最小值有一定的优化，或者我们应该考虑使用斐波那契堆，下面是对Dijkstra算法的一个优化版本
/**
* v_size表示节点的个数，src表示起始节点
*/
int dijkstra(int v_size,int src)
{
typedef pair<int,int> Node;
typedef multimap<int,int,less<int> > DijHeap;
DijHeap heap;
heap.insert(make_pair(0,src));
dis[src] = 0;
register int u,v,w,j;
Edge ed;
DijHeap::iterator iter,temp;
/*循环对没一个顶点访问*/
for (int i = 0; i < v_size;i++)
{
iter = heap.begin();
j = i;
while (j-- > 0)
{
++iter;
}
u = iter->second;
if (vis[u] == 1)
{
continue;
}
else
{
vis[u] = 1;
}
for (j = head[u];j != -1;j = ed.next)
{
ed = edge[j];
v = ed.v;
w = ed.w;
if (vis[v] == 0 && dis[v] > dis[u] + w)
{
dis[v] = dis[u] + w;
heap.insert(make_pair(dis[v],v));
}
}
}
return 0;
}
最后不得不提的是scanf的读取问题，scanf读取整数的时候速度会很慢，使用下面实现的读取整数的函数会极大提升程序执行速度
/**
* 读取一个int
*/
inline int read_int()
{
int ret=0;
char tmp;
while(!isdigit(tmp=getchar()));
do{
ret=(ret<<3)+(ret<<1)+tmp-'0';
}while(isdigit(tmp=getchar()));
return ret;
}
最终得如下程序，经测试，是POJ3159目前发现最快的一个程序47MS
/*-------------------------------------------------------------------
* Purpose:
* POJ 3159 candies 做了一些优化
* Time:
* 2012年3月21日 9:27:16
* Author:
* 张彦升
-------------------------------------------------------------------*/
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int V = 30001;
const int E = 150001;
int pnt[E],cost[E],nxt[E];
int e,head[V];
int dist[V];
bool vis[V];
int relax(int u,int v,int c)
{
if (dist[v] > dist[u] + c)
{
dist[v] = dist[u] + c;
return 1;
}
return 0;
}
/**
* 读取一个int
*/
inline int read_int()
{
int ret=0;
char tmp;
while(!isdigit(tmp=getchar()));
do{
ret=(ret<<3)+(ret<<1)+tmp-'0';
}while(isdigit(tmp=getchar()));
return ret;
}
void addedge(int u,int v,int c)
{
pnt[e] = v;
cost[e] = c;
nxt[e] = head[u];
head[u] = e++;
}
int SPFA(int src,int n)
{
int i;
for (i = 1;i <= n;i ++)
{
vis[i] = 0;
dist[i] = INF;
}
dist[src] = 0;
int Q[E],top = 1;
Q[0] = src;
vis[src] = true;
while (top)
{
int u,v;
u = Q[--top];
vis[u] = false;
for (i = head[u];i != -1;i = nxt[i])
{
v = pnt[i];
if (1 == relax(u,v,cost[i]) && !vis[v])
{
Q[top++] = v;
vis[v] = true;
}
}
}
return dist[n];
}
int main()
{
int n,m;
while (scanf("%d%d",&n,&m) != EOF)
{
int i,a,b,c;
e = 0;
memset(head,-1,sizeof(head));
for (i = 0;i < m;++i)
{
//cin >> a >> b >> c;
a = read_int();
b = read_int();
c = read_int();
addedge(a,b,c);
}
cout << SPFA(1,n) << endl;
}
return 0;
}