NOIP2009T3最优贸易（Dfs + spfa）

洛谷传送门

看到这个题，原本想先从后往前dfs，求出能到终点的点，再在这些点里从前往后spfa，用一条边上的两个城市的商品价格的差来作边权，实施过后，发现图中既有负边权，又有回路，以及各种奇奇怪怪的东西。说实话我连样例都没过，然后提交一下试试，得了10分。

然而我发现，要求赚最多钱，就是到那个点的路径上的最大价格 - 最小价格。

两边dfs——

最小价格可以从前往后搜来算。

最大价格可以从后往前搜来算。

最后枚举一边所有点maxx - minn的最大值就好。

说出来你可能不信，我是看的题解。

——代码

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>

using namespace std;

int n, m, cnt1, cnt2, ans;
int a[], next1[], to1[], head1[], next2[], to2[],
    head2[], maxx[], minn[];

inline void add1(int x, int y)
{
    to1[cnt1] = y;
    next1[cnt1] = head1[x];
    head1[x] = cnt1++;
}

inline void add2(int x, int y)
{
    to2[cnt2] = y;
    next2[cnt2] = head2[x];
    head2[x] = cnt2++;
}

inline void dfs2(int u, int k)
{
    int i, v;
    maxx[u] = max(maxx[u], k);
    for(i = head2[u]; i != -; i = next2[i])
    {
        v = to2[i];
        if(maxx[v] < k) dfs2(v, max(k, a[v]));
    }
}

inline void dfs1(int u, int k)
{
    int i, v;
    minn[u] = min(minn[u], k);
    for(i = head1[u]; i != -; i = next1[i])
    {
        v = to1[i];
        if(minn[v] > k) dfs1(v, min(k, a[v]));
    }
}

int main()
{
    int i, j, x, y, z;
    memset(head1, -, sizeof(head1));
    memset(head2, -, sizeof(head2));
    scanf("%d %d", &n, &m);
    for(i = ; i <= n; i++)
    {
        scanf("%d", &a[i]);
        maxx[i] = -1e9;
        minn[i] = 1e9;
    }
    for(i = ; i <= m; i++)
    {
        scanf("%d %d %d", &x, &y, &z);
        if(z == )
        {
            add1(x, y);
            add1(y, x);
            add2(x, y);
            add2(y, x);
        }
        else
        {
            add1(x, y);
            add2(y, x);
        }
    }
    dfs1(, a[]);
    dfs2(n, a[n]);
    for(i = ; i <= n; i++) ans = max(ans, maxx[i] - minn[i]);
    printf("%d", ans);
    return ;
}

其中dfs不用设置vis来记录是否被访问过，因为有双向道路，所以走到一个点有可能会返回来，所以进行深搜的判断标准是目标点（姑且这么说吧）的最大最小值小于或大于当前点的最大最小值。这样即使走到后面的点，发现前面的点需要修改，也可以改回去。

也可以用 spfa ，改变一下松弛操作，dis 数组表示到当前点的路径上买入的最小值，最后统计一遍就行。

——代码

 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <iostream>

 using namespace std;

 const int MAXN = ;
 int n, m, cnt, cnt1, ans;
 int a[MAXN], head[MAXN], to[MAXN], next[MAXN], head1[MAXN], to1[MAXN], next1[MAXN], dis[MAXN];
 bool b[MAXN], vis[MAXN];
 queue <int> q;

 inline void add(int x, int y)
 {
     to[cnt] = y;
     next[cnt] = head[x];
     head[x] = cnt++;
 }

 inline void add1(int x, int y)
 {
     to1[cnt1] = y;
     next1[cnt1] = head1[x];
     head1[x] = cnt1++;
 }

 inline void dfs(int u)
 {
     int i, v;
     b[u] = ;
     for(i = head1[u]; i != -; i = next1[i])
     {
         v = to1[i];
         if(!b[v]) dfs(v);
     }
 }

 inline void spfa(int u)
 {
     int i, v;
     memset(dis,  / , sizeof(dis));
     q.push(u);
     dis[u] = a[u];
     while(!q.empty())
     {
         u = q.front();
         q.pop();
         vis[u] = ;
         for(i = head[u]; i != -; i = next[i])
         {
             v = to[i];
             if(dis[v] > min(dis[u], a[v]) && b[v])
             {
                 dis[v] = min(dis[u], a[v]);
                 if(!vis[v])
                 {
                     q.push(v);
                     vis[v] = ;
                 }
             }
         }
     }
 }

 int main()
 {
     int i, j, x, y, z;
     scanf("%d %d", &n, &m);
     for(i = ; i <= n; i++) scanf("%d", &a[i]);
     memset(head, -, sizeof(head));
     memset(head1, -, sizeof(head1));
     for(i = ; i <= m; i++)
     {
         scanf("%d %d %d", &x, &y, &z);
         if(z == )
         {
             add(x, y);
             add1(y, x);
         }
         else
         {
             add(x, y);
             add(y, x);
             add1(x, y);
             add1(y, x);
         }
     }
     dfs(n);
     spfa();
     for(i = ; i <= n; i++)
         if(b[i])
             ans = max(ans, a[i] - dis[i]);
     printf("%d", ans);
     return ;
 }