【2018.11.8】小迟的比赛 / Yuno like cake / 格子填数

题目

$noip$ 欢乐赛真是欢乐，除了不欢乐的方面以外我都很欢乐。

---

T1

鸡汤题目，故意输对后面的胜率又没有影响，为什么要故意输呢？

所以第二个决策是凑字用的，这题就是朴素递推概率，最后乘结果权值计算期望。

 #include<cctype>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 inline int read(){
     int x=; bool f=; char c=getchar();
     for(;!isdigit(c);c=getchar()) if(c=='-') f=;
     for(; isdigit(c);c=getchar()) x=(x<<)+(x<<)+(c^'');
     if(f) return x;
     return -x;
 }
 #define N 1001
 int n;
 double p[N][N],f[N][N];
 int main(){
     freopen("game.in","r",stdin);
     freopen("game.out","w",stdout);
     n=read();
     int i,j;
     f[][]=;
     for(i=;i<=n;++i){
         cin>>p[i][j]; f[i][]=f[i-][]*(-p[i][j]);
         for(j=;j<i;++j){
             cin>>p[i][j];
             f[i][j]=f[i-][j-]*p[i][j-]+f[i-][j]*(-p[i][j]);
         }
         f[i][j]=f[i-][j-]*p[i][j-];
     }
     double ans=;
     for(i=;i<=n;++i) ans+=f[n][i]*i;
     printf("%.2f",ans);
     return ;
 }

---

T2

原题……在日本竞赛书上看到过……

把 $40$ 个数平分成两半，枚举其中一半的选取情况，然后在另一半中二分出能取的最大的剩下部分。时间复杂度 $O(2^{20}*log(2^{20}))$。

 #include<cctype>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #define ll long long
 using namespace std;
 inline int read(){
     int x=; bool f=; char c=getchar();
     for(;!isdigit(c);c=getchar()) if(c=='-') f=;
     for(; isdigit(c);c=getchar()) x=(x<<)+(x<<)+(c^'');
     if(f) return x;
     return -x;
 }

 int n,x;
 ll v[<<],l[<<],r[<<];
 int main(){
     freopen("cake.in","r",stdin);
     freopen("cake.out","w",stdout);
     n=read(),x=read();
     int i,to=n>>;
     for(i=;i<=to;++i) v[<<(i-)]=read();
     int l_len=<<to, r_len=<<(n-to), tmp;
     for(i=;i^l_len;++i) tmp=i&(i-), l[i]=v[i^(i&tmp)]+l[i&tmp];
     for(i=;i<=n-to;++i) v[<<(i-)]=read();
     for(i=;i^r_len;++i) tmp=i&(i-), r[i]=v[i^(i&tmp)]+r[i&tmp];
     sort(l+,l+l_len);
     sort(r+,r+r_len);
     int wz; ll ans=;
     for(i=;i^l_len;++i){
         if(l[i]>x) continue;
         wz=upper_bound(r+,r+r_len,x-l[i])-r-;
         ans=max(ans,l[i]+r[wz]);
         //printf("go:%d %d %d %d\n",i,wz,l[i],r[wz]);
     }
     printf("%lld",x-ans);
     return ;
 }

---

T3

CXM 之前讲过……

矩阵不相交的情况 和 相交而且数不相同的情况也很好做，直接用小的限制覆盖掉大的限制就完了。

两个矩阵相交而且数相同的话，会麻烦一点，因为在重叠区域放一个数就可以满足两个限制，而在两矩阵不相交的地方，需要两边各放一个才行。

而且更多数相同的矩阵相交的话，计算就更复杂了。

那怎么算？容斥？

其实可以把相交且数相同的矩阵连通块分割，使任意相邻两块的覆盖层数不相等，然后用二进制数给每个部分按照覆盖情况进行二进制编号，做 $dp$。简单地说就是状压 $dp$。

 #include<bits/stdc++.h>
 #define rep(i,x,y) for(register int i=(x);i<=(y);i++)
 #define dwn(i,x,y) for(register int i=(x);i>=(y);i--)
 #define maxn 51
 #define maxk 10010
 #define maxs ((1<<10)+5)
 #define LL long long
 using namespace std;
 int read()
 {
     int x=,f=;char ch=getchar();
     while(!isdigit(ch)&&ch!='-')ch=getchar();
     if(ch=='-')f=-,ch=getchar();
     while(isdigit(ch))x=(x<<)+(x<<)+ch-'',ch=getchar();
     return x*f;
 }
 void write(int x)
 {
     int f=;char ch[];
     if(!x){putchar(''),putchar('\n');return;}
     if(x<)x=-x,putchar('-');
     while(x)ch[++f]=x%+'',x/=;
     while(f)putchar(ch[f--]);
     putchar('\n');
 }
 typedef struct quest{int l,r,u,d,k;}que;
 que q[maxn];
 const int mod=1e9+;
 int f[maxs][maxs],sum;//,sum;
 int full,fulls,r,c,n,m,g[maxn][maxn],siz[maxs],tox[maxk],toy[maxk],num[maxn][maxn],bacx[maxn],bacy[maxn],extx[maxn],exty[maxn],cntx,cnty,nowx=,nowy=;
 int mul(int x,int y)
 {
     int ans=;
     while(y)
     {
         if(y&)ans=(int)(((LL)ans*(LL)x)%((LL)mod));
         x=(int)(((LL)x*(LL)x)%((LL)mod)),y>>=;
     }
     return ans;
 }
 void print(int x)
 {
     rep(i,,n)cout<<((x&(<<(i-)))?:);return;
 }
 int main()
 {
     freopen("grid.in","r",stdin);
     freopen("grid.out","w",stdout);
     memset(bacx,-,sizeof(bacx));
     memset(bacy,-,sizeof(bacy));
     r=read(),c=read(),m=read(),n=read();
     bacx[]=bacy[]=;tox[]=toy[]=;
     fulls=(<<n)-;
     rep(i,,n)
     q[i].l=read(),q[i].u=read(),q[i].r=read(),q[i].d=read(),q[i].k=read(),
     extx[++cntx]=q[i].l,extx[++cntx]=q[i].r,exty[++cnty]=q[i].u,exty[++cnty]=q[i].d;
     sort(extx+,extx+cntx+),sort(exty+,exty+cnty+);
     extx[]=;
     rep(i,,cntx)
     {
         if(extx[i]!=extx[i-]){if(extx[i]-extx[i-]>)nowx++;bacx[nowx]=extx[i],tox[extx[i]]=nowx,nowx++;}
     }
     if(bacx[nowx-]!=r){if(r-extx[cntx]>)nowx++;bacx[nowx]=r,tox[r]=nowx;}
     else nowx--;
     exty[]=;
     rep(i,,cnty)
     {
     //    cout<<exty[i]<<endl;
         if(exty[i]!=exty[i-]){if(exty[i]-exty[i-]>)nowy++;bacy[nowy]=exty[i],toy[exty[i]]=nowy,nowy++;}
     }
     if(bacy[nowy-]!=c){if(c-exty[cnty]>)nowy++;bacy[nowy]=c,toy[c]=nowy;}
     else nowy--;
     rep(i,,nowx)
         rep(j,,nowy)
         {
             int numx,numy;
             if(bacx[i]!=-)numx=;
             else numx=bacx[i+]-bacx[i-]-;
             if(bacy[j]!=-)numy=;
             else numy=bacy[j+]-bacy[j-]-;
             num[i][j]=numx*numy;
         }
     rep(i,,n)
     {
         rep(j,tox[q[i].l],tox[q[i].r])
             rep(k,toy[q[i].u],toy[q[i].d])
                 g[j][k]+=(<<(i-));
     }
     rep(i,,nowx)
     {
         rep(j,,nowy)
         {
             siz[g[i][j]]+=num[i][j];
             full=max(full,g[i][j]);
         }
     }
     f[][]=mul(m,siz[]);
     rep(i,,full-)
     {
         rep(j,,fulls)
         {
             int limit=m,num=;
             rep(k,,n)if((i+)&(<<(k-)))limit=min(limit,q[k].k);
             rep(k,,n)if(((i+)&(<<(k-)))&&q[k].k==limit)num|=(<<(k-));
             f[i+][j]=(int)(((LL)f[i+][j]+(LL)f[i][j]*(LL)mul(limit-,siz[i+]))%((LL)mod));
             f[i+][j|num]=(int)(((LL)f[i+][j|num]+(LL)f[i][j]*(((LL)mul(limit,siz[i+])-(LL)mul(limit-,siz[i+])+(LL)mod)%((LL)mod)))%((LL)mod));
         }
     }
     write(f[full][fulls]);
     return ;
 }
 /*
 2 3 2 1
 1 2 2 3 2
 */
 /*
 3 6 3 2
 1 2 2 3 2
 1 3 3 6 1
 */
 /*
 7 11 5 4
 2 2 4 4 3
 3 3 5 5 2
 4 4 5 9 3
 1 7 6 8 1
 */

SYF

 #include<bits/stdc++.h>
 typedef long long i64;
 const int P=1e9+;
 int T,h,w,m,n;
 int xs[],ys[],xp,yp,vs[],vp,ts[];
 int rc[][],mv[][],as[][];
 void mins(int&a,int b){if(a>b)a=b;}
 int pw(int a,int n){
     int v=;
     for(;n;n>>=,a=i64(a)*a%P)if(n&)v=i64(v)*a%P;
     return v;
 }
 int main(){
     int ans=;
     scanf("%d%d%d%d",&h,&w,&m,&n);
     xp=yp=vp=;
     xs[xp++]=;
     xs[xp++]=h+;
     ys[yp++]=;
     ys[yp++]=w+;
     vs[vp++]=m;
     for(int i=;i<n;++i){
         for(int j=;j<;++j)scanf("%d",rc[i]+j);
         xs[xp++]=rc[i][];
         xs[xp++]=rc[i][]+;
         ys[yp++]=rc[i][];
         ys[yp++]=rc[i][]+;
         vs[vp++]=rc[i][];
         vs[vp++]=rc[i][]-;
     }
     std::sort(xs,xs+xp);
     xp=std::unique(xs,xs+xp)-xs-;
     std::sort(ys,ys+yp);
     yp=std::unique(ys,ys+yp)-ys-;
     std::sort(vs,vs+vp);
     vp=std::unique(vs,vs+vp)-vs;
     for(int i=;i<xp;++i)
         for(int j=;j<yp;++j)as[i][j]=(xs[i+]-xs[i])*(ys[j+]-ys[j]);
     for(int t=;t<n;++t){
         rc[t][]=std::lower_bound(xs,xs+xp,rc[t][])-xs;
         rc[t][]=std::lower_bound(xs,xs+xp,rc[t][]+)-xs;
         rc[t][]=std::lower_bound(ys,ys+yp,rc[t][])-ys;
         rc[t][]=std::lower_bound(ys,ys+yp,rc[t][]+)-ys;
         rc[t][]=std::lower_bound(vs,vs+vp,rc[t][])-vs;
     }
     for(int S=;S<(<<n);++S){
         for(int i=;i<xp;++i)
             for(int j=;j<yp;++j)mv[i][j]=vp-;
         int s=;
         for(int t=;t<n;++t){
             int v=rc[t][];
             if(S>>t&)s=-s,--v;
             for(int i=rc[t][];i<rc[t][];++i)
                 for(int j=rc[t][];j<rc[t][];++j)mins(mv[i][j],v);
         }
         for(int i=;i<vp;++i)ts[i]=;
         for(int i=;i<xp;++i)
             for(int j=;j<yp;++j)ts[mv[i][j]]+=as[i][j];
         for(int i=;i<vp;++i)s=i64(s)*pw(vs[i],ts[i])%P;
         ans=(ans+s)%P;
     }
     printf("%d\n",(ans+P)%P);
     return ;
 }

std（好像是另类做法）

另外 $wxj$ 用扫描线过了……