BZOJ 3611: [Heoi2014]大工程

3611: [Heoi2014]大工程

Time Limit: 60 Sec  Memory Limit: 512 MB
Submit: 1101  Solved: 478
[Submit][Status][Discuss]

Description

国家有一个大工程，要给一个非常大的交通网络里建一些新的通道。 

我们这个国家位置非常特殊，可以看成是一个单位边权的树，城市位于顶点上。 

在 2 个国家 a,b 之间建一条新通道需要的代价为树上 a,b 的最短路径。

 现在国家有很多个计划，每个计划都是这样，我们选中了 k 个点，然后在它们两两之间 新建 C(k,2)条 新通道。

现在对于每个计划，我们想知道：

 1.这些新通道的代价和

 2.这些新通道中代价最小的是多少 

3.这些新通道中代价最大的是多少

 

Input

第一行 n 表示点数。

 接下来 n-1 行，每行两个数 a,b 表示 a 和 b 之间有一条边。

点从 1 开始标号。 接下来一行 q 表示计划数。

对每个计划有 2 行，第一行 k 表示这个计划选中了几个点。

 第二行用空格隔开的 k 个互不相同的数表示选了哪 k 个点。

 

Output

输出 q 行，每行三个数分别表示代价和，最小代价，最大代价。 

 

Sample Input

10
2 1
3 2
4 1
5 2
6 4
7 5
8 6
9 7
10 9
5
2
5 4
2
10 4
2
5 2
2
6 1
2
6 1

Sample Output

3 3 3
6 6 6
1 1 1
2 2 2
2 2 2

HINT

n<=1000000 

q<=50000并且保证所有k之和<=2*n 

Source

鸣谢佚名上传

[Submit][Status][Discuss]

建出虚树，树形DP

#include <bits/stdc++.h>

namespace scanner
{
    inline char nextChar(void)
    {
        static const int siz = 1 << 20;
        
        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 bool neg = false;
        register char bit = nextChar();
        
        for (; bit < 48; bit = nextChar())
            if (bit == '-')neg ^= true;
        
        for (; bit > 47; bit = nextChar())
            ret = ret * 10 + bit - '0';
        
        return neg ? -ret : ret;
    }
}

const int inf = 1e9;

const int maxn = 2000005;
const int maxm = 5000005;

struct graph
{
    int hd[maxn], to[maxm], nt[maxm], tot;
    
    inline graph(void)
    {
        tot = top = 0;
        memset(hd, 0, sizeof(hd));
        memset(marked, 0, sizeof(marked));
    }
    
    inline void addEdge(int x, int y)
    {
        nt[++tot] = hd[x]; to[tot] = y; hd[x] = tot;
        nt[++tot] = hd[y]; to[tot] = x; hd[y] = tot;
        
        markPoint(x);
        markPoint(y);
    }
    
    int used[maxn], marked[maxn], top;
    
    inline void markPoint(int t)
    {
        if (!marked[t])used[++top] = t, marked[t] = true;
    }
    
    inline void recovery(void)
    {
        while (top)
        {
            int t = used[top--];
            marked[t] = false;
            hd[t] = 0;
        }
    }
};

struct boolean
{
    bool s[maxn];
    
    inline boolean(void)
    {
        top = 0;
        memset(s, 0, sizeof(s));
        memset(marked, 0, sizeof(marked));
    }
    
    inline void mark(int t)
    {
        s[t] = true;
        
        markPoint(t);
    }
    
    int used[maxn], marked[maxn], top;
    
    inline void markPoint(int t)
    {
        if (!marked[t])used[++top] = t, marked[t] = true;
    }
    
    inline void recovery(void)
    {
        while (top)
        {
            int t = used[top--];
            marked[t] = false;
            s[t] = false;
        }
    }
    
    inline bool operator [] (int t)
    {
        return s[t];
    }
};

int n, m;

graph src;
graph use;

int dfn[maxn], dep[maxn], fa[maxn][21];

void preworkDfs(graph &g, int u, int f)
{
    static int tim = 0;
    
    dfn[u] = ++tim;
    dep[u] = dep[f] + 1;
    
    fa[u][0] = f;
    
    for (int i = 1; i <= 20; ++i)
        fa[u][i] = fa[fa[u][i - 1]][i - 1];
    
    for (int i = g.hd[u]; i; i = g.nt[i])
        if (f != g.to[i])preworkDfs(g, g.to[i], u);
}

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

inline bool cmpDfn(int a, int b)
{
    return dfn[a] < dfn[b];
}

boolean mrk;

struct stack
{
    int s[maxn], tot;
    
    inline void push(int t)
    {
        s[++tot] = t;
    }
    
    inline void pop(void)
    {
        if (tot)--tot;
    }
    
    inline int top(void)
    {
        return s[tot];
    }
    
    inline int tat(void)
    {
        return s[tot - 1];
    }
    
    inline int size(void)
    {
        return tot;
    }
    
    inline bool empty(void)
    {
        return tot == 0;
    }
    
    inline void clear(void)
    {
        tot = 0;
    }
};

stack stk;

typedef long long lnt;

struct answer
{
    int maxi;
    int mini;
    
    inline void setup(void)
    {
        maxi = 0;
        mini = inf;
    }
    
    inline void updateMin(int t)
    {
        if (mini > t)
            mini = t;
    }
    
    inline void updateMax(int t)
    {
        if (maxi < t)
            maxi = t;
    }
}ans;

lnt all, dp[maxn], sz[maxn];

int maxPath[maxn];
int minPath[maxn];

void getansDfs(graph &g, int u, int f)
{
    dp[u] = 0LL;
    sz[u] = mrk[u];
    maxPath[u] = 0;
    minPath[u] = inf;
    
    for (int i = g.hd[u]; i; i = g.nt[i])
        if (g.to[i] != f)
        {
            int v = g.to[i];
            int d = dep[v] - dep[u];
            
            getansDfs(g, v, u);
            
            sz[u] += sz[v];
            dp[u] += dp[v];
            dp[u] += sz[v] * (all - sz[v]) * d;
            
            ans.updateMin(minPath[v] + minPath[u] + d);
            ans.updateMax(maxPath[v] + maxPath[u] + d);
            
            if (minPath[u] > minPath[v] + d)
                minPath[u] = minPath[v] + d;
            
            if (maxPath[u] < maxPath[v] + d)
                maxPath[u] = maxPath[v] + d;
        }
    
    if (mrk[u])
    {
        ans.updateMin(minPath[u]);
        ans.updateMax(maxPath[u]);
        
        minPath[u] = 0;
    }
}

signed main(void)
{
    n = scanner::nextInt();
    
    for (int i = 1; i < n; ++i)
    {
        int x = scanner::nextInt();
        int y = scanner::nextInt();
        
        src.addEdge(x, y);
    }
    
    preworkDfs(src, 1, 0);
    
    m = scanner::nextInt();
    
    while (m--)
    {
        static int k, p[maxn];
        
        k = scanner::nextInt();
        
        for (int i = 1; i <= k; ++i)
            p[i] = scanner::nextInt();
        
        std::sort(p + 1, p + k + 1, cmpDfn);
        
        use.recovery();
        mrk.recovery();
        
        ans.setup();
        stk.clear();
        
        all = k;
        
        for (int i = 1; i <= k; ++i)
            mrk.mark(p[i]);
        
        for (int i = 1; i <= k; ++i)
        {
            if (!stk.empty())
            {
                int t = getLca(p[i], stk.top());
                
                while (dfn[t] < dfn[stk.top()])
                {
                    if (dfn[t] >= dfn[stk.tat()])
                    {
                        use.addEdge(t, stk.top()), stk.pop();
                        
                        if (stk.top() != t)
                            stk.push(t);
                        
                        break;
                    }
                    
                    use.addEdge(stk.top(), stk.tat()), stk.pop();
                }
            }
                
            stk.push(p[i]);
        }
        
        while (stk.size() > 1)
            use.addEdge(stk.top(), stk.tat()), stk.pop();
        
        getansDfs(use, stk.top(), 0);
        
        printf("%lld %d %d
", dp[stk.top()], ans.mini, ans.maxi);
    }
}

@Author: YouSiki