【题解】PKUWC2018简要题解
Minimax
定义结点x的权值为：
1.若x没有子结点，那么它的权值会在输入里给出，保证这类点中每个结点的权值互不相同。
2.若x有子结点，那么它的权值有p的概率是它的子结点的权值的最大值，有1-p的概率是它的子结点的权值的最小值。
1号点权值第i小的可能性的权值是\(V_i\)，它的概率为 ，求：
\[ \sum i V_iD_i^2 \]
\(n\le 3e5\)
先离散化一下所有叶子节点的值，然后考虑一个DP
\(dp(i,j)\)表示在\(i\)点权值是第\(j\)小的概率，只有一个儿子的时候直接转移过来，转移很显然就不写了
然后考虑线段树合并维护这个过程，因为转移时是乘上一段后缀/前缀，同时线段树合并可以获得好的效果。
考虑一下时间复杂度，就是线段树合并的复杂度\(O(n\log n)\)
//@winlere
#include
#include
#include
#include
#include
#define mid ((l+r)>>1)
#define pp(pos) {seg[pos].val=MOD(seg[seg[pos].ls].val+seg[seg[pos].rs].val);}
using namespace std; typedef long long ll; char __buf[1<<22],*__c=__buf;
inline int qr(){
int ret=0,f=0,c=*__c++;
while(!isdigit(c))f|=c==45,c=*__c++;
while(isdigit(c)) ret=ret*10+c-48,c=*__c++;
return f?-ret:ret;
}
const int mod=998244353;
const int maxn=3e5+5;
inline int ksm(const int&ba,const int&p){
int ret=1;
for(int t=p,b=ba%mod;t;t>>=1,b=1ll*b*b%mod)
if(t&1) ret=1ll*ret*b%mod;
return ret;
}
const int baseinv=ksm(1e4,mod-2);
int e[maxn][2];
struct E{
int ls,rs,val,tag;
E(const int&a=0,const int&b=0,const int&c=0,const int&d=1):ls(a),rs(b),val(c),tag(d){}
inline E&operator *=(ll a){return *this=E(ls,rs,val*a%mod,tag*a%mod);}
}*seg;
inline void pd(const int&pos){
if(seg[pos].tag==1) return;
seg[seg[pos].ls]*=seg[pos].tag;
seg[seg[pos].rs]*=seg[pos].tag;
seg[pos].tag=1;
}
inline int MOD(const int&x){return x>mod?x-mod:x;}
int rt[maxn],n,w[maxn],sav[maxn],ans,cnt,len;
struct vec{
int data[2];
inline int&operator[](int x){return data[x];}
};
//p0=ch max p1=ch min
int Merge(vec t,vec pre,vec suf,vec p){
if(!t[0]||!t[1]){
register int k=t[1]>0;
seg[t[k]]*=1ll*p[0]*pre[k^1]%mod+1ll*p[1]*suf[k^1]%mod;
return t[k];
}
pd(t[0]); pd(t[1]);
vec P=pre,S=suf;
for(int i=0;i<=1;++i)
pre[i]=MOD(pre[i]+seg[seg[t[i]].ls].val),suf[i]=MOD(suf[i]+seg[seg[t[i]].rs].val);
seg[t[0]].ls=Merge({seg[t[0]].ls,seg[t[1]].ls},P,suf,p);
seg[t[0]].rs=Merge({seg[t[0]].rs,seg[t[1]].rs},pre,S,p);
pp(t[0]);
return t[0];
}
void build(int p,int l,int r,int&pos){
if(pr) return;
if(!pos) seg[pos=++cnt]=E();
if(l==r){seg[pos].val=1;return;}
if(p<=mid) build(p,l,mid,seg[pos].ls);
else build(p,mid+1,r,seg[pos].rs);
pp(pos);
}
void dfs(const int&now){
if(!e[now][0]) return build(w[now],1,len,rt[now]);
if(!e[now][1]) return dfs(e[now][0]),rt[now]=rt[e[now][0]],void();
dfs(e[now][0]); dfs(e[now][1]);
rt[now]=Merge({rt[e[now][0]],rt[e[now][1]]},{0,0},{0,0},{w[now],mod-w[now]+1});
}
void que(int l,int r,int pos){
if(l==r){ans=(ans+1ll*seg[pos].val*seg[pos].val%mod*l%mod*sav[l]%mod)%mod;return;}
pd(pos);
que(l,mid,seg[pos].ls),que(mid+1,r,seg[pos].rs);
}
int main(){
fread(__c=__buf,1,1<<22,stdin);
n=qr(); qr();
seg=(E*)malloc(sizeof(E)*n*18.2);
for(int t=2,a;t<=n;++t)
a=qr(),(e[a][0]?e[a][1]:e[a][0])=t;
for(int t=1;t<=n;++t){
w[t]=qr();
if(e[t][0]) w[t]=1ll*w[t]*baseinv%mod;
else sav[++len]=w[t];
}
sort(sav+1,sav+len+1);
for(int t=1;t<=n;++t)
if(!e[t][0])
w[t]=lower_bound(sav+1,sav+len+1,w[t])-sav;
dfs(1);
que(1,len,1);
printf("%d\n",ans);
return 0;
}
Slay the Spire
你有\(n\)个攻击牌\(n\)个强化牌，都有权值，一种攻击牌的效果是进行面值攻击，一张强化牌的效果是将其他所有攻击牌的面值乘上他的面值\(>1\)。问你随意选出\(m\)张牌，可以打出\(k\)张牌，问你所有选出\(m\)张牌的方案的最大伤害的和是多少。
由于强化牌\(>1\)所以能打强化牌就打强化牌，最后剩下一个打攻击牌。很显然打攻击牌是打那些选出\(m\)个最大的那几个，那么将攻击牌序列排序，可能打的攻击牌是一个子序列。那么设\(dp(i,j)\)表示钦定\(i\)选中，选了\(j\)个的权值和，转移显然，要记前缀和。
那么如何处理强化牌呢？可以考虑到，强化牌最多可以打\(k-1\)张，再多是没有意义的，同样排序后，设\(f(i,j)\)表示选了钦定选择了\(i\)号牌，总共选择了\(j\)个牌的强化权值，(要记前缀和)。为了满足上面这个\(\le k-1\)的限制，我们钦定当强化牌数量\(> k-1\)的时候，接下来加入强化牌的权值都为1。这样，多选的强化牌就不会造成伤害的贡献，但是仍然可以贡献方案。
//@winlere
#include
#include
#include
#include
#include
using namespace std; typedef long long ll;
int qr(){
int ret=0,f=0,c=getchar();
while(!isdigit(c))f|=c==45,c=getchar();
while(isdigit(c)) ret=ret*10+c-48,c=getchar();
return f?-ret:ret;
}
const int mod=998244353;
const int maxn=3e3+15;
int st[maxn],w[maxn];
int dp[maxn][maxn];
int f[maxn][maxn];
int c[maxn][maxn];
int n,m,k,ans;
int MOD(const int&x){return x>=mod?x-mod:x;}
int MOD(const int&x,const int&y){return 1ll*x*y%mod;}
int main(){
n=3e3;
c[0][0]=1;
for(int t=1;t<=n;++t){
c[t][0]=1;
for(int i=1;i<=t;++i){
c[t][i]=MOD(c[t-1][i]+c[t-1][i-1]);
}
}
int T=qr();
while(T--){
n=qr(); m=qr(); k=qr();
for(int t=1;t<=n;++t) st[t]=qr();
for(int t=1;t<=n;++t) w[t]=qr();
sort(st+1,st+n+1,greater());
sort(w+1,w+n+1,greater());
ans=0;
f[0][0]=1;
for(int t=1;t<=n;++t){
dp[t][0]=dp[t-1][0];
f[t][0]=f[t-1][0];
for(int i=t;i;--i)
dp[t][i]=MOD(dp[t-1][i]+MOD(dp[t-1][i-1]+MOD(c[t-1][i-1],w[t])));
for(int i=1;i<=t;++i)
f[t][i]=MOD(f[t-1][i]+MOD(f[t-1][i-1],in||!s) continue;
for(int i=1;i<=n;++i)
if(n-i>=Cash-Pay)
ans=MOD(ans+MOD(s,MOD(c[n-i][Cash-Pay],dp[i][Pay]-dp[i-1][Pay]+mod)));
}
printf("%d\n",ans);
}
return 0;
}
斗地主
滚
随机算法
给出一个最大独立集的算法，问你这个东西的正确率：
- 随机一个排列
- 按照这个排列依次试图将点加入独立集
\(n\le 20\)
设\(dp(S)\)表示\(S\)集合是排列中前\(|S|\)个元素时，按上述算法在所有可能的顺序下能够算出独立集的大小\(=Max(S)\)的概率，Max(S)字面意思，所有可能中最大的独立集大小。那么考虑，枚举排列第一个元素是谁设为u，然后访问去除所有和\(u\)相连的点 的状态\(S'\)，那么贡献就是\(dp(S')\over popcnt(S)\) 。注意只能从所有\(Max(S')+1=Max(S)\)的状态转移来。
钦定统计第一个！！！！太有技巧性了
//@winlere
#include
#include
#include
#include
#define lb(t) ((t)&-(t))
using namespace std; typedef long long ll;
inline int qr(){
int ret=0,f=0,c=getchar();
while(!isdigit(c))f|=c==45,c=getchar();
while(isdigit(c)) ret=ret*10+c-48,c=getchar();
return f?-ret:ret;
}
const int maxn=20;
const int mod=998244353;
int e[maxn],n,m,u;
int dp[1<>=1,b=1ll*b*b%mod)
if(t&1) ret=1ll*ret*b%mod;
return ret;
}
inline int MOD(const int&x){return x>=mod?x-mod:x;}
int main(){
n=qr(); m=qr(); u=(1<Max[t]) dp[t]=dp[s],Max[t]=Max[s]+1;
else if(Max[s]+1==Max[t]) dp[t]=MOD(dp[t]+dp[s]);
}
dp[t]=1ll*dp[t]*invc[num[t]]%mod;
}
printf("%d\n",dp[u]);
return 0;
}
猎人杀
设\(dp(S)\)表示钦定\(S\)中的人在\(1\)号猎人之后死亡，其他人生死我们不管。可以知道在任何时刻，死掉\(S\)中的任何一个人的概率始终是死掉\(1\)号猎人的\(w_{ x\in S}\over w_1\)倍。注意\(1\not \in S\) 那么
\[ dp(S)={w_1\over w_{ x\in S}+w_1} \]
那么考虑题目给我们的条件，是要求\(1\)是最后一个死亡的概率，也就是不存在有人在他后面死亡。由于\(dp(S)\)是钦定，考虑容斥，答案就是
\[ \sum_{S\subseteq U-1} (-1)^{|S|+1} dp(S) \]
然后用背包优化容斥即可
我们对着\(w_{x\in S}\)带容斥系数进行背包，设\(dp(i)\)表示\(w_{x \in S}=i\)的方案数，根据\(|S|\)的不同带符号，那么他的生成函数是
\[ [x^i]\prod (1-x^{w_j}) \]
由于多项式乘法满足结合律也满足交换律，所以直接二进制合并即可，复杂度\(O(n \log^2 n)\)
猫猫说这做到的是最优复杂度。
//@winlere
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std; typedef long long ll;
inline int qr(){
int ret=0,f=0,c=getchar();
while(!isdigit(c))f|=c==45,c=getchar();
while(isdigit(c)) ret=ret*10+c-48,c=getchar();
return f?-ret:ret;
}
const int maxn=1e5+5;
const int mod=998244353;
int w[maxn],inv[maxn],n,s,ans;
inline int MOD(const int&x){return x>=mod?x-mod:x;}
inline int MOD(const int&x,const int&y){return 1ll*x*y%mod;}
inline int ksm(const int&ba,const int&p){
int ret=1;
for(int t=p,b=ba%mod;t;t>>=1,b=1ll*b*b%mod)
if(t&1) ret=1ll*ret*b%mod;
return ret;
}
namespace poly{
typedef vector poly;
const int maxn=1<<18;
const int g=3;
const int gi=ksm(g,mod-2);
int r[maxn];
inline void getr(const int&len){
static int L=0;
if(L==len) return;
L=len;
for(int t=0;t>1]>>1|(t&1?L>>1:0);
}
inline void NTT(poly&a,const int&len,const int&tag){
getr(len);
for(int t=0;t q;
inline poly DIVD_NTT(vectora){
for(auto&t:a) t.resize(foo(t.size()));
for(int i=0,ed=a.size();i1){
int t1=q.front();
q.pop();
int t2=q.front();
q.pop();
int g=a[t1].size()+a[t2].size(),k=foo(a[t1].size()+a[t2].size()-1);
a[t1].resize(k); a[t2].resize(k);
NTT(a[t1],k,1); NTT(a[t2],k,1);
for(int t=0;t dp;
vector a;
int main(){
n=qr();
for(int t=1;t<=n;++t) w[t]=qr(),s+=w[t];
sort(w+2,w+n+1);
for(int t=2;t<=n;++t)
a.push_back(vector(w[t]+1)),a.back()[0]=1,a.back()[w[t]]=mod-1;
dp=poly::DIVD_NTT(a);
inv[1]=1;
for(int t=2;t<=s;++t) inv[t]=1ll*(mod-mod/t)*inv[mod%t]%mod;
for(int t=0,ed=dp.size();t 随机游走
不会