Codeforces Round #300 E. Demiurges Play Again

最新推荐文章于 2021-11-16 14:34:17 发布

原创最新推荐文章于 2021-11-16 14:34:17 发布 · 917 阅读

0 ·

CC 4.0 BY-SA版权

DFS 专栏收录该内容

5 篇文章

订阅专栏

本文探讨了一种包含N个节点的游戏树结构，其中M个节点为叶子节点，每个节点放置了一个从1到M的唯一整数。玩家从根节点开始，轮流将棋子移动到其子节点，直到棋子落在叶子节点上，该叶子节点上的数值即为最终得分。玩家分为两组，一组试图最大化得分，另一组则试图最小化得分。在游戏开始前，神明可以随意调整叶子节点的数值排列。文章分析了在神明最优调整下，最终得分的最大值和最小值。

Demiurges Shambambukli and Mazukta love to watch the games of ordinary people. Today, they noticed two men who play the following game.

There is a rooted tree on n nodes, m of which are leaves (a leaf is a nodes that does not have any children), edges of the tree are directed from parent to children. In the leaves of the tree integers from 1 tom are placed in such a way that each number appears exactly in one leaf.

Initially, the root of the tree contains a piece. Two players move this piece in turns, during a move a player moves the piece from its current nodes to one of its children; if the player can not make a move, the game ends immediately. Theresult of the game is the number placed in the leaf where a piece has completed its movement. The player who makes the first move tries to maximize the result of the game and the second player, on the contrary, tries to minimize the result. We can assume that both players move optimally well.

Demiurges are omnipotent, so before the game they can arbitrarily rearrange the numbers placed in the leaves. Shambambukli wants to rearrange numbers so that the result of the game when both players play optimally well is as large as possible, and Mazukta wants the result to be as small as possible. What will be the outcome of the game, if the numbers are rearranged by Shambambukli, and what will it be if the numbers are rearranged by Mazukta? Of course, the Demiurges choose the best possible option of arranging numbers.

Input

The first line contains a single integer n — the number of nodes in the tree (1 ≤ n ≤ 2·10⁵).

Each of the next n - 1 lines contains two integersu_i andv_i (1 ≤ u_i, v_i ≤ n) — the ends of the edge of the tree; the edge leads from node u_i to nodev_i. It is guaranteed that the described graph is a rooted tree, and the root is the node 1.

Output

Print two space-separated integers — the maximum possible and the minimum possible result of the game.

给一棵树，叶子节点权值1-N，从根开始，两个人轮流走，一人走一步，走到某个叶子结点就停止，得到叶子结点的权值。第一个人会往使权值尽量大的方向走，第二个人会往权值尽量小的方向走，两个人都足够聪明。叶子结点的权值可以任意排序，问最后能得到的最大值和最小值是多少。

把权值从大到小编号，f[u]表示当前在结点u，能得到的最小编号。g[u]表示当前在结点u，能得到的最大编号。那么v是u的子结点，f[u]=min(g[u])，g[u]=sum(f[v])。当u是叶子结点时，f[u]=g[u]=1。

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;

const int MAXN=200010;

int N,M;

vector<int> G[MAXN];
int g[MAXN],f[MAXN];

void dfs(int u){
    int len=G[u].size();
    if(len<=0){
        f[u]=g[u]=1;
        M++;
        return;
    }
    f[u]=INF;
    g[u]=0;
    for(int i=0;i<len;i++){
        int v=G[u][i];
        dfs(v);
        f[u]=min(f[u],g[v]);
        g[u]+=f[v];
    }
}

int main(){
    freopen("in.txt","r",stdin);
    while(scanf("%d",&N)!=EOF){
        for(int i=1;i<=N;i++) G[i].clear();
        int u,v;
        for(int i=0;i<N-1;i++){
            scanf("%d%d",&u,&v);
            G[u].push_back(v);
        }
        M=0;
        dfs(1);
        printf("%d %d\n",M-f[1]+1,g[1]);
    }
    return 0;
}