最短路题目整理 Poj 2387 + 3259 + 2502 + 1847

最新推荐文章于 2016-09-28 19:08:13 发布
最新推荐文章于 2016-09-28 19:08:13 发布
阅读量912 收藏
点赞数
分类专栏： 最小生成树最短路 文章标签： 最短路 次短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyorwhnt/article/details/9632755
版权

树形DP刷不动了，意识模糊。。总结一下以前做的题。

Poj 2387 Til the Cows Come Home

最短路水题，注意重边。

#pragma warning (disable: 4514 4786)
#include <cstdio>
#include <cstring> 
#include <algorithm> 
#include <queue>
using namespace std;

const int INF = 0x5fffffff;  //权值上限
const int MAXPT = 1002;       //顶点数上限
const int MAXEG = 2*2002;     //边数上限

//点存储1~n
template<typename Type>
class Dijkstra     /*邻接表 + 优先队列 + Dijkstra求最短路*/
{
private:
	int n,e;
    Type dis[MAXPT];
	int head[MAXPT];
    bool visit[MAXPT];

    struct Node
	{
		int v;
		Type dis;
        Node () {}
		Node (int _v,Type _dis)
		{
			v=_v;
			dis=_dis;
		}
		bool operator < (const Node a) const
		{
			return dis>a.dis;
		}
	};
	
	struct Edge
	{
		int v,next;
		Type w;
		Edge () {}
		Edge (int _v, int _next,Type _w)
		{
			v=_v;
			next=_next;
			w=_w;
		}
    }edges[MAXEG];

public:
    inline void init (int _n)
	{ 
        n = _n;
		e = 0; 
        memset(head,-1,sizeof(int) * (n+1));
    } 
  
    inline void Add (int u,int v,Type w)
	{ 
        edges[e] = Edge(v, head[u], w);
        head[u] = e++;
    } 
  
    void print ()
	{ 
        for (int i=1;i<=n;i++)
		{
            printf("%d: ", i); 
            for (int j=head[i]; j!=-1; j=edges[j].next)
                printf(" %d", edges[j].v);
			printf("\n");
        } 
    } 
  
    Type dijkstra (int src, int des)
	{ 
        Node first, next;
        priority_queue <Node> Q;
        for (int i=0;i<=n;i++)
		{ 
            dis[i] = INF; 
            visit[i] = false; 
        } 
  
        dis[src]=0;
        Q.push (Node(src, 0));
  
        while (!Q.empty())
		{ 
            first = Q.top(); 
            Q.pop(); 
            visit[first.v] = true;
  
            for (int i=head[first.v] ; i!=-1 ; i=edges[i].next)
			{ 
                if (visit[edges[i].v])
					continue;
                next = Node(edges[i].v, first.dis + edges[i].w);
                if (next.dis < dis[next.v])
				{ 
                    dis[next.v] = next.dis; 
                    Q.push(next); 
                } 
            } 
        }
        return dis[des]; 
    }
};

Dijkstra<int> ob;
  
int main ()
{
	int n,m;
    while (~scanf("%d%d",&m,&n))
	{
		ob.init(n);
		while (m--)
		{
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			ob.Add(u,v,w);
			ob.Add(v,u,w);
        }
		printf("%d\n",ob.dijkstra(1,n));
	}
	return 0; 
}


Poj 3259 Wormholes

SPFA判环

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int MAXPT = 505; 
const int MAXEG = 2505*2+300; 
const int INF = 0x3fffffff;
  
class SPFA
{
private:
	int n,e; 
    int dis[MAXPT],head[MAXPT];
	int cnt[MAXPT]; //cnt[i]>n则表示有负环
    bool visit[MAXPT];
	
    struct Edge
	{
		int v,w,next;
		Edge () {}
		Edge (int _v, int _next, int _w)
		{
			v=_v;
			next=_next;
			w=_w;
		}
    }edges[MAXEG];

public:
    void init (int vn)
	{ 
        n = vn;
		e = 0; 
        for (int i=0;i<=n;i++) 
		{
            head[i] = -1;
            visit[i] = false;
            dis[i] = INF;
			cnt[i] = 0;
        } 
    } 
  
    inline void Add (int u, int v, int w)
	{ 
        edges[e] = Edge(v,head[u],w);
        head[u] = e++;
    } 

    bool spfa (int src, int des)
	{ 
        queue<int> que; 
        dis[src] = 0; 
        que.push(src); 
        visit[src] = true; 
        while (!que.empty())
		{ 
            int u = que.front(); 
            que.pop(); 
            visit[u] = false; 
            for (int i = head[u]; i != -1; i = edges[i].next)
			{ 
                int v = edges[i].v;
				if (dis[v] == INF || dis[u]+edges[i].w < dis[v])
				{
					dis[v]=dis[u]+edges[i].w;
					cnt[u]++;
					if (cnt[u]>=n)
						return true;  //负环
					if (visit[v]==false)
					{
						visit[v] = true;
						que.push(v);
					}
				}
			}
        }
        return false;  //没有负环
    }
}ob; 
  
int main ()
{ 
#ifdef ONLINE_JUDGE
#else
	freopen("read.txt","r",stdin);
#endif
    int T;
    scanf("%d",&T);
    for (int Cas=1;Cas<=T;Cas++)
    {
		int n,m,w,i;
		scanf("%d%d%d",&n,&m,&w);
        ob.init(n);
        int a, b, c;
		for (i=0;i<m;i++)
		{
            scanf("%d%d%d",&a,&b,&c);
            ob.Add(a,b,c);
            ob.Add(b,a,c);
        }
		for (i=0;i<w;i++)
		{
            scanf("%d%d%d",&a,&b,&c);
			c*=-1;
            ob.Add(a,b,c);
        }
		if (ob.spfa(1,n))
			printf("YES\n");
		else
			printf("NO\n");
    } 
    return 0; 
}

Poj 2502 Subway

题意：在一个城市里，分布着若干条地铁线路，每条地铁线路有若干个站点，所有地铁的速度均为40km/h。现在你知道了出发地和终点的坐标，以及这些地铁线路每个站点的坐标，你的步行速度为10km/h，且你到了地铁的任意一个站之后就刚好有地铁出发。问你从出发点到终点最少需要多少时间。

思路：建图：把起点，终点，以及每个地铁站作为一个图的所有顶点，所有顶点i和j两两之间，均有边权为w = dis / 10 (km/h) 的边相连，任意地铁线路的任意两个相邻的站点，均有边权为 w = dis / 40 (km/h)的边相连。


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

const double INF = 1e10;  //权值上限
const int MAXPT = 210;       //顶点数上限

typedef pair <double,int> ele;

class Dijkstra     /*邻接矩阵 + 优先队列 + Dijkstra求最短路*/
{
private:
	double map[MAXPT][MAXPT];
	bool vis[MAXPT];
	double dis[MAXPT];
	int n;

public:

	void init (int num)
	{
		n=num;
		for (int i=0;i<=n;i++)
			for (int j=0;j<=n;j++)
			{
				if (i==j)
					map[i][j]=0;
				else
					map[i][j] = INF;
			}
//		memset (dis,0,sizeof(dis));
		memset (vis,false,sizeof(vis));
	}

	void Add (int u,int v,double w)
	{
		if (w<map[u][v])
			map[u][v]=w;
	}

	double dijkstra (int src,int end)
	{
		int i;
		for (i=0;i<=n;i++)
			dis[i] = INF;
		dis[src] = 0;
		priority_queue < ele,vector<ele>,greater<ele> >q;  //优先队列：小顶堆
		q.push (make_pair(dis[src],src));
		
		while ( !q.empty() )
		{
			ele t = q.top();
			q.pop();
			int now = t.second;
			if ( vis[now] )
				continue;
			vis[now] = true;
			for (i=1; i<=n; i++)
				if (vis[i]=false && map[now][i]<INF && dis[i] > dis[now]+map[now][i])
				{
					dis[i] = dis[now]+map[now][i];
					q.push(make_pair(dis[i],i));
				}
		}
		return dis[end];
	}
}ob;

int x[MAXPT],y[MAXPT],visit[MAXPT][MAXPT];

int main ()
{
	scanf("%d%d%d%d",&x[1],&y[1],&x[2],&y[2]);
	ob.init (205);
	int n=3,m=3,u,v;
	double d;
	memset(visit,0,sizeof(visit));
	while (~scanf("%d%d",&u,&v))
	{
		if (u==-1 && v==-1)
		{
			m=n;
			continue;
		}
		x[n]=u,y[n]=v;
		if (n!=m)
        {
			visit[n-1][n]=1;
			visit[n][n-1]=1;
			d=sqrt(1.0*(x[n]-x[n-1])*(x[n]-x[n-1])+(y[n]-y[n-1])*(y[n]-y[n-1]))/40000.0;
			ob.Add (n-1,n,d);
			ob.Add (n,n-1,d);
		}
		n++;
	}
	for (int i=1;i<n;i++)
		for (int j=i+1;j<n;j++)
			if (visit[i][j] == 0)
			{
				d=sqrt(1.0*(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]))/10000.0;
				ob.Add (i,j,d);
				ob.Add (j,i,d);
            }

	printf("%lf\n",ob.dijkstra(1,2));
	return 0;
}

Poj 1847 Tram

题意参见：http://blog.csdn.net/zhang20072844/article/details/7761273

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

const int INF = 0x5fffffff;  //权值上限  
const int MAXPT = 102;       //顶点数上限  
const int MAXEG = 20002;     //边数上限  

class Dijkstra     /*邻接表 + 优先队列 + Dijkstra求最短路*/  
{  
private:  
    int n,e;  
    int dis[MAXPT], head[MAXPT];  
    int visit[MAXPT];  
  
    struct Node  
    {  
        int v,dis;  
        Node () {}  
        Node (int _v,int _dis)  
        {  
            v=_v;  
            dis=_dis;  
        }  
        bool operator < (const Node a) const  
        {  
            return dis>a.dis;  
        }  
    };  
      
    struct Edge  
    {  
        int v, w, next;  
        Edge () {}  
        Edge (int _v, int _next, int _w)  
        {  
            v=_v;  
            next=_next;  
            w=_w;  
        }  
    }edges[MAXEG];  
  
public:  
    inline void init (int vx)  
    {   
        n = vx;  
        e = 0;   
        memset(head,-1,sizeof(int) * (vx + 1));  
    }   
    
    inline void Add (int u, int v, int w)  
    {   
        edges[e] = Edge(v, head[u], w);  
        head[u] = e++;  
    }   
    
    void print ()  
    {   
        for (int i=1;i<=n;i++)  
        {   
            printf("%d: ", i);   
            for (int j=head[i]; j!=-1; j=edges[j].next)  
                printf(" %d", edges[j].v);  
            printf("\n");  
        }   
    }   
    
    int dijkstra (int src, int des)  
    {   
        Node first, next;  
        priority_queue <Node> Q;  
        for (int i=0;i<=n;i++)  
        {   
            dis[i] = INF;   
            visit[i] = false;   
        }   
    
        dis[src]=0;   
        Q.push (Node(src, 0));  
    
        while (!Q.empty())  
        {   
            first = Q.top();   
            Q.pop();   
            visit[first.v] = true;  
    
            for (int i=head[first.v] ; i!=-1 ; i=edges[i].next)  
            {   
                if (visit[edges[i].v])  
                    continue;   
                next = Node(edges[i].v, first.dis + edges[i].w);  
                if (next.dis < dis[next.v])  
                {   
                    dis[next.v] = next.dis;   
                    Q.push(next);   
                }   
            }   
        }  
        return dis[des];   
    }  
}ob;

int main ()  
{  
    int n,s,e;  
    while (~scanf("%d%d%d",&n,&s,&e))
    {  
        ob.init(n);  
        for (int i=1;i<=n;i++)
		{
			int a,b;
			scanf("%d",&a);
			for (int j=0;j<a;j++)
			{
				scanf("%d",&b);
				if (j == 0)
					ob.Add(i,b,0);
				else
					ob.Add(i,b,1);
            }  
        }
		int ans=ob.dijkstra(s,e);
		if (ans!=INF)
			printf("%d\n",ans);
		else
			printf("-1\n");
    }  
    return 0;   
}


时雨晴天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj 800+ 题目源代码，多年做题积累
08-01
poj 800+ 题目源代码，多年做题积累 包含各种类型经典题目
POJ2387—水题+变态的题
飞翔的小鸟
08-11 775
这个题目很变态，数据范围题目给错了，是远大于100，而且还有重边，即两个顶点有多条边连接，当权值不一样，只要取最小的那个就可以了，注意这几点就很容易AC了。   #include #include #include using namespace std; const int maxn=1002; const int inf=100000000; bool visit[max
ACM POJ 题目分类（完整整理版本）
兔清风的博客
09-28 3554
DP:  1011   NTA                 简单题  1013   Great Equipment     简单题  1024   Calendar Game       简单题  1027   Human Gene Functions   简单题  1037   Gridland            简单题  1052   Algernon s Noxi
POJ2387 最短路入门题 [spfa,dijstra+heap]
Aszxqw
08-25 1819
思路： 最短路入门题。 很久前做的题目，今天重写了一下，算是复习了一下最短路，整理一下spfa代码模板和dijstra+heap的代码。 SPFA:32ms #include #include #include #include #include #define llong long long #define Abs(a) ((a)>0?(a):-(a)) #define Mod(a,
（置顶）POJ题目分类
LzyRapX
05-03 1819
OJ上的一些水题(可用来练手和增加自信)  (poj3299,poj2159,poj2739,poj1083,poj2262,poj1503,poj3006,poj2255,poj3094)  http://www.cnblogs.com/kuangbin/archive/2011/07/29/2120667.html   (kuangbin的分类) 初期:  一.基本算法:
北大POJ初级-所有题目AC代码+解题报告
07-31
北大POJ初级-所有题目AC代码+解题报告
POJ1207-The 3n + 1 problem
07-29
北大POJ1207-The 3n + 1 problem 解题报告+AC代码
博客园stdc++.h头文件源码
04-26
注意，目前POJ还不支持<bits/stdc++.h>（G++、C++都不支持）。HDU部分支持（G++支持，C++不支持）。 其他国外的oj，还有台湾的oj都支持，CF，Topcoder也都支持。 当然，其实这是一个偷懒的写法，但是会降低编译...
万能头文件stdc++.h
04-26
注意，目前POJ还不支持<bits/stdc++.h>（G++、C++都不支持）。HDU部分支持（G++支持，C++不支持）。 其他国外的oj，还有台湾的oj都支持，CF，Topcoder也都支持。 当然，其实这是一个偷懒的写法，但是会降低编译...
Poj 1679 The Unique MST (最小生成树唯一性判定)
whyorwhnt的专栏
03-08 3580
题目链接：http://poj.org/problem?id=1679 题意：给定的图是否具有唯一的最小生成树。 思路：看到网上的代码都是用次小生成树解的，但其实不用那么麻烦。 利用Prim算法求最小生成树，选择最小边时进行判断：是否有两个或以上的未选择顶点到已选顶点集合的权值相等的，若有则最小生成树不唯一。同时在松弛计算的时候也要 对刚加进的顶点进行权值是否相等的判断。 #in
Poj 1094 Sorting It All Out (传递闭包+拓扑排序)
whyorwhnt的专栏
09-10 2104
题意：给你一些大写字母间的大小排序关系，判断以下3中情况：1 能唯一确定它们的排列顺序，2 所给关系是矛盾的，3 到最后也不能确定它们之间的关系。 思路：出现矛盾也就是在比较大小关系的过程中出现环，可以通过Floyd算法求传递闭包来判环。 如果没有环且每个点的出度+入度==n-1，则表明字母之间两两关系确定，构成唯一的一个序列，存在答案，否则不存在。 当答案存在时，利用拓扑排序确定各点顺序。
Poj 1635 Subway tree systems （树的最小表示）
whyorwhnt的专栏
07-17 1750
题目链接：http://poj.org/problem?id=1635 题意：初始时站在树的根节点，若朝着远离根的方向走，记录“0”，接近根的方向走记录“1”。并且树的每一条边只能来回走一次（即向下和返回）。一个合法的01序列可以描述出一棵树的形态。现在给出两个合法的01序列，判断两棵树是否同构。 思路主要参考了这里：http://blog.csdn.net/tiaotiaoyly/artic
Poj 1860 Currency Exchange + Poj 2240 Arbitrage （货币兑换问题+最短路）
whyorwhnt的专栏
07-18 1228
Poj 上两道典型的货币兑换问题，放在一起总结下 Poj 1860 Currency Exchange 题目链接：http://poj.org/problem?id=1860 题意：有多种汇币，汇币之间可以交换，这需要手续费。例如：当你用100A币交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到(100 - 0.39) * 29.75 = 2963.3975 B币。
Poj 3268 Silver Cow Party + Poj 1511 Invitation Cards （最短路反向建图）
whyorwhnt的专栏
07-18 1188
Poj 3268 Silver Cow Party 题意：牛要去特定的牧场开舞会..其中要求去的路以及回来的最短路的和是最大的 思路：第一次利用dijstra求出从X到各点的最短距离,即为回来时的最短路。 然后所有的边反向，再进行一次dijstra求X到各点的最短路径。 第二次求出的最短路径也就是各点到X的最短路径，因为边已经反向，对于第二次从X到各点的最短路径正是 原图从各点到X的
Hdu 4013 Distinct Subtrees (状态压缩枚举+树的最小表示)
whyorwhnt的专栏
07-17 1102
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4013 题意：一棵由无向边构成的树，求出它的不同的子树的数目。 思路：枚举每个点集，DFS求最小表示。对于某一种情况，若有一次得到的表示以前没有，答案加1。 代码中有一大段被注释掉的部分，那是我最开始的想法，会出现同一棵子树因树根不同而重复记录的情况 。 如果一个点集构成森林，由于遍历了所有
Poj 2253 + 1797 + 1502 最短路的最小最大值问题
whyorwhnt的专栏
07-18 1090
Poj 2253 Frogger 题目链接：http://poj.org/problem?id=2253 题意：给出两只青蛙的坐标A、B，和其他的n-2个坐标，求从起点到终点的所有路中最大边权的最小值 思路：Floyd变形:map[j][k]=min(map[j][k],max(map[j][i],map[i][k])); #include #include
Hdu 2544 最短路 (Dijkstra+SPFA+Floyd模板)
whyorwhnt的专栏
03-09 1052
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2544 最短路模板题。 Dijkstra #include #include #include #include using namespace std; const int INF = 0x5fffffff; //权值上限 const int MAXPT = 102;
Poj 3660 Cow Contest (传递闭包 Floyd算法变形)
whyorwhnt的专栏
07-05 1035
题目链接：http://poj.org/problem?id=3660 题意：有n头牛比赛，m种比赛结果，最后问你一共有多少头牛的排名被确定了，其中如果a战胜b，b战胜c，则也可以说a战胜c，即可以传递胜负。求能确定排名的牛的数目。 思路：Floyd算法变形，关于传递闭包网上没有搜到能看懂的资料……不过大致可以理解是什么意思。感觉思路很巧妙。 解法完全参照了：http://www.cnb
poj 1125 最短路
最新发布
06-02
好的，请稍等，我为您提供poj 1125 最短路的解法和代码。 题目描述 在一个n个点的有向图中，每个点有一个编号(1编号)，每条边有一个长度。现在给定一个起点s，要求计算出从s出发到每个点的最短路。若两点间没有路...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值