[th04]秋静叶&秋穣子-博弈论

秋静叶&秋穣子

Description

在幻想乡，秋姐妹是掌管秋天的神明，作为红叶之神的姐姐静叶和作为丰收之神的妹妹穰子。如果把红叶和果实联系在一起，自然会想到烤红薯。烤红薯需要很多的叶子，才能把红薯烤得很香，所以秋姐妹决定比比谁能够收集到最多的红叶。静叶将红叶分成了N堆(编号1..N)，并且规定了它们的选取顺序，刚好形成一颗有向树。在游戏过程中，两人从根节点开始，轮流取走红叶，当一个人取走节点i的红叶后，另一个人只能从节点i的儿子节点中选取一个。当取到某个叶子时游戏结束，然后两人会比较自己得到的红叶数量。已知两人采用的策略不一样，静叶考虑在让穰子取得尽可能少的前提下，自己取的最多；而穰子想得是在自己尽可能取得多的前提下，让静叶取得最少。在两人都采取最优策略的情况下，请你计算出游戏结束时两人的红叶数量。
游戏总是静叶先取，保证只存在一组解。

Input Description

第1行：1个正整数N，表示红叶堆数
第2行：N个整数，第i个数表示第i堆红叶的数量num[i]
第3..N+1行：2个正整数u,v，表示节点u为节点v的父亲

Output Description

第1行：2个整数，分别表示静叶取到的叶子数和穰子取到的叶子数

Sample Input

6
4 16 16 5 3 1
1 2
2 4
1 3
3 5
3 6

Sample Output

7 16

数据范围

　　对于30%的数据：1 ≤ N ≤ 100，1 ≤ num[i] ≤ 100
　　对于60%的数据：1 ≤ N ≤ 10,000，1 ≤ num[i] ≤ 10,000
　　对于100%的数据：1 ≤ N ≤ 100,000，1 ≤ num[i] ≤ 10,000

提示

　　样例解释：
　　首先静叶一定能取得节点1的4片红叶，留给穰子的是节点2和3，均为16片红叶。
　　若选取节点2则静叶下一次可以最多得到5片红叶，而选择3静叶最多也只能得到3片红叶，
　　所以此时穰子会选择节点3，故静叶最后得到的红叶数为7，穰子为16。

注意：
　　保证两人得到的红叶数在[0, 2^31-1]。

---

秋姐妹~~~

不人气姐妹竟然会有题目……
难道人气上升了???
虽然原标题的”穰”字打错了……
算了咱跟着打错吧……果然还是不人气啊……

---

咳咳，回归正题。
这是一道博弈论的题。
然而，我认为分类到”树形DP”上也没有丝毫问题~

思路:
DP啦~
开一个DP数组f[N][2]:
设当前节点为u，
f[u][0]表示以u为根子树先手最优值，f[u][1]表示后手最优值~
因为这对腹黑姐妹的缘故，应该是这样:
由于全局上是静叶先取，所以:
对于dep为奇数的情况:
f[u][0]=num[u]+f[v][1];
f[u][1]=f[v][0];
这里的v是u的儿子中下标0的值最大时下标1的结果最小的一个儿子~
对应某天真妹妹会优先保证自己取到的红叶最多再坑姐姐~
同理对于dep为偶数的情况:
f[u][0]=num[u]+f[v][1];
f[u][1]=f[v][0];
这里的v是u的儿子中下标1的值最小时下标0的结果最大的一个儿子~
对应某腹黑姐姐会优先选择调戏妹妹再保证自己的红叶数量~

这样DP一波就好了……吧？
然而栈溢出…..
于是手写栈!
具体方式是设置一个回溯标记记录这次对这个元素的访问是不是一次回溯，分开回溯部分和前半部分即可~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int Inf=0x7fffffff;

inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')
    {
        x=(x<<1)+(x<<3)+(ch^48);
        ch=getchar();
    }
    return x;
}

const int N=100233;

int n,num[N],f[N][2];
int to[N<<1],nxt[N<<1],beg[N],tot;

void add(int u,int v)
{
    to[++tot]=v;
    nxt[tot]=beg[u];
    beg[u]=tot;
}

int dep[N],stk[N],top;
bool first_part[N],as[N],af[N];

void dfs(int root)
{
    stk[top=1]=root;
    dep[root]=1;
    while(top)
    {
        int u=stk[top];

        if(!af[u])
        {
            f[u][0]=num[u];
            top--;
            continue;
        }

        if(!first_part[u])
        {
            for(int i=beg[u],v;i;i=nxt[i])
            {
                stk[++top]=(v=to[i]);
                dep[v]=dep[u]^1;
            }

            first_part[u]=1;
            continue;
        }

        //second part
        int mn=Inf,mx=-1,tar=0;
        if(dep[u])
        {
            for(int i=beg[u],v;i;i=nxt[i])
                if(f[v=to[i]][0]>mx || (f[v][0]==mx && f[v][1]<mn))
                    mx=f[v][0],mn=f[v][1],tar=v;
        }
        else
        {
            for(int i=beg[u],v;i;i=nxt[i])
                if(f[v=to[i]][1]<mn || (f[v][1]==mn && f[v][0]>mx))
                    mn=f[v][1],mx=f[v][0],tar=v;
        }
        f[u][0]=f[tar][1]+num[u];
        f[u][1]=f[tar][0];
        top--;
    }
}

int main()
{
    n=read();
    for(int i=1;i<=n;i++)
        num[i]=read();

    for(int i=1,u,v;i<n;i++)
    {
        u=read();v=read();
        add(u,v);
        as[v]=1;af[u]=1;
    }

    int root=0;
    for(int i=1;i<=n;i++)
        if(!as[i])
        {
            root=i;
            break;
        }

    dfs(root);

    printf("%d %d\n",f[root][0],f[root][1]);

    return 0;
}