【noip 2009】最优贸易

题目描述

C 国有 n 个大城市和 m 条道路，每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路，一部分为双向通行的道路，双向通行的道路在统计条数时也计为 1 条。

C 国幅员辽阔，各地的资源分布情况各不相同，这就导致了同一种商品在不同城市的价格不一定相同。但是，同一种商品在同一个城市的买入价和卖出价始终是相同的。

商人阿龙来到 C 国旅游。当他得知同一种商品在不同城市的价格可能会不同这一信息之后，便决定在旅游的同时，利用商品在不同城市中的差价赚回一点旅费。设 C 国 n 个城市的标号从 1~ n，阿龙决定从 1 号城市出发，并最终在 n 号城市结束自己的旅行。在旅游的过程中，任何城市可以重复经过多次，但不要求经过所有 n 个城市。阿龙通过这样的贸易方式赚取旅费：他会选择一个经过的城市买入他最喜欢的商品――水晶球，并在之后经过的另一个城市卖出这个水晶球，用赚取的差价当做旅费。由于阿龙主要是来 C 国旅游，他决定这个贸易只进行最多一次，当然，在赚不到差价的情况下他就无需进行贸易。

现在给出 n 个城市的水晶球价格，m 条道路的信息（每条道路所连接的两个城市的编号以及该条道路的通行情况）。请你告诉阿龙，他最多能赚取多少旅费。

输入格式：

第一行包含 2 个正整数 n 和 m，中间用一个空格隔开，分别表示城市的数目和道路的数目。
第二行 n 个正整数，每两个整数之间用一个空格隔开，按标号顺序分别表示这 n 个城市的商品价格。
接下来 m 行，每行有 3 个正整数，x，y，z，每两个整数之间用一个空格隔开。如果 z=1，表示这条道路是城市 x 到城市 y 之间的单向道路；如果 z=2，表示这条道路为城市 x 和城市y 之间的双向道路。

输出格式：

输出包含 1 个整数，表示最多能赚取的旅费。如果没有进行贸易，则输出 0。

数据范围

对于 100%的数据，1≤n≤100000，1≤m≤500000，1≤x，y≤n，1≤z≤2，1≤各城市水晶球价格≤100。

这道题好像两遍bfs就能过…

不过不能颓废，抱着学习新知识的目的我作死写了tarjan缩点…

然后调了一个多小时都调不对结果犯了个sb错…

说说思路，这道题看起来处理出minw[i]表示能到达i点的最低价格，然后用i点的价格减去minw就是在改点卖出的最大收益，再对于所有点取max就好啦。可是怎么处理minw？

智障dp啊！

对于点v，枚举所有能到达v的点u，dp[v]=min(w[v],dp[u])。所以反向建图，从终点往前dfs，回溯的时候更新minw就可以。

好像哪里有问题！这不是一个DAG，所以要小心点。图中可能有环，这就说明龙龙可以在图中某些地方来回跑，因为dfs的时候每个点只访问一次（要不然复杂度爆炸），所以dfs的minw不一定是真正的minw。

要是这是一个DAG就好啦！

Tarjan算法登场了！

Tarjan就是 一个人 一种dfs来求强联通分量的算法，对于每个dfs到的点i有DFN[i]表示i号点被搜索到的编号，low[i]表示i所能回溯到最早的点的编号。每搜索到一个点就把它压入栈里，如果一个点u所到达的点v在栈里，那么就尝试用DFN[v]更新low[u]。回溯的时候，也尝试用low[v]更新low[u]，因为v能到的点u一定能到；如果回溯到点u，DFN[u]=low[u]，那说明u是它所在强联通分量的第一个点，这时候从栈里弹出它和它顶部的元素，并把这些元素放在一个集合里（有点像并查集），也就是belong数组的作用。

那怎么变成DAG？

把所有的环变成一个点！

因为龙龙可以在环里随便走动，所以就跟一个点没什么区别辣！只不过这个点最小水晶球的价值是强联通分量中每个点的价值取min，最大值就是取max。

搞定DAG，剩下的无脑dp就行了。

语文水平受限，感觉说的不是很清楚，看代码吧：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<stack>
using namespace std;
struct edge{
    int to,next;
}ed1[1000001],ed2[1000001];
struct node{
    int u,v;
}tmped[1000001];

int head1[100001]={0},head2[100001]={0};
int DFN[100001]={0},low[100001]={0};
int dp[100001],w[100001];                       //dp[i]表示i和i点前买入卖出的最大收益
int maxw[100001],minw[100001];
int n,m,cnt=1,size1=0,size2=0;
bool inst[100001]={0};
bool vis[100001]={0};
int belong[100001]={0};
stack <int> st;

bool cmp(node a,node b)
{
    if(a.u!=b.u) return a.u<b.u;
    if(a.v!=b.v) return a.v<b.v;
}
void read(int &x)
{
    char c=getchar();x=0;
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
}
void add1(int from,int to)
{
    size1++;
    ed1[size1].to=to;
    ed1[size1].next=head1[from];
    head1[from]=size1;
}
void add2(int from,int to)
{
    size2++;
    ed2[size2].to=to;
    ed2[size2].next=head2[from];
    head2[from]=size2;
}
void Tarjan(int u)
{
    DFN[u]=low[u]=++cnt;
    st.push(u);inst[u]=1;
    for(int i=head1[u];i;i=ed1[i].next)
    {
        int v=ed1[i].to;
        if(!DFN[v])
        {
            Tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(inst[v]) low[u]=min(low[u],DFN[v]);
    }
    int now;
    if(DFN[u]==low[u])
    {
        maxw[u]=0,minw[u]=1e9;                       
        do{
            now=st.top();
            st.pop();
            inst[now]=0;
            belong[now]=u;                       //代表元素是u
            maxw[u]=max(maxw[u],w[now]);         //处理这个强联通分量的最大价格
            minw[u]=min(minw[u],w[now]);         //最小价格
        }
        while(now!=u);
    }
}
void shrink()                                    //缩点
{
    int p=0;
    for(int u=1;u<=n;u++)
    {
        for(int i=head1[u];i;i=ed1[i].next)
        {
            int v=ed1[i].to;
            if(belong[u]!=belong[v])             //如果两个点不在一个强联通分量里，那么这两个强联通分量之间需要连边
            {
                tmped[++p].u=belong[u];          //一定是belong！
                tmped[p].v=belong[v];
            }
        }
    }
    sort(tmped+1,tmped+p+1,cmp);            
    int j;
    for(int i=1;i<=p;i=j)                         //去重，stl的去重感觉不是很好用...
    {
        add2(tmped[i].v,tmped[i].u);
        j=i+1;
        while(j<=p&&tmped[j].u==tmped[i].u&&tmped[j].v==tmped[i].v)
            j++;
    }
}
void dfs(int u)
{
    for(int i=head2[u];i;i=ed2[i].next)
    {
        int v=ed2[i].to;
        if(!vis[v])
        {
            vis[v]=1;
            dfs(v);
        }
        minw[u]=min(minw[u],minw[v]);
        dp[u]=max(dp[u],dp[v]);
        dp[u]=max(dp[u],maxw[u]-minw[u]);
    }
}
int main()
{
    read(n),read(m);
    for(int i=1;i<=n;i++)
    {
        read(w[i]);
    }
    int x,y,z;
    for(int i=1;i<=m;i++)
    {
        read(x),read(y),read(z);
        add1(x,y);
        if(z==2) add1(y,x);
    }
    for(int i=1;i<=n;i++)
    {
        if(!DFN[i]) Tarjan(i);                 //如果这个点没有序号也就是没搜过，就搜它
    }
    shrink();
    dfs(belong[n]);                            //一定是belong[n]！因为原来的n可能缩掉了！
    printf("%d",dp[belong[n]]);
    return 0;
}

---