2017-10-01-afternoon

T1 一道图论好题(graph)

Time Limit:1000ms   Memory Limit:128MB

题目描述

LYK有一张无向图G={V,E}，这张无向图有n个点m条边组成。并且这是一张带权图，不仅有边权还有点权。

LYK给出了一个子图的定义，一张图G’={V’,E’}被称作G的子图，当且仅当

·G’的点集V’包含于G的点集V。

·对于E中的任意两个点a,b∈V’，当(a,b)∈E时，(a,b)一定也属于E’，并且连接这两个点的边的边权是一样的。

LYK给一个子图定义了它的价值，它的价值为：点权之和与边权之和的比。 看

LYK想找到一个价值最大的非空子图，所以它来找你帮忙啦。

输入格式(graph.in)

第一行两个数n,m表示一张n个点m条边的图。

第二行n个数ai表示点权。

接下来m行每行三个数u,v,z，表示有一条连接u,v的边权为z的无向边。数据保证任意两个点之间最多一条边相连，并且不存在自环。

输出格式(graph.out)

你需要输出这个价值最大的非空子图的价值，由于它是一个浮点数，你只需要保留小数点后两位有效数字。

输入样例

3 3

2 3 4

1 2 3

1 3 4

2 3 5

输出样例

1.67

样例解释

选择1,2两个点，则价值为5/3=1.67。

对于20%的数据n=2

对于50%的数据n<=5

对于100%的数据1<=n,m<=100000，1<=ai,z<=1000。

大忽悠题。。

 /*
 设点1,2，之间边权w12,点2,3，之间边权w23
 假设 t1=(v1+v2)/w12>(v2+v3)/w23,即
       v1*w23+v2*w23>v2*w12+v3*w12
 那么 如果在1,2这个图里再加上3这个点
      t2==(v1+v2+v3)/(w12+w23)
 如果 t1>t2   移项一下就是
      v1*w12+v1*w23+v2*w12+v2*w23>v1*w12+v2*w12+v3*w12
 又因为v1*w23+v2*w23>v2*w12+v3*w12
 所以t1>t2显然，所以就是找两个点的图
 */
 #include <cstdio>
 
 #define max(a,b) (a>b?a:b)
 
 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N();
 int n,m,val[N];
 double ans;
 
 int Presist()
 {
 //    freopen("graph.in","r",stdin);
 //    freopen("graph.out","w",stdout);
     read(n),read(m);
     for(int i=; i<=n; ++i) read(val[i]);
     for(int u,v,w; m--; )
     {
         read(u),read(v),read(w);
         ans=max(ans,1.0*(val[u]+val[v])/w);
     }
     printf("%.2lf",ans);
     return ;
 }
 
 int Aptal=Presist();
 int main(int argc,char**argv){;} 

AC

T2 拍照(photo)

Time Limit:1000ms   Memory Limit:128MB

题目描述

假设这是一个二次元。

LYK召集了n个小伙伴一起来拍照。他们分别有自己的身高Hi和宽度Wi。

为了放下这个照片并且每个小伙伴都完整的露出来，必须需要一个宽度为ΣWi，长度为max{Hi}的相框。（因为不能叠罗汉）。

LYK为了节省相框的空间，它有了绝妙的idea，让部分人躺着！一个人躺着相当于是身高变成了Wi，宽度变成了Hi。但是很多人躺着不好看，于是LYK规定最多只有n/2个人躺着。（也就是说当n=3时最多只有1个人躺着，当n=4时最多只有2个人躺着）

LYK现在想问你，当其中部分人躺着后，相框的面积最少是多少。

输入格式(photo.in)

第一行一个数n。

接下来n行，每行两个数分别是Wi,Hi。

输出格式(photo.out)

你需要输出这个相框的面积最少是多少。

输入样例

3

3 1

2 2

4 3

输出样例

21

样例解释

如果没人躺过来，需要27的面积。

我们只要让第1个人躺过来，就只需要21的面积！

对于30%的数据n<=10。

对于60%的数据n<=1000，Wi,Hi<=10。

对于100%的数据1<=n,Wi,Hi<=1000。

 /*
 气人诶。。。
 一开始二分高度，，然后WA3个点。
 然后高度从大到小枚举，就A了。 
 
 对于每个人，判断在当前高度下是否需要躺下，且躺下是否合法
 当所有人的高度都符合要求时，如果还有让人躺下的次数
 判断每个人在躺下后，是否比站着更优 （sort一下方便）
 */
 #include <algorithm>
 #include <cstdio>
 
 #define max(a,b) (a>b?a:b)
 
 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N(1e3+);
 int n,W,H;
 struct People {
     int w,h;
     bool operator < (const People&x)const
     {
         return w-h>x.w-x.h;
 //        if(h!=x.h) return h>x.h;
 //        return w<x.w;
     }
 }peo[N];
 
 int l,r,mid,ans=0x7fffffff,tmp;
 inline bool check(int nowh)
 {
     int cnt=n>>,ret=,sw=W;
     for(int i=; i<=n; ++i)
      if(peo[i].h>nowh)
      {
          sw-=peo[i].w;
          sw+=peo[i].h;
          if(peo[i].w>nowh) return ;
         if(--cnt<) return ;
      }
     for(int i=; cnt&&i<=n; ++i)
       if(peo[i].h<=nowh&&peo[i].h<peo[i].w&&peo[i].w<=nowh)
         sw-=peo[i].w,sw+=peo[i].h,cnt--;
     if(tmp*nowh<ans) tmp=sw; return tmp*nowh<ans;
 }
 
 int Presist()
 {
     freopen("photo.in","r",stdin);
     freopen("photo.out","w",stdout);
     read(n);
     for(int i=; i<=n; ++i)
     {
         read(peo[i].w),read(peo[i].h);
         W+=peo[i].w;H=max(H,peo[i].h);
     }
     std::sort(peo+,peo+n+);
     for(; check(H); H--) ans=H*tmp;
     /*for(r=H; l<=r; )
     {
         mid=l+r>>1;
         if(check(mid))
         {
             ans=mid*tmp;
             r=mid-1;
         }
         else l=mid+1;
     }*/
     printf("%d\n",ans);
     return ;
 }
 
 int Aptal=Presist();
 int main(int argc,char**argv){;}

枚举+贪心AC

T3 或和异或(xor)

Time Limit:2000ms   Memory Limit:128MB

题目描述

LYK最近在研究位运算，它研究的主要有两个：or和xor。（C语言中对于|和^）

为了更好的了解这两个运算符，LYK找来了一个2^n长度的数组。它第一次先对所有相邻两个数执行or操作，得到一个2^(n-1)长度的数组。也就是说，如果一开始时a[1],a[2],…,a[2^n]，执行完第一次操作后，会得到a[1] or a[2],a[3] or a[4] ,…, a[(2^n)-1] or a[2^n]。

第二次操作，LYK会将所有相邻两个数执行xor操作，得到一个2^(n-2)长度的数组，假如第一次操作后的数组是b[1],b[2],…,b[2^(n-1)]，那么执行完这次操作后会变成b[1] xor b[2], b[3] xor b[4] ,…, b[(2^(n-1))-1] xor b[2^(n-1)]。

第三次操作，LYK仍然将执行or操作，第四次LYK执行xor操作。如此交替进行。

最终这2^n个数一定会变成1个数。LYK想知道最终这个数是多少。

为了让这个游戏更好玩，LYK还会执行Q次修改操作。每次修改原先的2^n长度的数组中的某一个数，对于每次修改操作，你需要输出n次操作后（最后一定只剩下唯一一个数）剩下的那个数是多少。

输入格式(xor.in)

第一行两个数n，Q。

接下来一行2^n个数ai表示一开始的数组。

接下来Q行，每行两个数xi,yi，表示LYK这次的修改操作是将a{xi}改成yi。

输出格式(xor.out)

Q行，表示每次修改操作后执行n次操作后剩下的那个数的值。

输入样例

2 4

1 6 3 5

1 4

3 4

1 2

1 2

输出样例

1

3

3

3

样例解释

第一次修改，{4,6,3,5}->{6,7}->{1}

第二次修改，{4,6,4,5}->{6,5}->{3}

第三次修改，{2,6,4,5}->{6,5}->{3}

第四次修改，{2,6,4,5}->{6,5}->{3}

对于30%的数据n<=17，Q=1。

对于另外20%的数据n<=10，Q<=1000。

对于再另外30%的数据n<=12，Q<=100000。

对于100%的数据1<=n<=17，1<=Q<=10^5，1<=xi<=2^n，0<=yi<2^30，0<=ai<2^30。

 #include <cstdio>
 
 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N(5e6+);
 int n,q,a[N],x[N];
 
 inline int work()
 {
     int cnt1=,cnt2=<<n;
     for(int i=; i<=<<n; ++i) x[i]=a[i];
     for(; ; )
     {
         cnt1=;
         for(int i=; i<=cnt2; i+=)
             x[++cnt1]=x[i]|x[i+];
         if(cnt1==) return x[];
         cnt2=;
         for(int i=; i<=cnt1; i+=)
             x[++cnt2]=x[i]^x[i+];
         if(cnt2==) return x[];
     }
 
 }
 
 int Presist()
 {
 //    freopen("xor.in","r",stdin);
 //    freopen("xor.out","w",stdout);
     read(n),read(q);
     for(int i=; i<=<<n; ++i) read(a[i]);
     for(int pos,num; q--; )
     {
         read(pos),read(num);
         a[pos]=num;
         printf("%d\n",work());
     }
     return ;
 }
 
 int Aptal=Presist();
 int main(int argc,char**argv){;}

搞笑的50分暴力

 /*
 数的个数依次减少，每次有类似操作——>>线段树维护
 对于一个区间，标记他的父亲是需要 | 得到还是 ^ 得到
 */
 #include <cstdio>
 
 inline void read(int &x)
 {
     x=; register char ch=getchar();
     for(; ch>''||ch<''; ) ch=getchar();
     for(; ch>=''&&ch<=''; ch=getchar()) x=x*+ch-'';
 }
 const int N(<<);
 
 struct Tree {
     bool flag;
     int l,r,mid,val;
 }tr[N<<];
 
 #define lc (now<<1)
 #define rc (now<<1|1)
 #define mid (tr[now].l+tr[now].r>>1)
 
 void Tree_update(int now)
 {
     tr[now].flag=!tr[lc].flag;
     if(!tr[lc].flag)
          tr[now].val=tr[lc].val|tr[rc].val;
     else tr[now].val=tr[lc].val^tr[rc].val;
 }
 void Tree_build(int now,int l,int r)
 {
     tr[now].l=l; tr[now].r=r;
     if(l==r) { read(tr[now].val),tr[now].flag=;return ; }
     Tree_build(lc,l,mid);    Tree_build(rc,mid+,r);
     Tree_update(now);
 }
 void Tree_change(int now,int to,int x)
 {
     if(tr[now].l==tr[now].r) {tr[now].val=x; return ;}
     if(to<=mid) Tree_change(lc,to,x);
     else Tree_change(rc,to,x);
     Tree_update(now);
 }
 
 int Presist()
 {
     freopen("xor.in","r",stdin);
     freopen("xor.out","w",stdout);
     int n,q;    read(n),read(q);
     Tree_build(,,<<n);
     for(int pos,num; q--; )
     {
         read(pos),read(num);
         Tree_change(,pos,num);
         printf("%d\n",tr[].val);
     }
     return ;
 }
 
 int Aptal=Presist();
 int main(int argc,char**argv){;}

线段树 AC

 #include <cmath>
 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <algorithm>
 #include <string>
 #include <cstring>
 using namespace std;
 long long st[][];
 int next[][],i,j,n,m,now,k,A,B;
 int main()
 {
     freopen("xor.in","r",stdin);
     freopen("xor.out","w",stdout);
     scanf("%d%d",&n,&m);
     for (i=; i<=(<<n); i++) cin>>st[i][];
     for (i=; i<=n; i++)
     {
         for (j=; j<=(<<n); j+=(<<i))
         {
             if (i % ==) st[j][i]=st[j][i-]|st[j+(<<(i-))][i-]; else
               st[j][i]=st[j][i-]^st[j+(<<(i-))][i-];
         }
     }
     for (i=; i<=n; i++)
       for (j=; j<=(<<n); j+=(<<i))
       {
           for (k=j; k<=j+(<<i)-; k++)
             next[i][k]=j;
       }
     for (i=; i<=m; i++)
     {
         scanf("%d%d",&A,&B);
         st[A][]=B;
         for (j=; j<=n; j++)
         {
             now=next[j][A];
             if (j % ==) st[now][j]=st[now][j-]|st[now+(<<(j-))][j-]; else
                 st[now][j]=(st[now][j-]^st[now+(<<(j-))][j-]);
         }
         cout<<st[][n]<<endl;
     }
     return ;
 }

std的set表