BZOJ1776

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1776

题目大意：一棵n个点的树，树上每个点属于一个党派，要求每个党派的最远距离点。两点间距离为两点间边的个数。

主观思路：看到树上两点距离立即想到dep[x] + dep[y] - 2 * dep[lca(x, y)]这件事。于是想到树形序列化的思想，搞成一个中序遍历的dfs序列。序列中每个点有一个dep,也有一个col表示点深度和所属党派，依次枚举dfs序列中的点，对于当前点x它与之前所有同党派y之间的最远距离取决于dep[y] - 2 * min{dep[k], k在dfs序列y,x之间}。这里用了一种类似单调队列的思想可以做到每个点只进队(我对每个党派的点开了一个vector)一次，详见代码，属于乱搞。对于那个min就用rmq提前对dep维护一下即可。

/**************************************************************
    Problem: 1776
    User: SWUN2015
    Language: C++
    Result: Accepted
    Time:1988 ms
    Memory:48060 kb
****************************************************************/
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;
  
const int MaxN = 2 * 1e5, MaxM = 4 * 1e5;
struct ARR
{
    int loc, dep, MiN, pre;
};
int n, K, all, Root, tot;
int dep[MaxN + 5], col[MaxN + 5], dfs_seq[MaxN + 5], ans[MaxN + 5];
int p[MaxN + 5], pre[MaxM + 5], last[MaxN + 5], other[MaxM + 5];
int rmq[MaxN + 5][30];
vector <ARR> a[MaxN + 5];
  
void Build(int x, int y)
{
    pre[++all] = last[x];
    last[x] = all;
    other[all] = y;
}
  
void Init()
{
    all = -1; memset(last, -1, sizeof(last));
    scanf("%d%d", &n, &K);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", &col[i], &p[i]);
        Build(i, p[i]); Build(p[i], i);
        if (p[i] == 0) Root = i;
    }
}
  
void Dfs(int x, int fa, int d)
{
    dfs_seq[++tot] = x;
    dep[x] = d;
    int ed = last[x], dr;
    while (ed != -1)
    {
        dr = other[ed];
        if (dr != fa) Dfs(dr, x, d + 1);
        ed = pre[ed];
    }
}
  
void RMQ()
{
    int K = (int)(double(log(n)) / double(log(2)));
    for (int i = 1; i <= n; i++) rmq[i][0] = dep[dfs_seq[i]];
    for (int i = 1; i <= K; i++)
        for (int j = 1; j <= n - (1 << i) + 1; j++)
            rmq[j][i] = min(rmq[j][i - 1], rmq[j + (1 << (i - 1))][i - 1]);
}
  
void Insert(int x)
{
    int t, c = col[dfs_seq[x]]; 
    if (a[c].size() > 0)
    {
        t = a[c].size();
        int pos, dd = 0;
        int l = a[c][--t].loc + 1, r = x;
        int K = (int)(double(log(r - l + 1)) / double(log(2)));
        int MiN = min(rmq[l][K], rmq[r - (1 << K) + 1][K]);
        ARR res;
        while (t >= 0 && MiN <= a[c][t].MiN) 
        {
            if (a[c][t].dep >= dd) dd = a[c][t].dep, pos = a[c][t].loc;
            a[c].pop_back(); t--;
        }   
        res.dep = dd; res.loc = pos; res.MiN = MiN; 
        if (t >= 0) res.pre = max(a[c][t].pre, res.dep - 2 * (res.MiN - 1));
            else res.pre = res.dep - 2 * (res.MiN - 1);
        a[c].push_back(res);
        res.dep = dep[dfs_seq[x]]; res.loc = x; res.MiN = 1 << 30; 
        res.pre = a[c][t + 1].pre;
        a[c].push_back(res);
        t += 2;
        ans[c] = max(ans[c], a[c][t].pre + dep[dfs_seq[x]]);
    }
    else
    {
        t = 0;
        ARR res;
        res.dep = dep[dfs_seq[x]]; res.loc = x; res.MiN = 1 << 30; res.pre = -(1 << 30);
        a[c].push_back(res);
    }
}
  
void Solve()
{
    Dfs(Root, 0, 0); RMQ();
    for (int i = 1; i <= n; i++) {Insert(i);}//printf("%d %d
", dfs_seq[i], ans[col[dfs_seq[i]]]);}
    for (int i = 1; i <= K; i++) printf("%d
", ans[i]);
}
  
int main()
{
    Init();
    Solve();
}

于是这道题就成了RMQ预处理之后的O(N)乱搞题，然而看了题解之后异常崩溃。

有这样一个结论：每个政党中的最远距离点对，必然有一个点是该政党dep最深的点。仔细考虑没有理由反驳…

于是题目变得很水，找到每个党派的dep最深点，再顺次枚举该党派的所有点，找到lca求值更新答案即可。复杂度O(nlogn)。