NOIP模拟67

T1;

　　简化问题，比较容易得到排序策略，然而这种排序策略仅局限于子节点决策

考虑直观想法显然为树形DP，然而是错的，考虑问题在于本题的选择策略并不是连续的

也就是并不一定选择完一个子树再选择下一个

　　这也启示我们树形DP的局限性，即问题必须具有连续性与可合并性

　　考虑修正，既然选择不一定是连续的，那么我们就每次选择最优选项进行合并

即通过同样的排序策略，每次全局寻找最优点与父亲进行合并代表选择父亲后要选择它

每次更新父亲的排序关键字，利用优先队列或set维护即可

　　考虑一种贪心的假做法，即每次从根开始从子节点中选择最优点并更新子节点序列

问题仍然在于贪心的短视性，而正解通过合并再更新父节点的关键字则可以解决这一问题

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define I long long
#define C char
#define B bool
#define V void
#define D double
#define LL long long
#define UI unsigned int
#define UL unsigned long long
#define P pair<I,I>
#define MP make_pair
#define a first
#define b second
#define lowbit(x) (x & -x)
#define debug cout << "It's Ok Here !" << endl;
#define FP(x) freopen (#x,"r",stdin)
#define FC(x) freopen (#x,"w",stdout)
const I N = 3e5 + 3;
I n,f[N],sigma,ans;
struct T {I idx,a,b;} a[N];
multiset <T> s;
inline I read () {
    I x(0),y(1); C z(getchar());
    while (!isdigit(z)) { if (z == '-') y = -1; z = getchar(); }
    while ( isdigit(z))  x = x * 10 + (z ^ 48), z = getchar();
    return x * y;
}
inline V Max (I &a,I b) { a = a > b ? a : b; }
inline V Min (I &a,I b) { a = a < b ? a : b; }
inline I max (I a,I b) { return a > b ? a : b; }
inline I min (I a,I b) { return a < b ? a : b; }
inline V swap (I &a,I &b) { a ^= b, b ^= a, a ^= b; }
inline I abs (I a) { return a >= 0 ? a : -a; }
inline P operator + (const P &a,const P &b) {
    return MP (a.a + b.a,a.b + b.b);
}
inline P operator - (const P &a,const P &b) {
    return MP (a.a - b.a,a.b - b.b);
}
inline B operator < (const T &a,const T &b) {
    return a.b * b.a == b.b * a.a ? a.idx < b.idx : a.b * b.a < b.b * a.a;
}
struct DJS {
    I f[N];
    inline V initital () {
        for (I i(1);i <= n; ++ i) f[i] = i;
    }
    I get (I x) {
        return x == f[x] ? x : f[x] = get (f[x]);
    }
    inline V merge (I x,I y) {
        if (x == y) return ;
        I fx (get (x)), fy (get (y));
        if (fx == fy) return ; 
        f[fy] = fx; if (fx != 1) s.erase (s.find (a[fx]));
        a[fx].a += a[fy].a, a[fx].b += a[fy].b; if (fx != 1) s.insert (a[fx]);
    }
}DJS;
signed main () {
    n = read (); DJS.initital ();
    for (I i(2);i <= n; ++ i) 
        f[i] = read ();
    for (I i(1);i <= n; ++ i) 
        a[i].idx = i, a[i].a = read (), a[i].b = read ();
    for (I i(2);i <= n; ++ i)
        sigma += a[i].a, s.insert (a[i]);
    ans += a[1].b * sigma;
    for (I i(1);i <  n; ++ i) {
        auto it = -- s.end (); s.erase (it); T x (*it); I tmp (DJS.get (f[x.idx]));
        ans += tmp == 1 ? a[x.idx].b * (sigma - a[x.idx].a), sigma -= a[x.idx].a : a[tmp].b * a[x.idx].a;
        DJS.merge (f[x.idx],x.idx);  
    }
    printf ("%lld\n",ans);
}

T2：

　　考虑突破点在于如何判断合法性，显然若子树总a值 >= 子树size则可行，那么考虑可行下的方案数

显然为子树总a值 - 子树总size即为rest，考虑树形DP子树合并，首先直接继承子节点方案数，考虑子节点

间合并所产生的方案数，考虑首先选择子节点上部节点一定在子节点下部节点之前，那么分开考虑

于是方案数显然为子树合并过程中顺序不同所产生的方案数，即对于相对顺序相同的序列x，y，其合并方案数

为C(x + y,y)，于是在合并过程中记录最终累加即可

代码如下：

#include <bits/stdc++.h>
using namespace std;
#define I long long
#define C char
#define B bool
#define V void
#define D double
#define LL long long
#define UI unsigned int
#define UL unsigned long long
#define P pair<I,I>
#define MP make_pair
#define a first
#define b second
#define lowbit(x) (x & -x)
#define debug cout << "It's Ok Here !" << endl;
#define FP(x) freopen (#x,"r",stdin)
#define FC(x) freopen (#x,"w",stdout)
const I N = 1e6 + 3, mod = 1e9 + 7;
I n,f[N],a[N],J[N],Y[N],size[N],dp[N];
I tot,to[N << 1],nxt[N << 1],head[N];
inline I read () {
    I x(0),y(1); C z(getchar());
    while (!isdigit(z)) { if (z == '-') y = -1; z = getchar(); }
    while ( isdigit(z))  x = x * 10 + (z ^ 48), z = getchar();
    return x * y;
}
inline V Max (D &a,D b) { a = a > b ? a : b; }
inline V Min (D &a,D b) { a = a < b ? a : b; }
inline D max (D a,D b) { return a > b ? a : b; }
inline D min (D a,D b) { return a < b ? a : b; }
inline V swap (I &a,I &b) { a ^= b, b ^= a, a ^= b; }
inline I abs (I a) { return a >= 0 ? a : -a; }
inline P operator + (const P &a,const P &b) {
    return MP (a.a + b.a,a.b + b.b);
}
inline P operator - (const P &a,const P &b) {
    return MP (a.a - b.a,a.b - b.b);
}
inline V found (I x,I y) {
    to[++tot] = y, nxt[tot] = head[x], head[x] = tot;
    to[++tot] = x, nxt[tot] = head[y], head[y] = tot;
}
inline I fp (I a,I b) { I ans (1);
    for (; b ;b >>= 1,a = a * a % mod)
        if(b & 1) ans = ans * a % mod;
    return ans;
}
inline I _C (I n,I m) {
    return J[n] * Y[m] % mod * Y[n - m] % mod;
}
V Dfs (I x) {
    I tmp1 (1), tmp2 (1); size[x] = dp[x] = 1; 
    for (I i(head[x]),y(to[i]); i ;i = nxt[i],y = to[i]) if (y != f[x]) {
        Dfs (y), size[x] += size[y]; a[x] += a[y]; (dp[x] *= dp[y]) %= mod; 
        (tmp1 *= _C (a[x] - size[x] + 1,a[y] - size[y])) %= mod;  
        (tmp2 *= _C (size[x] - 1,size[y])) %= mod;
    }                      
    (dp[x] *= tmp1 * tmp2 % mod) %= mod;
}
signed main () {
    FP (ball.in), FC (ball.out);
    n = read ();
    for (I i(2);i <= n; ++ i)
        found (f[i] = read (),i);
    for (I i(1);i <= n; ++ i) 
        a[i] = read ();
    J[0] = Y[0] = 1;
    for (I i(1);i <= n; ++ i)
        J[i] = J[i - 1] * i % mod;
    Y[n] = fp (J[n],mod - 2);
    for (I i(n - 1); i; -- i)
        Y[i] = Y[i + 1] * (i + 1) % mod;
    Dfs (1);
    for (I i(1);i <= n; ++ i)
        cout << i << " : " << dp[i] << endl;
    printf ("%lld\n",dp[1]);
}