BZOJ 1146: [CTSC2008]网络管理Network

1146: [CTSC2008]网络管理Network

Time Limit: 50 Sec  Memory Limit: 162 MB
Submit: 3539  Solved: 1054
[Submit][Status][Discuss]

Description

　　M公司是一个非常庞大的跨国公司，在许多国家都设有它的下属分支机构或部门。为了让分布在世界各地的N个

部门之间协同工作，公司搭建了一个连接整个公司的通信网络。该网络的结构由N个路由器和N-1条高速光缆组成。

每个部门都有一个专属的路由器，部门局域网内的所有机器都联向这个路由器，然后再通过这个通信子网与其他部

门进行通信联络。该网络结构保证网络中的任意两个路由器之间都存在一条直接或间接路径以进行通信。 高速光

缆的数据传输速度非常快，以至于利用光缆传输的延迟时间可以忽略。但是由于路由器老化，在这些路由器上进行

数据交换会带来很大的延迟。而两个路由器之间的通信延迟时间则与这两个路由器通信路径上所有路由器中最大的

交换延迟时间有关。作为M公司网络部门的一名实习员工，现在要求你编写一个简单的程序来监视公司的网络状况

。该程序能够随时更新网络状况的变化信息（路由器数据交换延迟时间的变化），并且根据询问给出两个路由器通

信路径上延迟第k大的路由器的延迟时间。【任务】 你的程序从输入文件中读入N个路由器和N-1条光缆的连接信息

，每个路由器初始的数据交换延迟时间Ti，以及Q条询问（或状态改变）的信息。并依次处理这Q条询问信息，它们

可能是： 1. 由于更新了设备，或者设备出现新的故障，使得某个路由器的数据交换延迟时间发生了变化。 2. 查

询某两个路由器a和b之间的路径上延迟第k大的路由器的延迟时间。

Input

　　第一行为两个整数N和Q，分别表示路由器总数和询问的总数。第二行有N个整数，第i个数表示编号为i的路由

器初始的数据延迟时间Ti。紧接着N-1行，每行包含两个整数x和y。表示有一条光缆连接路由器x和路由器y。紧接

着是Q行，每行三个整数k、a、b。如果k=0，则表示路由器a的状态发生了变化，它的数据交换延迟时间由Ta变为b

。如果k>0，则表示询问a到b的路径上所经过的所有路由器（包括a和b）中延迟第k大的路由器的延迟时间。注意N

,Q<=80000,任意一个路由器在任何时刻都满足延迟时间小于10^8。对于所有询问满足0<=K<=N

Output

　　对于每一个第二种询问（k>0），输出一行。包含一个整数为相应的延迟时间。如果路径上的路由器不足k个，

则输出信息“invalid request!”（全部小写不包含引号，两个单词之间有一个空格）。

Sample Input

5 5
5 1 2 3 4
3 1
2 1
4 3
5 3
2 4 5
0 1 2
2 2 3
2 1 4
3 3 5

Sample Output

3
2
2
invalid request!

HINT

 

Source

 

[Submit][Status][Discuss]

本来以为是CDQ什么的，发现并不会；从DaD3zZ神犇那里看到带修主席树，表示也不会。

然后就是看代码学喽，各种RE各种WA，外加OJ上的TLE。直到代码长的都一模一样了才过，T_T，看来还有重新学习的必要。

DaD3zZ的题解，摘抄在下——

这道题方法很好想把，树上带修第k大问题，最直观的就是树链剖分+树套树，复杂度O(Nlog^4N)，我是直接 dfs序+带修主席树 硬上，复杂度是O(Nlog^2N)

问题在于内存 ，所以可以考虑先建一棵完整的树，然后树状数组修改时只搞一条链这样能把内存大大降低。

并且，这里的dfs序直接用就好了，并不需要搞成入栈出栈序，那样内存消耗依旧很大，自己第一次大概是180M--MLE。

By DaD3zZ

另外记录一下带修主席树的大体思想：

一般主席树维护的是前缀关系，即 $Root_{i}$ 上含有从$1$到$i$的区间内的信息，而这样是不能修改的，因为改动区间中一个地方的信息，就需要把后面所有地方的 $Root_{j},i leq j leq n$ 全部修改。

带修主席树利用树状数组的形式，每个 $Root_{i}$ 上维护的只有树状数组上 $i$ 这个位置管辖的区间，这样更改区间中一处位置，只需要更改其在树状数组上的所有祖先节点，这是 $log_{2}N$ 级别的，所以总体复杂度是 $O(log_{2}^{2}N)$ 的。

而查询的时候，先开两个存放根节点的数组，分别为 $Add$ 和 $Sub$ ，代表需要加上$Add$中节点上的答案，减去$Sub$中节点上的答案。这个还好理解，原本主席树就是用 $Root_{i}$ 的答案减去 $Root_{j}$ 的答案从而得到 $(j,i]$ 这一区间的答案的，现在因为外层还有树状数组，所以 $i$ 和 $j$ 不唯一了，分别变为了一些结点。权值线段树上二分的时候还是类似，只是需要从多个 $Root$ 中计算出左（右）侧答案，进而判断应该向左还是右递归。注意递归的时候需要把所有 $Add$ 和 $Sub$ 中的结点向该方向递归。

#include <cstdio>
#include <vector>
#include <algorithm>

inline int nextChar(void)
{
    const static int siz = 1024;
    
    static char buf[siz];
    static char *hd = buf + siz;
    static char *tl = buf + siz;
    
    if (hd == tl)
        fread(hd = buf, 1, siz, stdin);
        
    return *hd++;
}

inline int nextInt(void)
{
    register int ret = 0;
    register int neg = false;
    register int bit = nextChar();
    
    for (; bit < 48; bit = nextChar())
        if (bit == '-')neg ^= true;
        
    for (; bit > 47; bit = nextChar())
        ret = ret * 10 + bit - 48;
        
    return neg ? -ret : ret;
}

const int siz = 80005;

int N, M;

int tim[siz];

int map[siz << 1], tot;

int opt[siz], opx[siz], opy[siz];

int edges;
int hd[siz];
int to[siz << 1];
int nt[siz << 1];

inline void addEdge(int x, int y)
{
    nt[edges] = hd[x]; to[edges] = y; hd[x] = edges++;
    nt[edges] = hd[y]; to[edges] = x; hd[y] = edges++;
}

int dfn;
int arv[siz];
int lev[siz];
int dep[siz];
int fa[siz][17];

void preworkDFS(int u, int f)
{
    arv[u] = ++dfn;
    
    for (int i = 1; i <= 16; ++i)
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
        
    for (int i = hd[u], v; ~i; i = nt[i])
        if ((v = to[i]) != f)
        {
            fa[v][0] = u;
            dep[v] = dep[u] + 1;
            preworkDFS(v, u);
        }
        
    lev[u] = dfn + 1;
}

inline int lca(int a, int b)
{
    if (dep[a] < dep[b])
        a ^= b ^= a ^= b;
        
    for (int i = 16; i >= 0; --i)
        if (dep[fa[a][i]] >= dep[b])
            a = fa[a][i];
            
    if (a == b)return a;
    
    for (int i = 16; i >= 0; --i)
        if (fa[a][i] != fa[b][i])
            a = fa[a][i], b = fa[b][i];
            
    return fa[a][0];
}

int cnt;
int root[siz];
int ls[siz * 80];
int rs[siz * 80];
int sm[siz * 80];

std::vector<int> add;
std::vector<int> sub;

inline void clear(void)
{
    add.clear();
    sub.clear();
}

void insert(int l, int r, int &t, int f, int p, int v)
{
    t = ++cnt;
    
    ls[t] = ls[f];
    rs[t] = rs[f];
    
    sm[t] = sm[f] + v;
    
    if (l != r)
    {
        int mid = (l + r) >> 1;
        
        if (p <= mid)
            rs[t] = rs[f], insert(l, mid, ls[t], ls[f], p, v);
        else
            ls[t] = ls[f], insert(mid + 1, r, rs[t], rs[f], p, v);
    }
}

int query(int l, int r, int k)
{
    if (l == r)return l;
    
    int mid = (l + r) >> 1, sn = 0, sr = 0;
    
    for (int i = 0; i < add.size(); ++i)sr += sm[rs[add[i]]], sn += sm[add[i]];
    for (int i = 0; i < sub.size(); ++i)sr -= sm[rs[sub[i]]], sn -= sm[sub[i]];
    
    if (sn < k)
        return -1;
    if (sr < k)
    {
        for (int i = 0; i < add.size(); ++i)add[i] = ls[add[i]];
        for (int i = 0; i < sub.size(); ++i)sub[i] = ls[sub[i]];
        
        return query(l, mid, k - sr);
    }
    else
    {
        for (int i = 0; i < add.size(); ++i)add[i] = rs[add[i]];
        for (int i = 0; i < sub.size(); ++i)sub[i] = rs[sub[i]];
        
        return query(mid + 1, r, k);
    }
}

int bit[siz];

inline void modify(int t, int p, int d)
{
    for (int i = t; i <= dfn; i += i&-i)
        insert(1, tot, bit[i], bit[i], p, d);
}

inline void addQuery(int t)
{
    add.push_back(root[t]);
    
    for (int i = arv[t]; i; i -= i&-i)
        add.push_back(bit[i]);
}

inline void subQuery(int t)
{
    sub.push_back(root[t]);
    
    for (int i = arv[t]; i; i -= i&-i)
        sub.push_back(bit[i]);
}

void buildDFS(int u, int f)
{
    insert(1, tot, root[u], root[f], tim[u], 1);
    
    for (int i = hd[u]; ~i; i = nt[i])
        if (to[i] != f)buildDFS(to[i], u);
}

signed main(void)
{
    N = nextInt();
    M = nextInt();
    
    for (int i = 0; i <= N; ++i)
        hd[i] = -1;
    
    for (int i = 1; i <= N; ++i)
        tim[i] = map[++tot] = nextInt();
        
    for (int i = 1; i < N; ++i)
        addEdge(nextInt(), nextInt());
        
    for (int i = 1; i <= M; ++i)
    {
        opt[i] = nextInt();
        opx[i] = nextInt();
        opy[i] = nextInt();
        
        if (!opt[i])
            map[++tot] = opy[i];
    }
    
    std::sort(map + 1, map + tot + 1);
    
    tot = std::unique(map + 1, map + tot + 1) - map - 1;
    
    for (int i = 1; i <= N; ++i)
        tim[i] = std::lower_bound(map + 1, map + tot + 1, tim[i]) - map;
        
    for (int i = 1; i <= M; ++i)if (!opt[i])
        opy[i] = std::lower_bound(map + 1, map + tot + 1, opy[i]) - map;
            
    preworkDFS(1, 0); buildDFS(1, 0);
    
    for (int i = 1; i <= M; ++i)
        if (!opt[i])
        {
            int x = opx[i];
            int y = opy[i];
            
            modify(arv[x], tim[x], -1);
            modify(lev[x], tim[x], +1);
            
            tim[x] = y;
            
            modify(arv[x], tim[x], +1);
            modify(lev[x], tim[x], -1);
        }
        else
        {
            clear();

            int x = opx[i];
            int y = opy[i];
            int t = lca(x, y);
            
            addQuery(x);
            addQuery(y);
            subQuery(t);
            subQuery(fa[t][0]);
            
            int ans = query(1, tot, opt[i]);
            
            if (ans == -1)
                puts("invalid request!");
            else
                printf("%d
", map[ans]);
        }
}

@Author: YouSiki