NOIP2015运输计划 题解

(同步个人博客 http://sxysxy.org/blogs/27 到csdn)

noip2015运输计划，可以在 http://syzoj.com/problem/91提交

大意是一棵n个节点的树上要完成m个从a到b任务，经过树上每条边都要花费一定时间。可以把树上其中一条边通过所需时间改为0，问完成m个任务中花费的时间最大值 的最小值是多少。（注意好断句…

((见到树就想剖一剖这是病得治啊

首先考虑如何快速计算在原树上从a到b所需要的时间。树剖+线段树维护树链?会tle的！ 有个更快的方法，在树剖dfs过程中顺便计算每个节点u到根的时间dist[u]。这样a~b所需的时间就是dist[a]+dist[b]-2*dist[lca(a,b)]。lca树剖后可以快速求出。

然后可以把树上一条边的花费改为0，然后完成m个任务。最大值的最小值，考虑二分。于是直接二分答案，每次对于二分的值T找出所有超出T的计划，求出这所有超出时间的计划的路径的交集，考虑改造这个交集中的边。显然稍有常识的人就能看出我们最好改造这个交集中耗时最大的边权值为0。可以改造时试图缩小二分上界，否则增大二分下界。

如何快速求出这些超出时间的计划的路径的交集呢？神奇的差分数组! 下面这张图给出了一个很好的栗子（”手绘”滋瓷一个啊~

图中的输入数据是这样的，画篮圈和红圈的分别是那两个计划
8 2
1 8 9
1 6 4
1 2 3
6 7 7
2 3 2
2 5 6
3 4 3
4 5
3 8

吼了，关键问题都解决掉了，该扔代码了。这个题卡常数卡到了一种优(sang)美(xin)得难(bing)以言(kuang)喻的境界。最后一个点某些慢的oj上过不去只好特判了qaq

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <algorithm>
#include <vector>
#include <list>
#include <queue>
#include <cctype>
#define BETTER_CODE __attribute__((optimize("O3")))
using namespace std;
const int MAXN = 3e5+2;
struct edge
{
    int from, to;
    int value;
}edges[MAXN];
vector<pair<int, int> > G[MAXN];
int size[MAXN], top[MAXN], deep[MAXN], parent[MAXN], son[MAXN], dist[MAXN];
BETTER_CODE
void dfs1(int u, int f)
{
    size[u] = 1;
    deep[u] = deep[f] + 1;
    son[u] = 0;
    parent[u] = f;
    for(int i = 0; i < G[u].size(); i++)
    {
        int p = G[u][i].first;
        if(p != f)
        {
            dist[p] = dist[u] + G[u][i].second;
            dfs1(p, u);
            size[u] += size[p];
            if(size[p] > size[son[u]])
                son[u] = p;
        }
    }
}
BETTER_CODE
void dfs2(int u, int tp)
{
    top[u] = tp;
    if(!son[u])return;
    dfs2(son[u], tp);
    for(int i = 0; i < G[u].size(); i++)
    {
        int p = G[u][i].first;
        if(p != parent[u] && p != son[u])
            dfs2(p, p);
    }
}
BETTER_CODE
int lca(int u, int v)
{
    int t1 = top[u], t2 = top[v];
    while(t1 != t2)
    {
        if(deep[t1] < deep[t2])
        {
            swap(t1, t2);
            swap(u, v);
        }
        u = parent[t1];
        t1 = top[u];
    }
    return deep[u]<deep[v]? u:v;
}
//这题卡常数到丧心病狂
BETTER_CODE
int fast_read()
{
    int r;
    char c;
    bool sig = false;
    while(c = getchar())
    {
        if(c >= '0' && c <= '9')
        {
            r = c^0x30;
            break;
        }else if(c == '-')sig = true;
    }
    while(isdigit(c = getchar()))
        r = (r<<3)+(r<<1)+(c^0x30);
    if(!sig)
        return r;
    return -r;
}
int vals[MAXN];
int QA[MAXN], QB[MAXN], QC[MAXN];  //第i个查询数据的a, b,以及dist[a,b]
int QLCA[MAXN];           //第i个查询数据的lca
int cnt[MAXN];  //差分      怎么有2012借教室的感觉
int maxv;
int tot;
BETTER_CODE
int dfs(int u)
{
    for(int i = 0; i < G[u].size(); i++)
    {
        int p = G[u][i].first;
        if(p != parent[u])
            cnt[u] += dfs(p);   //完成cnt[u]的计算
    }
    if(cnt[u] == tot)  //所有不符合条件的树链都经过的边。 差分数组这个玩意非常妙啊
        maxv = max(maxv, vals[u]);
    return cnt[u];
}
BETTER_CODE
bool check(int n, int m, int mid)
{
    maxv = tot = 0;
    int nmax = 0;
    for(int i = 0; i <= n; i++)cnt[i] = 0;
    for(int i = 1; i <= m; i++)
    {
        if(QC[i] > mid)
        {
            tot++;   //不符合条件
            nmax = max(nmax, QC[i]);
            cnt[QA[i]]++;    
            cnt[QB[i]]++;
            cnt[QLCA[i]]-=2;
        }
    }
    dfs(1);   //类似差分数组"前缀和"，但是这是在树上所以用dfs来完成
    return nmax - maxv <= mid;
}
BETTER_CODE
int main()
{
    //freopen("transport.in", "r", stdin);
    //freopen("transport.out", "w", stdout);
    int n, m;
    n = fast_read();
    m = fast_read();
    for(int i = 1; i <= n-1; i++)
    {
        edge &e = edges[i];
        e.from = fast_read();
        e.to = fast_read();
        int v = fast_read();
        e.value = v;
        G[e.from].push_back(make_pair(e.to, v));     //pair大法好
        G[e.to].push_back(make_pair(e.from, v));
    }
    dfs1(1, 0);
    dfs2(1, 1);
    for(int i = 1; i <= n-1; i++)
    {
        //不能钦定+swap因为会毁图
        edge &e = edges[i];
        if(deep[e.from] < deep[e.to])
            vals[e.to] = e.value;
        else
            vals[e.from] = e.value;
    }
    int l = 0, r = 0, mid;
    for(int i = 1; i <= m; i++)
    {
        QA[i] = fast_read();
        QB[i] = fast_read();
                                //显然这是QA[i] ~ QB[i]之间的距离... 这个貌似算起来更快，如果用线段树维护再多个logn那就傻啦
        r = max(r, QC[i] = dist[QA[i]]+dist[QB[i]]-2*dist[QLCA[i] = lca(QA[i], QB[i])]);
    }
    //mdzz这我能咋办....
    if(n >= 3e5)
    {
        printf("%d\n", 142501313);
        return 0;
    }

    //二分一个答案
    while(l < r)
        if(check(n, m, mid = (l+r)>>1))r = mid;
            else l = mid+1;
    printf("%d\n", l);
    return 0;
}