练习07：最短路劲（进阶）

Dijkstra 进阶：

Dijkstra 算法维护一条路上某条边的最大或者最小问题。

Heavy Transportation 最短路径算法维护路径上最小的边。好像还可以用生成树写。

Frogger 最短路劲维护路径上最大的边。

昂贵的聘礼  懂了前面两个，这个可以一遍A（我关系没想清楚，交了两次才过....）

前面两题基本差不多，就是大于几个符号的区别，弄懂后，另外一题差不多秒A。

第三个也可以用最短路劲写（就是钱，每个商品看成点，价格看成权值，就变成最短路劲问题了，不过最后需要检查所有的商品查找最小的价格），但是麻烦的是怎么维护关系，嘿嘿，简单。在维护一个dist的同时。我们还维护一个二维数组，表示到这个点路上交易过商品的最小级别和最高级别吗，如果一个新的商品不满足abs(当前最小级别-下个商品的最高级别） 那就pass.不能交易。

   维路径上边最小的边，让这边最大：
   模本的dist是记录到起点的距离，现在我们改下，记录经过所有边最小的那条（因为最小会直接影响后面的边）。同时我们的优先队列也需要更改，把原来的大于号变成小于号，我们要尽可能的大。

struct cmp{ //维护最大的那条边 
	bool operator()(struct heap a,struct heap b)
	{
		return a.weight<b.weight;
	}
};

如何判断边是否需要，和原来的有一点区别。当我们出队一条边（当前最优的边），顺带还有个点（当前已经走到的最优点），接下来我们还是枚举最优点连接的所有边（我们简称下条边）。

模板的判断语句是，如果当前的边的距离+下条边的距离小于 目前下个点的距离（注意不是边，不懂请转Dijkstra基础）

dist 记录的是起点到各个点的最优距离

if(min+edge[i].dis<dist[edge[i].to])
            {
				dist[edge[i].to]=min+edge[i].dis;
				if(vis[edge[i].to]) //已经确定了最优点了 
				continue;
				h.data=edge[i].to; //点 
				h.weight=dist[edge[i].to];
				q.push(h);
			}

现在我们的dist 记录的是起点到各个点路径上的最小边。如果现在的最优边和下条边都大于dist[u](起点到下个点的最优距离)

那么我们就更新，并且更新为最优边和下条边里面最小的（因为我们就是需要维护最小的边，让最小的边竟可能的大）。

所以判断条件为：

            if(edge[i].dis>dist[edge[i].to]&&mmax>dist[edge[i].to])
			{
				dist[edge[i].to]=min(mmax,edge[i].dis);  //选择最小的那条
				if(vis[edge[i].to])  //下面就是模板的更新
					continue;
				h.data=edge[i].to;
				h.weight=dist[edge[i].to];
				q.push(h);
			}

PS：初始化注意，dist 初始化为0，起点到起点的距离我们设为极大值。

Heavy Transportation AC代码：

另外题，同理一遍A。、
 

#include<stdio.h>
#include<string.h>
#include<string>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#define Max 1000010
#define min(a,b) a>b?b:a;
#define max(a,b) a>b?a:b;
#define inf 0x3f3f3f3f
using namespace std;
bool vis[Max];
int dist[Max];
int max_num;  //ans
struct Node{
	int next;
	int to;
	int dis;
}edge[20000000];  //边数 需要开大点
int num_edge;
int head[Max];
void add_edge(int x,int y,int w)
{
	edge[++num_edge].next=head[x];
	edge[num_edge].to=y;
	edge[num_edge].dis=w;
	head[x]=num_edge;
}
struct heap{
	int data;
	int weight;
};
struct cmp{ //维护最大的那条边 
	bool operator()(struct heap a,struct heap b)
	{
		return a.weight<b.weight;
	}
};
priority_queue <struct heap,vector<heap>, cmp> q;
void dijkstra(int num)
{
	dist[num]=inf;  //到自己默认为最大
	while(q.size()) q.pop();
	struct heap h;
	h.data=num;
	h.weight=inf; //因为最小的会影响 
	q.push(h);
	while(q.size())
	{
		int mmax=inf,u=-1;
		h=q.top();
		q.pop();
		mmax=h.weight;
		u=h.data;
		if(vis[u])
			continue;
		vis[u]=true;
		for(int i=head[u];i;i=edge[i].next)
		{
            // 如果当前最优的边和下条边都大于到当前点的维护的distd的值，就更新
			if(edge[i].dis>dist[edge[i].to]&&mmax>dist[edge[i].to])
			{
				dist[edge[i].to]=min(mmax,edge[i].dis); //更新为最小的
				if(vis[edge[i].to])
					continue;
				h.data=edge[i].to;
				h.weight=dist[edge[i].to];
				q.push(h);
			}
		}
	 }
}
int main()
{
	int t,n,m,x,y,w;
	scanf("%d",&t);
	for(int k=1;k<=t;k++)
	{
		memset(head,0,sizeof(head));
		memset(vis,false,sizeof(vis));
		memset(dist,0,sizeof(dist));  //距离默认为0
		num_edge=0;
		scanf("%d%d",&n,&m);
		while(m--)
		{
			scanf("%d%d%d",&x,&y,&w);
			if(y==x) continue;
			add_edge(x,y,w);
			add_edge(y,x,w);
		}
		max_num=inf;
		dijkstra(1); 
		printf("Scenario #%d:\n%d\n\n",k,dist[n]);
	}
	return 0;
}

昂贵的婚礼AC代码：
 

#include<stdio.h>
#include<string.h>
#include<string>
#include<map>
#include<math.h> 
#include<queue>
#include<stack>
#include<algorithm>
#define Max 210
#define min(a,b) a>b?b:a;
#define max(a,b) a>b?a:b;
#define inf 0x3f3f3f3f
using namespace std;
bool vis[Max];
int dist[Max];  //平方，答案最后需要根号 
int deg[Max][2];//还需要维护一个最高的等级 
int max_num;
int M;
struct Node{
	int next;
	int to;
	int dis;
}edge[Max*Max];
int num_edge;
int head[Max];
void add_edge(int x,int y,int w)
{
	edge[++num_edge].next=head[x];
	edge[num_edge].to=y;
	edge[num_edge].dis=w;
	head[x]=num_edge;
}
struct heap{
	int data;
	int weight;
};
int goods[Max][3];   	//钱，主任	，替代品（边） 
struct cmp{ //维护最小的那条边 
	bool operator()(struct heap a,struct heap b)
	{
		return a.weight>b.weight;
	}
};
priority_queue <struct heap,vector<heap>, cmp> q;
bool can_buy(int id)
{
	if(abs(goods[id][1]-goods[1][1])<=M)
		return true;
	else return false;
}
void dijkstra(int num)
{
	dist[num]=0;
	while(q.size()) q.pop();
	struct heap h;
	h.data=num;
	h.weight=0;		//自己为0 
	q.push(h);
	while(q.size())
	{
		int mmin=inf,u=-1;
		h=q.top();
		q.pop();
		mmin=h.weight;
		u=h.data;
		if(vis[u])
			continue;
		vis[u]=true;
		for(int i=head[u];i;i=edge[i].next)
		{
			int id=edge[i].to;//下个商品
			if(dist[id]>mmin+edge[i].dis)
			{
				if(abs(deg[id][0]-deg[u][1])<=M&&abs(deg[id][1]-deg[u][0])<=M)  //经过的等级 
				{
					dist[edge[i].to]=mmin+edge[i].dis;
					deg[id][1]=max(deg[id][1],deg[u][1]);//等级最大 
					deg[id][0]=min(deg[id][0],deg[u][0]);
					if(vis[edge[i].to])
						continue;
					h.data=edge[i].to;
					h.weight=dist[edge[i].to];
					q.push(h);
				}
			}
		}
	 }
}
int main()
{
	int t,n,m,x,y,w;
	num_edge=0;
	memset(head,0,sizeof(head));
	memset(goods,0,sizeof(goods));
	memset(vis,false,sizeof(vis));
	memset(dist,inf,sizeof(dist));  //最远 
	scanf("%d%d",&M,&n); //地位差距直接pass 
	for(int i=1;i<=n;i++)  //多少个点 
	{
		scanf("%d%d%d",&goods[i][0],&goods[i][1],&goods[i][2]);  //钱，等级，替代 
		deg[i][0]=deg[i][1]=goods[i][1];//等级初始化为自己 
		for(int j=1;j<=goods[i][2];j++)
		{
			scanf("%d%d",&y,&w);
			add_edge(i,y,w);
		}
	}
	dijkstra(1);
	int ans=goods[1][0]; //初始价格 
	for(int i=2;i<=n;i++)
	{
		if(ans>goods[i][0]+dist[i])
		{
			ans=goods[i][0]+dist[i];
		}
	}
	printf("%d\n",ans);
	return 0;
}

Floyd 求最短路劲：
Wormholes 数据水，1700ms飘过，切勿使用自带的min 会超时，手写一

Arbitrage 这题数据也水，最坑的是居然可以自己和自己换钱，还能越换越多？？我特判直接剔除了，卡了好久。。。需要换会自己。到自己钱变多了就可以跳出来了。

虽然代码简单，但是需要理解题目然后变通下（数据是真的水.....）

SPFA：判断负环

Currency Exchange  和Arbitrage 这题类似，不过只需要负环，因为他自己只有一种本钱。

AC代码32ms：
 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<queue>
#include<algorithm>
#define Max 10001
#define max(a,b) a>b?a:b;
#define min(a,b) a>b?b:a;
 
using namespace std;
queue<int> q;
double d[Max];   //目前的钱 
int cnt[Max];//记录走过了多少次
bool inque[Max]; //在队列中的信息
struct Node{
	int t;
	double dis;
	double cost;
};
vector<Node> g[Max];
int n;
double all_m;
bool spfa(int s)  //spfa模板 
{
	memset(d,0,sizeof(d));
	memset(inque,0,sizeof(inque));
	memset(cnt,0,sizeof(cnt));
	d[s]=all_m;
	q.push(s);
	inque[s]=true; //记录
	while(q.size())
	{
		int u=q.front();
		q.pop();
		inque[u]=false; //出去
		int nun=g[u].size();
		for(int i=0;i<nun;i++)
		{
			int t=g[u][i].t;
			double w=g[u][i].dis;
			double cost=g[u][i].cost;
			if(w*(d[u]-cost)>d[t]) //换钱后变多了 
			{
				d[t]=w*(d[u]-cost);
				if(!inque[t])  //不在队列里面
				{
					q.push(t);		 //入队
					inque[t]=true;
					cnt[t]++;
					if(cnt[t]>=n)  //存在正环 
						return true;
				}
			}
		}
	}
	return false;
}
int main()
{
	int m,x,y,st;
	double w,cost;
	scanf("%d%d%d%lf",&n,&m,&st,&all_m); //点、边、开始、结束
	struct Node temp;
	while(m--)
	{
		scanf("%d%d",&x,&y);
		scanf("%lf%lf",&w,&cost); // x 》》 y 
		temp.t=y;
		temp.dis=w;
		temp.cost=cost;
		g[x].push_back(temp);
		scanf("%lf%lf",&w,&cost);
		temp.t=x;
		temp.dis=w;
		temp.cost=cost;
		g[y].push_back(temp);//两边都要走
	}
	if(spfa(st))
		printf("YES\n");
	else
		printf("NO\n");
	return 0;
}

上面练习题是上次的。

 PS;今天的模拟题又写炸了，谷歌翻译卡了我几个多小时，题目看不懂真的伤......然后调试一个简单题 又花了1个小时，哭了，最后还有个水题没提交。然后还有两个貌似的难题，有个TLE了，后面没时间写，还有个题看都没看，晕死，后面心态真的炸。

另外8月前学完提高组，8月要把省选刷完！！！加油！！