题解：

思路挺好想的。。然而今天写代码写成傻逼了

d1t1:

首先比较暴力的就是$f[i][j]$表示i个这个点是j的概率

然后前缀和一下dp就是$n^2$的

部分分树形态随机就说明树深度是$log$的

只转移子树中有的点,复杂度$nlogn$的

正解也很好想

我们化简一下那个式子（早上的草稿纸找不到了。。）

反正形如$(ai*sum[i]+bi)*pi$

因为最多只有两个儿子，显然启发式合并或者线段树合并可以维护这个sum[i]然后复杂度是$nlogn$的

30min写完一下过了样例一交爆0

然后就debug了无限久

大概先是通过手造发现要先做左二子，然后发现了查询没down

然后手造就再也发现不了问题

就改对拍（早知道就早点写了）

然后那个数据要在不太能手摸的时候才出错。。

找了半天才发现是merge里面没有把y的sum加到x上

然后交了tle70

然后我把map改了hash快了一点点还是70

于是又离散化才过

于是我写了2个半小时这题 简直是傻逼

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. #define rint register int
  4. #define IL inline
  5. #define rep(i,h,t) for (int i=h;i<=t;i++)
  6. #define dep(i,t,h) for (int i=t;i>=h;i--)
  7. #define me(x) memset(x,0,sizeof(x))
  8. #define ll long long
  9. #define mid ((h+t)>>1)
  10. namespace IO
  11. {
  12.     char ss[<<],*A=ss,*B=ss;
  13.     IL char gc()
  14.     {
  15.         return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
  16.     }
  17.     template<class T>void read(T &x)
  18.     {
  19.         rint f=,c;while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
  20.         while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
  21.     }
  22.     char sr[<<],z[]; int C=-,Z;
  23.     template<class T>void wer(T x)
  24.     {
  25.         if (x<) sr[++C]='-',x=-x;
  26.         while (z[++Z]=x%+,x/=);
  27.         while (sr[++C]=z[Z],--Z);
  28.     }
  29.     IL void wer1() {sr[++C]=' ';}
  30.     IL void wer2() {sr[++C]='\n';}
  31.     template<class T>IL void maxa(T &x,T y) { if (x<y) x=y;}
  32.     template<class T>IL void mina(T &x,T y) { if (x>y) x=y;}
  33.     template<class T>IL T MAX(T x,T y){ return x>y?x:y;}
  34.     template<class T>IL T MIN(T x,T y){ return x<y?x:y;}
  35. }
  36. using namespace IO;
  37. const int N=4e5;
  38. const int M2=N*;
  39. const int mo=;
  40. const int INF=4e5;
  41. int ch[N][],cnt[N],v[N];
  42. const int mo2=1e7+;
  43. struct Hash{
  44.     int a[mo2+],b[mo2+];
  45.     IL void push(int x,int y)
  46.     {
  47.         int pos=x%mo2;
  48.         while (a[pos]&&a[pos]!=x) pos++;
  49.         a[pos]=x; b[pos]=y;
  50.     }
  51.     IL int find(int x)
  52.     {
  53.         int pos=x%mo2;
  54.         while (a[pos]&&a[pos]!=x) pos++;
  55.         return b[pos];
  56.     }
  57. }H;
  58. IL int fsp(int x,int y)
  59. {
  60.     ll now=;
  61.     while (y)
  62.     {
  63.         if (y&) now=now*x%mo;
  64.         x=1ll*x*x%mo; y>>=;
  65.     }
  66.     return now;
  67. }
  68. int rt[N];
  69. map<int,int> M;
  70. struct re{
  71.     int a,b;
  72. }p[N];
  73. int tf;
  74. struct sgt{
  75.     int sum[M2],lazy[M2],ls[M2],rs[M2],cnt2;
  76.     sgt() { rep(i,,M2-) lazy[i]=;}
  77.     IL void down(int x)
  78.     {
  79.         if (lazy[x]!=)
  80.         {
  81.             sum[ls[x]]=1ll*sum[ls[x]]*lazy[x]%mo;
  82.             sum[rs[x]]=1ll*sum[rs[x]]*lazy[x]%mo;
  83.             lazy[ls[x]]=1ll*lazy[ls[x]]*lazy[x]%mo;
  84.             lazy[rs[x]]=1ll*lazy[rs[x]]*lazy[x]%mo;
  85.             lazy[x]=;
  86.         }
  87.     }
  88.     int merge(int x,int y,int p1,int p2,int p)
  89.     {
  90.         down(x); down(y);
  91.         if (!x&&!y) return ;
  92.         if (!x)
  93.         {
  94.             lazy[y]=(1ll*p1*(*p-)+(-p))%mo;
  95.             sum[y]=1ll*lazy[y]*sum[y]%mo;
  96.             return y;
  97.         }
  98.         if (!y)
  99.         {
  100.             lazy[x]=(1ll*p2*(*p-)+(-p))%mo;
  101.             sum[x]=1ll*sum[x]*lazy[x]%mo;
  102.             return x;
  103.         }
  104.         rs[x]=merge(rs[x],rs[y],(p1+sum[ls[x]])%mo,(p2+sum[ls[y]])%mo,p);
  105.         ls[x]=merge(ls[x],ls[y],p1,p2,p);
  106.         sum[x]=(sum[ls[x]]+sum[rs[x]])%mo;
  107.         return x;
  108.     }
  109.     void change(int &x,int h,int t,int pos)
  110.     {
  111.         x=++cnt2; sum[x]=;
  112.         if (h==t) return;
  113.         if (pos<=mid) change(ls[x],h,mid,pos);
  114.         else change(rs[x],mid+,t,pos);
  115.     }
  116.     int query(int x,int h,int t)
  117.     {
  118.         if (!x) return();
  119.         if (h==t)
  120.         {
  121.           return 1ll*h*p[h].a%mo*sum[x]%mo*sum[x]%mo;
  122.         }
  123.         down(x);
  124.         return (query(ls[x],h,mid)+query(rs[x],mid+,t))%mo;
  125.     }
  126. }S;
  127. void dfs(int x)
  128. {
  129.     if (!x) return;
  130.     if (cnt[x]==)
  131.     {
  132.       dfs(ch[x][]); dfs(ch[x][]);
  133.       rt[x]=S.merge(rt[ch[x][]],rt[ch[x][]],,,v[x]);
  134.     } else if (cnt[x]==)
  135.     {
  136.       dfs(ch[x][]);
  137.       rt[x]=rt[ch[x][]];
  138.     } else
  139.     {
  140.         S.change(rt[x],,INF,v[x]);
  141.     }
  142. }
  143. int n;
  144. bool cmp(re x,re y)
  145. {
  146.     return x.a<y.a;
  147. }
  148. int main()
  149. {
  150.     read(n);
  151.     rep(i,,n)
  152.     {
  153.       int x;
  154.       read(x);
  155.       ch[x][cnt[x]++]=i;
  156.     }
  157.     int ni10000=fsp(,mo-),num=;
  158.     rep(i,,n)
  159.     {
  160.       read(v[i]);
  161.       if (cnt[i]) v[i]=1ll*v[i]*ni10000%mo;
  162.       else p[++num]=(re){v[i],i};
  163.     }
  164.     sort(p+,p+num+,cmp);
  165.     rep(i,,num) v[p[i].b]=i;
  166.   //  rep(i,1,num) H.push(p[i],i);
  167.     dfs();
  168.     cout<<S.query(rt[],,INF)<<endl;
  169.     return ;
  170. }

d1t2:

（我的做法可能比较麻烦常数比别人大2-3倍）

这个贪心的性质非常明显，有强化卡肯定强化他然后选最大的（没有当然只能选攻击了）

看数据范围就知道这个东西很明显是$n^2$的 并且不能带$log$

于是这时候很明显是dp了

对于强化卡我们$f[i][j]$表示前i张选j张不同方案的乘积和（注意如果>k-1只取k-1张） 所以要先排序

那对于攻击卡我们怎么选择呢，似乎暴力$dp$需要$f[i][j][k]$，i张里面选j张，使用k张攻击卡

但我们排序后发现，对后面的我们可以直接乘组合数

于是处理出$f[i][j]$表示前i张选j张并且攻击了

最后枚举$i$和强化卡使用数量num，那么j就是$max(1,k-num)$，再乘个组合数就好了

刚开始第二个样例wa了

写了个拍查了一下就对了

然后提交上去30？？？？？

卧槽卡常这么恐怖的么

然后就是30-40-60-100了

（大概是 把多次调用数组同一个值的地方改掉了 上下界修改了一下 MAX只调用一次 C数组改变了一下两维的顺序）

连续两天用指针卡常发现没用

以后再也不改指针了，最花时间又最没用的卡常

当然这些都改了也只有60

通过删减代码发现时间在最后统计处

然后用常用的套路去减少取模次数

于是我循环展开了然后4次取模一次（8次测出来和4次效果差不多）

终于过了

我也不知道为啥这个常数这么大。。。跟正解好像没啥区别。。。

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. #define rint register int
  4. #define IL inline
  5. #define rep(i,h,t) for (int i=h;i<=t;i++)
  6. #define dep(i,t,h) for (int i=t;i>=h;i--)
  7. #define me(x) memset(x,0,sizeof(x))
  8. #define ll long long
  9. #define mid ((h+t)>>1)
  10. namespace IO
  11. {
  12.     char ss[<<],*A=ss,*B=ss;
  13.     IL char gc()
  14.     {
  15.         return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
  16.     }
  17.     template<class T>void read(T &x)
  18.     {
  19.         rint f=,c;while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
  20.         while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
  21.     }
  22.     char sr[<<],z[]; int C1=-,Z;
  23.     template<class T>void wer(T x)
  24.     {
  25.         if (x<) sr[++C1]='-',x=-x;
  26.         while (z[++Z]=x%+,x/=);
  27.         while (sr[++C1]=z[Z],--Z);
  28.     }
  29.     IL void wer1() {sr[++C1]=' ';}
  30.     IL void wer2() {sr[++C1]='\n';}
  31.     template<class T>IL void maxa(T &x,T y) { if (x<y) x=y;}
  32.     template<class T>IL void mina(T &x,T y) { if (x>y) x=y;}
  33.     template<class T>IL T MAX(T x,T y){ return x>y?x:y;}
  34.     template<class T>IL T MIN(T x,T y){ return x<y?x:y;}
  35. }
  36. using namespace IO;
  37. const int N=4e3;
  38. const int mo=;
  39. int w1[N],w2[N];
  40. int f1[N][N],f2[N][N],C[N][N],g[N][N],C2[N][N],f3[N][N];
  41. bool cmp(int x,int y)
  42. {
  43.     return x>y;
  44. }
  45. int main()
  46. {
  47.     int T;
  48.     read(T);
  49.     rep(i,,)
  50.     {
  51.       rep(j,,i)
  52.         C[i][j]=(C[i-][j]+C[i-][j-])%mo;
  53.       C[i][]=;
  54.     }
  55.     rep(i,,)
  56.       rep(j,,)
  57.         C2[i][j]=C[j][i];
  58.     while (T--)
  59.     {
  60.         int n,m,k;
  61.         read(n); read(m); read(k);
  62.         rep(i,,n) read(w1[i]);
  63.         rep(i,,n) read(w2[i]);
  64.         sort(w1+,w1+n+,cmp); sort(w2+,w2+n+,cmp);
  65.         f1[][]=; f2[][]=;
  66.         rep(i,,n) f1[i][]=;
  67.         rep(i,,n)
  68.         {
  69.           int t=MIN(i,m);
  70.           rep(j,,t)
  71.           {
  72.             if (j<k) f1[i][j]=(f1[i-][j]+1ll*f1[i-][j-]*w1[i])%mo;
  73.             else f1[i][j]=(f1[i-][j]+f1[i-][j-])%mo;
  74.           }
  75.         }
  76.         rep(i,,n)
  77.         {
  78.           int t=MIN(i,m);
  79.           rep(j,,t)
  80.           {
  81.               f2[i][j]=(g[i-][j-]+1ll*w2[i]*C[i-][j-])%mo;
  82.               g[i][j]=(g[i-][j-]+g[i-][j]+1ll*w2[i]*C[i-][j-])%mo;
  83.           }
  84.         }
  85.         unsigned ll ans=;
  86.         for (register int j=;j<=n;j++)
  87.         {
  88.           int tt=MAX(k-j,),tt1=f1[n][j];
  89.           int *pp=C2[m-j-tt];
  90.           register int i;
  91.           for (i=;i+<=n;i+=)
  92.           {
  93.             ans+=1ll*tt1*f2[i][tt]%mo*pp[n-i];
  94.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  95.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  96.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  97.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  98.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  99.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  100.             ans+=1ll*tt1*f2[i+][tt]%mo*pp[n-i-];
  101.             ans%=mo;
  102.           }
  103.           for(;i<=n;i++)
  104.            ans+=1ll*tt1*f2[i][tt]%mo*pp[n-i];
  105.           ans%=mo;
  106.         }
  107.         wer(ans); wer2();
  108.     }
  109.     fwrite(sr,,C1+,stdout);
  110.     return ;
  111. }

d1t3:
果然是不可做题。。再见

d2t1:

因为记得我看过游记说这个是道傻逼题

于是看了题目10min写了个next_permutation然后拿了10分

我才意识到把排序当2^n了

然后就先去写了一道lct

写完重新开始想。。感觉已经晕了

然后我就很zz的想出了$nlog^3n$的做法

然后发现这个东西常数极小就写了

大概就是$f[i][j]$表示当前状态中有i这些点，然后与它相连的点有j个（包括自己）

然后转移就可以枚举现在放了几个点在后面

然后挺好写

不过拍了一下发现我把$A()$搞成了$x!$ 改了就拍上了

交了之后发现数组开小了

然后并不是很理解为啥这个数组要40

后来发现我把自己重复计数了（ 我也不懂为什么这都是对的）

果然跑的飞快

也就是$nlogn$慢了3倍

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. #define rint register int
  4. #define IL inline
  5. #define rep(i,h,t) for (int i=h;i<=t;i++)
  6. #define dep(i,t,h) for (int i=t;i>=h;i--)
  7. #define me(x) memset(x,0,sizeof(x))
  8. #define ll long long
  9. #define mid ((h+t)>>1)
  10. namespace IO
  11. {
  12.     char ss[<<],*A=ss,*B=ss;
  13.     IL char gc()
  14.     {
  15.         return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
  16.     }
  17.     template<class T>void read(T &x)
  18.     {
  19.         rint f=,c;while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
  20.         while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
  21.     }
  22.     char sr[<<],z[]; int C=-,Z;
  23.     template<class T>void wer(T x)
  24.     {
  25.         if (x<) sr[++C]='-',x=-x;
  26.         while (z[++Z]=x%+,x/=);
  27.         while (sr[++C]=z[Z],--Z);
  28.     }
  29.     IL void wer1() {sr[++C]=' ';}
  30.     IL void wer2() {sr[++C]='\n';}
  31.     template<class T>IL void maxa(T &x,T y) { if (x<y) x=y;}
  32.     template<class T>IL void mina(T &x,T y) { if (x>y) x=y;}
  33.     template<class T>IL T MAX(T x,T y){ return x>y?x:y;}
  34.     template<class T>IL T MIN(T x,T y){ return x<y?x:y;}
  35. }
  36. using namespace IO;
  37. const int N=1.5e6;
  38. const int M=;
  39. #define lowbit(x) (x&(-x))
  40. bool f[][N],o[N];
  41. int g[N][];
  42. int a[N],num,ans1[N],ans2[N],jc[],jc2[];
  43. const int mo=;
  44. IL int fsp(int x,int y)
  45. {
  46.     ll now=;
  47.     while (y)
  48.     {
  49.         if (y&) now=now*x%mo;
  50.         x=1ll*x*x%mo; y>>=;
  51.     }
  52.     return now;
  53. }
  54. int main()
  55. {
  56.     freopen("1.in","r",stdin);
  57.     freopen("1.out","w",stdout);
  58.     int n,m;
  59.     read(n); read(m);
  60.     rep(i,,m)
  61.     {
  62.         int x,y;
  63.         read(x); read(y);
  64.         f[y][<<(x-)]=;
  65.         f[x][<<(y-)]=;
  66.     }
  67.     jc[]=; jc2[]=;
  68.     rep(i,,) jc[i]=1ll*jc[i-]*i%mo,jc2[i]=fsp(jc[i],mo-);
  69.     rep(i,,n)
  70.       rep(j,,(<<n)-)
  71.         f[i][j]=f[i][j-lowbit(j)]|f[i][lowbit(j)];
  72.     rep(j,,(<<n)-)
  73.       rep(i,,n)
  74.       {
  75.         if (f[i][j]||(j>>(i-))&) ans1[j]++;
  76.         if ((j>>(i-))&) ans2[j]++;
  77.       }
  78.     g[][]=;
  79.     rep(i,,(<<n)-)
  80.       rep(j,ans2[i],ans1[i])
  81.         if (g[i][j])
  82.         {
  83.             if (j>=) cout<<"sb"<<endl;
  84.             rep(k,,n)
  85.               if (!((i>>(k-))&)&&!f[k][i])
  86.               {
  87.                   o[i|(<<(k-))]=;
  88.                   int pu=ans1[i|(<<(k-))];
  89.                 rep(i1,j+,pu)
  90.                 {
  91.                   if (i1>=) cout<<(i|(<<(k-)))<<endl;
  92.                   g[i|(<<(k-))][i1]=(g[i|(<<(k-))][i1]+1ll*g[i][j]*jc[pu-j-]%mo*jc2[pu-i1])%mo;
  93.                 }
  94.               }
  95.         }
  96.     int cnt=;
  97.     dep(i,(<<n)-,)
  98.       if (o[i])
  99.       {
  100.           maxa(cnt,ans2[i]);
  101.       }
  102.     ll ans=;
  103.     rep(i,,(<<n)-)
  104.       if (ans2[i]==cnt) (ans+=g[i][n])%=mo;
  105.     ll ans3=;
  106.     rep(i,,n) ans3=ans3*i%mo;
  107.     cout<<ans*fsp(ans3,mo-)%mo<<endl;
  108.     return ;
  109. }

正解是这样的：

大概就是跟我反着记录

$f[i][j]$表示当前有状态i内的点不能经过，独立集内有j个点的方案

然后现在枚举加入一个点会带来k个不合法的，就把他们插入到剩下的位置就可以了

这样是$2^n*n^2$的

然后这么dp的话显然是$i$相同时j越大越好且一定好于j小的

所以记录一下最大就行了

复杂度$nlogn$

我那个方法完全没法优化理论复杂度。。

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. #define rint register int
  4. #define IL inline
  5. #define rep(i,h,t) for (int i=h;i<=t;i++)
  6. #define dep(i,t,h) for (int i=t;i>=h;i--)
  7. #define me(x) memset(x,0,sizeof(x))
  8. #define ll long long
  9. #define mid ((h+t)>>1)
  10. namespace IO
  11. {
  12.     char ss[<<],*A=ss,*B=ss;
  13.     IL char gc()
  14.     {
  15.         return A==B&&(B=(A=ss)+fread(ss,,<<,stdin),A==B)?EOF:*A++;
  16.     }
  17.     template<class T>void read(T &x)
  18.     {
  19.         rint f=,c;while (c=gc(),c<||c>) if (c=='-') f=-; x=(c^);
  20.         while (c=gc(),c>&&c<) x=(x<<)+(x<<)+(c^); x*=f;
  21.     }
  22.     char sr[<<],z[]; int C=-,Z;
  23.     template<class T>void wer(T x)
  24.     {
  25.         if (x<) sr[++C]='-',x=-x;
  26.         while (z[++Z]=x%+,x/=);
  27.         while (sr[++C]=z[Z],--Z);
  28.     }
  29.     IL void wer1() {sr[++C]=' ';}
  30.     IL void wer2() {sr[++C]='\n';}
  31.     template<class T>IL void maxa(T &x,T y) { if (x<y) x=y;}
  32.     template<class T>IL void mina(T &x,T y) { if (x>y) x=y;}
  33.     template<class T>IL T MAX(T x,T y){ return x>y?x:y;}
  34.     template<class T>IL T MIN(T x,T y){ return x<y?x:y;}
  35. }
  36. using namespace IO;
  37. const int N=1.5e6;
  38. const int M=;
  39. #define lowbit(x) (x&(-x))
  40. bool f[][N],o[N];
  41. int g[N][];
  42. int a[N],num,ans1[N],ans2[N],jc[],jc2[];
  43. const int mo=;
  44. IL int fsp(int x,int y)
  45. {
  46.     ll now=;
  47.     while (y)
  48.     {
  49.         if (y&) now=now*x%mo;
  50.         x=1ll*x*x%mo; y>>=;
  51.     }
  52.     return now;
  53. }
  54. int main()
  55. {
  56.     freopen("1.in","r",stdin);
  57.     freopen("1.out","w",stdout);
  58.     int n,m;
  59.     read(n); read(m);
  60.     rep(i,,m)
  61.     {
  62.         int x,y;
  63.         read(x); read(y);
  64.         f[y][<<(x-)]=;
  65.         f[x][<<(y-)]=;
  66.     }
  67.     jc[]=; jc2[]=;
  68.     rep(i,,) jc[i]=1ll*jc[i-]*i%mo,jc2[i]=fsp(jc[i],mo-);
  69.     rep(i,,n)
  70.       rep(j,,(<<n)-)
  71.         f[i][j]=f[i][j-lowbit(j)]|f[i][lowbit(j)];
  72.     rep(j,,(<<n)-)
  73.       rep(i,,n)
  74.       {
  75.         if (f[i][j]||(j>>(i-))&) ans1[j]++;
  76.         if ((j>>(i-))&) ans2[j]++;
  77.       }
  78.     g[][]=;
  79.     rep(i,,(<<n)-)
  80.       rep(j,ans2[i],ans1[i])
  81.         if (g[i][j])
  82.         {
  83.             if (j>=) cout<<"sb"<<endl;
  84.             rep(k,,n)
  85.               if (!((i>>(k-))&)&&!f[k][i])
  86.               {
  87.                   o[i|(<<(k-))]=;
  88.                   int pu=ans1[i|(<<(k-))];
  89.                 rep(i1,j+,pu)
  90.                 {
  91.                   if (i1>=) cout<<(i|(<<(k-)))<<endl;
  92.                   g[i|(<<(k-))][i1]=(g[i|(<<(k-))][i1]+1ll*g[i][j]*jc[pu-j-]%mo*jc2[pu-i1])%mo;
  93.                 }
  94.               }
  95.         }
  96.     int cnt=;
  97.     dep(i,(<<n)-,)
  98.       if (o[i])
  99.       {
  100.           maxa(cnt,ans2[i]);
  101.       }
  102.     ll ans=;
  103.     rep(i,,(<<n)-)
  104.       if (ans2[i]==cnt) (ans+=g[i][n])%=mo;
  105.     ll ans3=;
  106.     rep(i,,n) ans3=ans3*i%mo;
  107.     cout<<ans*fsp(ans3,mo-)%mo<<endl;
  108.     return ;
  109. }

d2t2:

d2t3:

pkuwc2018题解的更多相关文章

  1. 【题解】PKUWC2018简要题解

    [题解]PKUWC2018简要题解 Minimax 定义结点x的权值为: 1.若x没有子结点,那么它的权值会在输入里给出,保证这类点中每个结点的权值互不相同. 2.若x有子结点,那么它的权值有p的概率 ...

  2. 题解-PKUWC2018 Minimax

    Problem loj2537 Solution pkuwc2018最水的一题,要死要活调了一个多小时(1h59min) 我写这题不是因为它有多好,而是为了保持pkuwc2018的队形,与这题类似的有 ...

  3. 题解-PKUWC2018 随机算法

    Problem loj2540 题意简述:给定\(n\)个点的无向图,给定求最大独立集的近似算法:随机排列\(1\cdots n\),按照该排列顺序贪心构造最大独立集(即对每个点能加入独立集就加),求 ...

  4. LOJ2537：[PKUWC2018]Minimax——题解

    https://loj.ac/problem/2537 参考了本题在网上能找到的为数不多的题解. 以及我眼睛瞎没看到需要离散化,还有不开longlong见祖宗. ——————————————————— ...

  5. 题解-PKUWC2018 Slay the Spire

    Problem loj2538 Solution 在考场上当然要学会写暴力,考虑如果手上已经有了\(a\)张攻击牌和\(b\)张强化牌: 首先强化牌会在攻击牌之前用(废话),其次要将两种牌分别从大往小 ...

  6. 题解-PKUWC2018 随机游走

    Problem loj2542 题意:一棵 \(n\) 个结点的树,从点 \(x\) 出发,每次等概率随机选择一条与所在点相邻的边走过去,询问走完一个集合 \(S\)的期望时间,多组询问 \(n\le ...

  7. 题解-PKUWC2018 猎人杀

    Problem loj2541 题意概要:给定 \(n\) 个人的倒霉度 \(\{w_i\}\),每回合会有一个人死亡,每个人这回合死亡的概率为 自己的倒霉度/目前所有存活玩家的倒霉度之和,求第 \( ...

  8. [PKUWC2018]Minimax 题解

    根据题意,若一个点有子节点,则给出权值:否则可以从子节点转移得来. 若没有子节点,则直接给出权值: 若只有一个子节点,则概率情况与该子节点完全相同: 若有两个子节点,则需要从两个子节点中进行转移. 如 ...

  9. 【LOJ#2542】[PKUWC2018]随机游走（min-max容斥，动态规划）

    [LOJ#2542][PKUWC2018]随机游走(min-max容斥,动态规划) 题面 LOJ 题解 很明显,要求的东西可以很容易的进行\(min-max\)容斥,那么转为求集合的\(min\). ...

随机推荐

  1. 计算指定文件的MD5值

    /// <summary> /// 计算指定文件的MD5值 /// </summary> /// <param name="fileName"> ...

  2. SQL学习指南第四篇

    SQL必知必会(第4版)学习笔记 插入数据 插入有几种方式: 插入完整的行 插入行的一部分 插入某些查询的结果(INSERT SELECT) 注意:省略列 如果表的定义允许,则可以在 INSERT 操 ...

  3. 30K iOS程序员的简述：如何快速进阶成为高级开发人员

    前言: 本篇文章适用于所有在这个行业已经有了几年时间后想要在职业生涯中取得突破的开发人员,编程人员和程序员(或者你可能刚刚开始,但希望你能看到你的路径) 本文适合那些有着简单愿望的人:你想成为一名高级 ...

  4. Apache的安装与配置+PHP

     https://blog.csdn.net/u012130971/article/details/79284937 文件夹名称不要有空格

  5. thinkphp5 去除缓存

    array_map('unlink', glob(TEMP_PATH . '/*.php')); rmdir(TEMP_PATH);

  6. vscode中文配置说明

    1.官网下载vscode安装完毕后, 2.在扩展中搜索chinese,选择:“Chinese (Simplified) Language Pack for Visual Studio Code” 3. ...

  7. 多模块项目Module must not contain source root. The root already belongs to module

    多模块项目Module "*" must not contain source root *. The root already belongs to module "* ...

  8. cmake 递归依赖

    现在有3个模块:main.service.base,main依赖service的service.h.service依赖base的base.h,怎么写CMakeList.txt避免main直接耦合bas ...

  9. Ps 应用小技巧总结

    一.如何等比例放大图片? 使用形状工具,画图之后,保存为智能对象,但是 ctrl+T 之后放大,会有虚边: 解决办法:编辑智能对象,在新的画布中:图像---图像大小----ctrl+alt+I 此处进 ...

  10. APACHE 安装

    APACHE  安装 到官网下载apache软件 解压apache软件 安装APR相关优化模块 创建APACHE安装目录 安装apche,开始预编译(检测安装环境) 编译和安装 启动时报错及排错 修改 ...