口胡题fr

T1
五种贡献恶心的要死。
$1.grand$
$2.father$
$3.brother$
$4.son$
$5.grandson$
我们选择维护三个量。
1.儿子和,$sx$
2.孙子和,$gsx$
3.自己的值,$a$
那么每次修改只需要修改自己的值，父亲的儿子和，爷爷的孙子和即可,注意儿子和孙子分开考虑。
那么查询的时候。设当前点为$x$,父亲为$f$,爷爷为$g$.
那么答案就是

$$ans=a[x]\ xor\ sx[x]\ xor\ gsx[x]\ xor\ sx[fa]\ xor\ a[x]\ xor\ a[g]$$

T2.

看一下数据范围：猜一下是$O(3^n)$

子集题我首先考虑了子集反演。

设$g[S]$为交集是$S$的子集情况下的方案数，$f[S]$是恰好的方案数。

$$g[S]=\sum\limits_{T\subseteq S}f[T]$$

反演得到。

$$f[S]=\sum\limits_{T\subseteq S}(-1)^{\left|S\right|-\left|T\right|}g[T]$$

发现根本不可做，因为交集是子集的集合根本算不出来。

考虑补集容斥。

那么我们需要让两个点能到的点没有交集即可。

因为两个点必然有自己能到的范围，所以枚举到达集合，然后让两个集合之间没有交点就可以了。

考虑构造这样两个集合，并算出方案。

$dp[S]$让$1$到达$S$中的点的方案数。

$g[S]$让$2$到达的方案数。

预处理数组$e[S]$为$S$中的边数。

设$mx$为全集。

枚举$1$所在的集合$T$得到：

$$dp[S]=2^{e[S]}-\sum\limits_{T\subseteq S}dp[T]2^{e[S\ xor\ T]}$$

$g$的转移也类似。

在统计答案的时候，枚举全集的子集$S$，同时枚举$S$补集的子集，同样原理转移即可。

$$ans=2^{e[mx]}-\sum\limits_{S\subseteq mx}\sum\limits_{T\subseteq mx\ xor\ S}dp[S]g[T]2^{e[mx\ xor\ S\ xor\ T]}$$

复杂度是$O(3^n)$

和wmz的暴力对拍结果,n=8,m=22。

T3不会.

D2T1.

其实就是只有以下一种情况是最优的，每个点有且仅有一条边没有被查看，并且这些边的和最大且为$S$

$$ans=\sum\limits{i=1}^{m}w_i-S$$

发现这些没有被查看的边形成了一颗最大生成树。

总权减树权即可。

复杂度$O(mlogm)$

D2T2.

其实是个比菜肴制作还简单的菜肴制作。

我们首先算出每个点的点权$dep[x]+a[x]$。

然后建反图跑堆拓扑即可。

原本我们是想让权值大的尽量考前。

而反图这种情况等价于让点权最小的尽量靠后，那么我们可以这样跑拓扑。

假设某个点是倒数第$i$个到达的，那么每个点权更新答案的值就是：$n-i+a[x]$。

时间复杂度$O(nlogn)$

和爆搜对拍过了n=10的点。

和wmz乱搞对拍过了n=300000,INF=1e9的点。

#include<iostream>
#include<cstdio>
using namespace std;
inline void read(int &x)
{
    x=;char c=getchar();
    ') c=getchar();
    )+(x<<)+c-,c=getchar();
}
<<|,maxn=,mod=1e9+;
],e[bitn],dp[][bitn],bin[maxn],hs[bitn];
int add(int x,int y) {return x+y>=mod?x+y-mod:x+y;}
int mul(int x,int y) {return 1LL*x*y%mod;}
?x-y+mod:x-y;}
void print(int s)
{
    ;i<=n;++i)
        ]) putchar(');
        ');
}
int main()
{
    read(n);read(m);
    ]=;i<=max(n,m);++i) bin[i]=mul(bin[i-],);
    ;i<=m;++i) read(op[i][]),read(op[i][]);
    <<n)-;
    ;s<=mx;++s)
        ;i<=m;++i)
        {
            ]-])&&(s&bin[op[i][]-])) ++e[s];
            ]-]) hs[s]|=bin[op[i][]-];
            ]-]) hs[s]|=bin[op[i][]-];
        }
    ;st<=;++st)
        ;s<=mx;++s)
            ]))
            {
                dp[st][s]=bin[e[s]];
                )&s;t;t=(t-)&s)
                    if(t&bin[st])
                        dp[st][s]=dic(dp[st][s],mul(dp[st][t],bin[e[s^t]]));
            }
    ans=bin[e[mx]];
    ;s<=mx;++s)
        ])&&!(s&bin[]))
            )&(mx^s))
                ])&&!(hs[s]&t))
                    ans=dic(ans,mul(mul(dp[][s],dp[][t]),bin[e[mx^s^t]]));
    printf("%d\n",ans);
    ;
}

国际影星

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
;
inline void read(int &x)
{
    x=;char c=getchar();
    ') c=getchar();
    )+(x<<)+c-,c=getchar();
}
int ans,n,tot,a[maxn],first[maxn],f[maxn],d[maxn];
struct Road{
    int u,t,nxt;
}eage[maxn<<];
void add(int x,int y) {eage[++tot]=(Road){x,y,first[x]};first[x]=tot;}
struct st{
    int id,x;
    bool friend operator < (const st a,const st b) {return a.x>b.x;}
};
priority_queue<st> q;
void dfs(int x,int fa,int d)
{
    a[x]+=d;f[x]=fa;
    for(int i=first[x];i;i=eage[i].nxt)
        if(eage[i].t!=fa)
            dfs(eage[i].t,x,d+);
}
void topsort()
{
    int cnt=n;
    q.push((st){,a[]});
    while(!q.empty())
    {
        st x=q.top();q.pop();--cnt;
        ans=max(ans,cnt+a[x.id]);
        for(int i=first[x.id];i;i=eage[i].nxt)
        {
            --d[eage[i].t];
            if(!d[eage[i].t]) q.push((st){eage[i].t,a[eage[i].t]});
        }
    }
}
int main()
{
//    freopen("ans.in","r",stdin);
//    freopen("c.out","w",stdout);
    read(n);
    ;i<=n;++i) read(a[i]);
    ,x,y;i<n;++i)
    {
        read(x);read(y);
        add(x,y);add(y,x);
    }
    dfs(,,);
    tot=;
    memset(first,,sizeof(first));
    ;i<=n;++i) add(f[i],i),++d[i];
    topsort();
    printf("%d\n",ans);
    ;
}