【SSL】1889 &【洛谷】P1073最优贸易
题目描述
C国有n个大城市和m 条道路，每条道路连接这 n个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1条。
C国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。
商人阿龙来到 C 国旅游。当他得知同一种商品在不同城市的价格可能会不同这一信息之后，便决定在旅游的同时，利用商品在不同城市中的差价赚回一点旅费。设 C 国 n 个城市的标号从 1~ n，阿龙决定从 1号城市出发，并最终在 n 号城市结束自己的旅行。在旅游的过程中，任何城市可以重复经过多次，但不要求经过所有 n 个城市。阿龙通过这样的贸易方式赚取旅费：他会选择一个经过的城市买入他最喜欢的商品――水晶球，并在之后经过的另一个城市卖出这个水晶球，用赚取的差价当做旅费。由于阿龙主要是来 C 国旅游，他决定这个贸易只进行最多一次，当然，在赚不到差价的情况下他就无需进行贸易。
假设 C国有 5个大城市，城市的编号和道路连接情况如下图，单向箭头表示这条道路为单向通行，双向箭头表示这条道路为双向通行。
假设 1~n 号城市的水晶球价格分别为 4,3,5,6,1。
阿龙可以选择如下一条线路：1->2->3->5，并在 2号城市以3 的价格买入水晶球，在 3号城市以5的价格卖出水晶球，赚取的旅费数为 2。
阿龙也可以选择如下一条线路1->4->5->4->5，并在第1次到达5 号城市时以 1的价格买入水晶球，在第 2 次到达4 号城市时以6 的价格卖出水晶球，赚取的旅费数为5。
现在给出 n个城市的水晶球价格，m 条道路的信息（每条道路所连接的两个城市的编号以及该条道路的通行情况）。请你告诉阿龙，他最多能赚取多少旅费。
输入格式
第一行包含 2 个正整数n和 m，中间用一个空格隔开，分别表示城市的数目和道路的数目。
第二行 n 个正整数，每两个整数之间用一个空格隔开，按标号顺序分别表示这 n 个城市的商品价格。
接下来 m 行，每行有3个正整数x,y,z，每两个整数之间用一个空格隔开。如果 z=1，表示这条道路是城市x到城市y之间的单向道路；如果z=2，表示这条道路为城市 x和城市y之间的双向道路。
输出格式
一 个整数，表示最多能赚取的旅费。如果没有进行贸易，则输出 0。
输入输出样例
输入
5 5
4 3 5 6 1
1 2 1
1 4 1
2 3 2
3 5 1
4 5 2
输出
5
说明/提示
【数据范围】
输入数据保证 1 号城市可以到达nn号城市。
对于 10%的数据，1≤n≤6。
对于 30%的数据，1≤n≤100。
对于 50%的数据，不存在一条旅游路线，可以从一个城市出发，再回到这个城市。
对于 100%的数据，1≤n≤100000，1≤m≤500000，1≤x，y≤n，1≤z≤2，1≤各城市水晶球价格≤100。
NOIP 2009 提高组 第三题
思路
分为3种情况：
1：买前
2：买后卖前
3：卖后
1：买前第i个点表示为i
2：买后卖前第i个点表示为i+n
3：卖后第i个点表示为i+n+n
建边
每种情况内部建边
跨情况建边<i,i+n>=-price[i],<i+n,i+n+n>=price[i],1<=i<=n;
再用SPFA。
SPFA是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
主要思想是：
初始时将起点加入队列。每次从队列中取出一个元素，并对所有与它相邻的点进行修改，若某个相邻的点修改成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford，利用了每个点不会更新次数太多的特点发明的此算法。
SPFA 在形式上和广度优先搜索非常类似，不同的是广度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是说一个点修改过其它的点之后，过了一段时间可能会获得更短的路径，于是再次用来修改其它的点，这样反复进行下去。
算法时间复杂度：O(kE)，E是边数。K是常数，平均值为2。
注意到Bellman-Ford算法实际上做了很多无用功。因为每次它都把所有的边枚举一次，而有一些边在上一次枚举中，起始端顶点都没有更新，那么在这一次枚举中，肯定不会进行松弛。那么我们可以使用一个队列来进行活跃点的维护。我们定义在这个队列里的每个元素x都必须满足：d[x]被更新，但是未利用d[x]去更新其它的点。那么初始时把起始点1放进队列里面，然后对它进行松弛操作，并把d值被更新的点放入队列之中，最后把当前这个做完松弛操作的点出队。重复这个操作直到队列中没有元素，那么所有点的d值都被确定了。
这个算法同样可用于有负权边的情况之中。此外，该算法也可以用来判断负权环，具体方法就是如果某一个点入队超过n次,那么判断有负权环。
时间复杂度O(kE),其中k为一个小常数，大致在[3,5]这个范围内。
算法实现：
dis[i]记录从起点s到i的最短路径，w[i][j]记录连接i，j的边的长度。pre[v]记录前趋。
team[1…n]为队列，头指针head，尾指针tail。
布尔数组exist[1…n]记录一个点是否现在存在在队列中。
初始化：dis[s]=0,dis[v]=∞（v≠s），memset(exist,false,sizeof(exist));
起点入队team[1]=s; head=0; tail=1;exist[s]=true;
do
{
1、头指针向下移一位，取出指向的点u。
2、exist[u]=false;已被取出了队列
3、for与u相连的所有点v //注意不要去枚举所有点，用数组模拟邻接表存储
if (dis[v]>dis[u]+w[u][v])
{
dis[v]=dis[u]+w[u][v];
pre[v]=u;
if (!exist[v]) //队列中不存在v点，v入队。
{
//尾指针下移一位，v入队;
exist[v]=true;
}
｝
}
while (head < tail);
循环队列：
采用循环队列能够降低队列大小，队列长度只需开到2*n+5即可。例题中的参考程序使用了循环队列。
代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
bool d[300010];
int n,m,dis[300010],head[300010],tot=0,a[300010];
struct jgt
{
int x,y,nxt,s;
}f[5000001];
queue<int> q;
void add(int x,int y)//建边
{
f[++tot].x=x;
f[tot].y=y;
f[tot].s=0;
f[tot].nxt=head[x];
head[x]=tot;
return;
}
void input()
{
int i,x,y,z;
scanf("%d%d",&n,&m);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
for(i=1;i<=m;i++)
{
scanf("%d%d%d",&x,&y,&z);
add(x,y);
add(x+n,y+n);
add(x+n+n,y+n+n);
if(z==2)
{
add(y,x);
add(y+n,x+n);
add(y+n+n,x+n+n);
}
}
for(i=1;i<=n;i++)
{
f[++tot].x=i;
f[tot].y=i+n;
f[tot].s=-a[i];
f[tot].nxt=head[i];
head[i]=tot;
f[++tot].x=i+n;
f[tot].y=i+n+n;
f[tot].s=a[i];
f[tot].nxt=head[i+n];
head[i+n]=tot;
}
return;
}
void SPFA()
{
int l,r,i;
memset(d,0,sizeof(d));
memset(dis,-0x7f7f,sizeof(dis));
dis[1]=0;
for(q.push(1),d[1]=1;!q.empty();q.pop())//队列优化
{
for(i=head[q.front()];i;i=f[i].nxt)
if(dis[f[i].y]<dis[q.front()]+f[i].s)//松弛
{
dis[f[i].y]=dis[q.front()]+f[i].s;
if(!d[f[i].y])
{
q.push(f[i].y);//加入队列
d[f[i].y]=1;
}
}
d[q.front()]=0;//退出队列
}
return;
}
int main()
{
input();
SPFA();
printf("%d",dis[3*n]);
return 0;
}