个人训练记录-赛码"bestcoder"杯中国大学生程序设计冠军赛

　A.Movie

　　题意是给n个线段，要求求出是否存在三个不相交的线段，是的话输出yes，否则输出no。根据贪心的想法，可以先找出右端点r'最小的线段，他是三条线段中最左的那条，再找出左端点l'最大的线段，他是三条线段中最右的那条，这样我们只需要找出是否存在一条线段可以放在中间，即区间[l,r]，l>r',r<l'。

　　代码

 #include<cstdio>
 int n;
 long long L,R,l,r,a,b,c,d,mi,mx,flag,u,v,i;
 int main()
 {
     int test;
     long long P=;
     scanf("%d",&test);
     while(test--)
     {flag=;
     scanf("%d%I64d%I64d%I64d%I64d%I64d%I64d",&n,&l,&r,&a,&b,&c,&d);
     L=l;R=r;
     u=L;v=R;
     mi=P;mx=;
     if (u>v) u^=v^=u^=v;
     if (v<mi) mi=v;
     if (u>mx) mx=u;
     for (i=;i<=n;i++)
     {
         L=(L*a+b)%P;
         R=(R*c+d)%P;
         u=L;v=R;
         if (u>v) u^=v^=u^=v;
         if (v<mi) mi=v;
         if (u>mx) mx=u;
     }
     L=l;R=r;
     u=l;v=r;if (u>v) u^=v^=u^=v;
         if ((u>mi)&&(v<mx)) flag=;
     for (i=;i<=n;i++)
     {
         if (flag) break;
         L=(L*a+b)%P;
         R=(R*c+d)%P;
         u=L;v=R;if (u>v) u^=v^=u^=v;
         if ((u>mi)&&(v<mx)) flag=;
     }
     if (flag) printf("YES\n");else printf("NO\n");}
 }

B.Cycle

　　题意是问给一张无向图，是否存在一个奇环或者偶环，环可以经过同样的点，做法是需要先求出dfs求出一颗树，一些边为树边，一些边为非树边，首先一条非树边和一些树边可以构成一些环，我们可以先判断这些环长度的奇偶性，然后如果一个环可能由多条非树边构成，需要怎么求，也很简单，如果存多个由一条非树边构成的环，他们交集非空，那么有他们复合成环的长度的奇偶性即为这些环的奇偶性的和，即使这些环的交集可能经过一些边，也不要紧，因为构成的环的边是否存在，是根据有多少个环包含这条边所决定，若存在奇数个环包含该边，则该边存在，否则不存在，因而复合环的奇偶性等价于这些环的奇偶性的和。

　　代码

 #pragma comment(linker, "/STACK:102400000,102400000")
 #include<cstdio>
 const int M = ;
 const int N = ;
 int vis[N],deep[N],jump[N][],i,a[N],b[N],v[N][];
 int dp,p[N],pre[M],tt[M],id[M],flag[N],n,m,Flag[],s[N][];
 void link(int x,int y,int z)
 {
     dp++;pre[dp]=p[x];p[x]=dp;tt[dp]=y;id[dp]=z;
 }
 void dfs(int x,int fa)
 {
     vis[x]=;
     deep[x]=deep[fa]+;
     jump[x][]=fa;
     int i;
     for (i=;i<=;i++)
     jump[x][i]=jump[jump[x][i-]][i-];
     i=p[x];
     while (i)
     {
         if (!vis[tt[i]])
         {
             dfs(tt[i],x);
             flag[id[i]]=;
         }
         i=pre[i];
     }
 }
 int lca(int a,int b)
 {
     if (deep[a]<deep[b]) a^=b^=a^=b;
     int i;
     for (i=;i>=;i--)
     if (deep[jump[a][i]]>=deep[b]) a=jump[a][i];
     if (a==b) return a;
     for (i=;i>=;i--)
     if (jump[a][i]!=jump[b][i])
     {
         a=jump[a][i];b=jump[b][i];
     }
     return jump[a][];
 }
 void gao(int x)
 {
     int i;
     s[x][]+=v[x][];
     s[x][]+=v[x][];
     i=p[x];
     while (i)
     {
         if (jump[tt[i]][]==x)
         {
             gao(tt[i]);
             s[x][]+=s[tt[i]][];
             s[x][]+=s[tt[i]][];
         }
         i=pre[i];
     }
     if (s[x][]) Flag[]=;
     if (s[x][]) Flag[]=;
     if (s[x][]>=) Flag[]=;
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d%d",&n,&m);
     dp=;
     for (i=;i<=n;i++)
     p[i]=vis[i]=v[i][]=v[i][]=s[i][]=s[i][]=;
     Flag[]=Flag[]=;
     for (i=;i<=m;i++)
     {
         flag[i]=;
         scanf("%d%d",&a[i],&b[i]);
         link(a[i],b[i],i);
         link(b[i],a[i],i);
     }
     for (i=;i<=n;i++)
     if (vis[i]==) dfs(i,);
     for (i=;i<=m;i++)
     if (!flag[i])
     {
         int c=lca(a[i],b[i]);
         int dis=(deep[a[i]]+deep[b[i]]-*deep[c]+)%;
         v[jump[c][]][dis]--;
         v[c][dis]--;
         v[a[i]][dis]++;
         v[b[i]][dis]++;
     }
     for (i=;i<=n;i++)
     if (jump[i][]==) gao(i);
     if (Flag[])
     printf("YES\n");else printf("NO\n");
     if (Flag[])
     printf("YES\n");else printf("NO\n");
     }
 }

C.Segment

　　假设对于一个可行的方案，若Ai<Aj,且Bpi>Bpj,那么[Ai，Bpi]∩[Aj,Bpj]与[Ai，Bpj]∩[Aj,Bpi]是等价的，因此我们可以一直将这样的pi和pj进行交换，直到不存在这样的方案，也就是说对于所有的可行方案，经过这样的交换后，配对都会变成一样的，因此可以将A与B进行排序。若存在Ai>Bi则不存在可行方案，否则找一个最长的输出即可。

　　代码

 #include<iostream>
 #include<stdio.h>
 #include<math.h>
 #include<string.h>
 #include<stdlib.h>
 #include<algorithm>
 using namespace std;
 const int N= ;
 int n,m,i,a[N],b[N],f[N],j,flag,cnt,ans;
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
         ans=;cnt=;flag=;
     scanf("%d%d",&n,&m);
         for (i=;i<=n;i++) f[i]=;
     for (i=;i<=m;i++)
     scanf("%d",&a[i]);
     for (i=;i<=m;i++)
     scanf("%d",&b[i]);
     sort(a+,a++m);
     sort(b+,b++m);
     for (i=;i<=m;i++)
     {
         for (j=a[i];j<=b[i];j++)
         f[j]=;
     if (a[i]>b[i])
     {
         flag=;break;
     }
     }
     for (i=;i<=n;i++)
     if (f[i]==) cnt++;else
     {
         if (cnt>ans) ans=cnt;cnt=;
     }
     if (cnt>ans) ans=cnt;
     if (flag) printf("Stupid BrotherK!\n");
     else
     printf("%d.000000\n",ans);
     }
 }

D.Brackets

　  题意是给一个括号序列，支持两种操作，第一种是修改一个位置的括号，第二种是查询区间[L,R]中，第k个未匹配括号是哪一个，输出下标。若无解输出-1

　  首先考虑有无解的判断，若一个序列中消除了已匹配的括号，那么未匹配括号必定是这种形式)))....)))(((((....((,我们可以根据前缀和来判断有无解，做法如下:

　　先将'(’视为1，')'视为-1，维护括号序列每个位置的的前缀和sum，那么在区间[L,R]中，未匹配括号的个数即为sum[L-1]+sum[R]-2*min(sum[i])(L<=i<=R)，区间最小的前缀和可以用线段树维护一下。

　  然后考虑有解情况，若k<=sum[L-1]-sum[i]，则答案为区间[l,r]中最靠左边的前缀和为sum[L-1]-k的括号的位置。否则为区间中最靠右边的，且前缀和为min(sum[i])+(k-(sum[L-1]-min(sum[i])))的括号的位置+1。

用线段树维护一下前缀和最小值，即可进行上面解决方法的所有操作，复杂度O(nlogn)

　　代码

 #include<cstdio>
 #include<set>
 #define fi first
 #define sc second
 using namespace std;
 typedef pair<int,int> P;
 const int N = ;
 int v[N],e[N],n,m,i,o;
 P s[N];
 char ch[N];
 P min(P a,P b)
 {
     if (a.fi==b.fi)
     {
         if (a.sc<b.sc) return a;return b;
     }
     if (a.fi<b.fi) return a;return b;
 }
 void clean(int x)
 {
     if (v[x])
     {
         s[x].fi+=v[x];
         v[*x]+=v[x];
         v[*x+]+=v[x];
         v[x]=;
     }
 }
 void gao(int x,int l,int r)
 {
     v[x]=;
     if (r-l==)
     {
         s[x].fi=e[r];
         s[x].sc=r;
     }
     else
     {
         int m=(l+r)>>;
         gao(*x,l,m);
         gao(*x+,m,r);
         s[x]=min(s[*x],s[*x+]);
     }
 }
 void change(int x,int a,int b,int l,int r,int c)
 {
     clean(x);
     if ((a<=l)&&(r<=b))
     {
         v[x]+=c;
         return;
     }
     int m=(l+r)>>;
     if (a<m) change(*x,a,b,l,m,c);
     if (m<b) change(*x+,a,b,m,r,c);
     clean(*x);clean(*x+);
     s[x]=min(s[*x],s[*x+]);
 }
 P query(int x,int a,int b,int l,int r)
 {
     clean(x);
     if ((a<=l)&&(r<=b)) return s[x];
     int m=(l+r)>>;
     P tmp;tmp.fi=;
     if (a<m) tmp=min(tmp,query(*x,a,b,l,m));
     if (m<b) tmp=min(tmp,query(*x+,a,b,m,r));
     return tmp;
 }
 int get(int x,int a,int b,int l,int r,int c,int typ)
 {
     clean(x);
     if (s[x].fi>c) return ;
     int m=(l+r)>>;
     int ans=;
     if (r-l==)
     {
         if (s[x].fi==c) return r;else return ;
     }
     if ((a<=l)&&(r<=b))
     {
         if (typ==)
         {
             ans=get(*x,a,b,l,m,c,typ);
             if (ans) return ans;
             ans=get(*x+,a,b,m,r,c,typ);
             return ans;
         }
         else
         {
             ans=get(*x+,a,b,m,r,c,typ);
             if (ans) return ans;
             ans=get(*x,a,b,l,m,c,typ);
             return ans;
         }
     }
     if (typ==)
     {
     if (a<m) ans=get(*x,a,b,l,m,c,typ);
     if (ans) return ans;
     if (m<b) ans=get(*x+,a,b,m,r,c,typ);
     return ans;
     }
     else
     {
     if (m<b) ans=get(*x+,a,b,m,r,c,typ);
     if (ans) return ans;
     if (a<m) ans=get(*x,a,b,l,m,c,typ);
     return ans;
     }
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d%d",&n,&m);
     for (i=;i<=n;i++)
     scanf(" %c",&ch[i]);
     for (i=;i<=n;i++)
     if (ch[i]=='(') e[i+]=e[i]+;else e[i+]=e[i]-;
     gao(,,n+);
     for (i=;i<=m;i++)
     {
         int typ,a,b,c;
         scanf("%d",&typ);
         if (typ==)
         {
             scanf("%d",&a);
             if (ch[a]=='(')
             {
                 ch[a]=')';
                 a++;
                 change(,a-,n+,,n+,-);
             }
             else
             {
                 ch[a]='(';
                 a++;
                 change(,a-,n+,,n+,);
             }
         }
         else
         {
             scanf("%d%d%d",&a,&b,&c);
             a++;b++;
             P tmp=query(,a-,b,,n+);

             int p=,q=;
             p=query(,a-,a-,,n+).fi;
             q=query(,b-,b,,n+).fi;

             if (p-tmp.fi+q-tmp.fi<c)
                 printf("-1\n");
             else
             if (c<=p-tmp.fi)
                 printf("%d\n",get(,a-,n+,,n+,p-c,)-);
             else
                 printf("%d\n",get(,,b,,n+,tmp.fi+c-(p-tmp.fi)-,));
         }
     }
     }
 } 

E.Game

题意是有n个人站成环，有一个集合S，每次从集合S中随机选出一个数字s，然后依次报数，报道s的人从环中出去，问n轮后有哪些人有获胜的可能性。经典的约瑟夫问题，可以O(N^3)dp解决。

代码

 #include<cstdio>
 const int N = ;
 int n,m,i,j,k,t,a[N],f[N][N],ans;
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d%d",&n,&m);
     for (i=;i<=m;i++)
     scanf("%d",&a[i]);
     for (i=;i<=n;i++)
     for (j=;j<=n;j++)
     f[i][j]=;
     f[][]=;
     for (i=;i<=n;i++)
     {
         for (j=;j<=m;j++)
         {
             t=(a[j]-)%i;
             for (k=;k<i;k++)
             if (f[i-][k])
             f[i][(t++k)%i]=;
         }
     }
     ans=;
     for (i=;i<n;i++)
     if (f[n][i]) ans++;
     printf("%d\n",ans);
     int flag=;
     for (i=;i<n;i++)
     if (f[n][i])
     {
         if (flag) printf(" ");
         flag=;
         printf("%d",i+);
     }
     printf("\n");
     }
 }

　　

F.

G.

H.Occupation

　　题意是给一棵树，树上每个点都有一个权值，有三类操作，1.取一条路径上所有的没被取的点，2.如果x点被取了，则将其变为未取的状态，3.去以x为根的子树上所有没被取的点，每次操作后求出被取点的价值总和。

　　裸的树链剖分。。。

　　代码

 #include<cstdio>
 const int N = ;
 int dp,pre[N],p[N],tt[N],size[N],id[N],f[N],deep[N],go[N],L[N],R[N];
 int cnt,gf[N],i,n,e[N],a,b,v[N],s[N],sum[N];
 void link(int x,int y)
 {
     dp++;pre[dp]=p[x];p[x]=dp;tt[dp]=y;
 }
 void dfs1(int x,int y)
 {
     size[x]=;
     int i=p[x];
     while (i)
     {
         if (tt[i]!=y)
         {
             f[tt[i]]=x;
             deep[tt[i]]=deep[x]+;
             dfs1(tt[i],x);
             size[x]+=size[tt[i]];
             if (size[tt[i]]>size[go[x]]) go[x]=tt[i];
         }
         i=pre[i];
     }
 }
 void dfs2(int x,int y)
 {
     L[x]=++cnt;
     id[cnt]=x;
     gf[x]=y;
     if (go[x]) dfs2(go[x],y);
     int i=p[x];
     while (i)
     {
         if (deep[tt[i]]>deep[x])
         if (tt[i]!=go[x])
         dfs2(tt[i],tt[i]);
         i=pre[i];
     }
     R[x]=cnt;
 }
 void clean(int x)
 {
     if (v[x])
     {
         v[x]=;
         s[x]=sum[x];
         v[*x]=;
         v[*x+]=;
     }
 }
 void change(int x,int a,int b,int l,int r,int c)
 {
     clean(x);
     if ((a<=l)&&(r<=b))
     {
         if (c) v[x]=;else s[x]=;
         return;
     }
     int m=(l+r)>>;
     if (a<m) change(*x,a,b,l,m,c);
     if (m<b) change(*x+,a,b,m,r,c);
     clean(*x);clean(*x+);
     s[x]=s[*x]+s[*x+];
 }
 void gao(int a,int b)
 {
     while ()
     {
         if (deep[gf[a]]<deep[gf[b]]) a^=b^=a^=b;
         if (gf[a]==gf[b])
         {
             if (deep[a]<deep[b]) a^=b^=a^=b;
             change(,L[b]-,L[a],,n,);
             return;
         }
         else
         {
             change(,L[gf[a]]-,L[a],,n,);
             a=f[gf[a]];
         }
     }
 }
 void get(int x,int l,int r)
 {
     v[x]=s[x]=;
     if (r-l==)
     {
         sum[x]=e[id[r]];
         return;
     }
     int m=(l+r)>>;
     get(*x,l,m);
     get(*x+,m,r);
     sum[x]=sum[*x]+sum[*x+];
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d",&n);dp=cnt=;
     for (i=;i<=n;i++)
     {
         scanf("%d",&e[i]);
         p[i]=go[i]=deep[i]=gf[i]=f[i]=;
     }
     for (i=;i<n;i++)
     {
         scanf("%d%d",&a,&b);
         link(a,b);link(b,a);
     }
     dfs1(,);
     dfs2(,);
     get(,,n);
     int m;
     scanf("%d",&m);
     for (i=;i<=m;i++)
     {
         int typ;
         scanf("%d",&typ);
         if (typ==)
         {
             scanf("%d%d",&a,&b);
             gao(a,b);
         }
         else
         {
             scanf("%d",&a);
             if (typ==)
                 change(,L[a]-,L[a],,n,);
             else
                 change(,L[a]-,R[a],,n,);
         }
         clean();
         printf("%d\n",s[]);
     }
     }
 }

I.Exploration

　　题意是给一张图，其中有一些边为双向，有一些为单向，问是否存在一个起点，其能走出一条路径，至少能到达一个起点以外的点，且最终能回到起点，注意路一旦经过，就会坍塌。

　　可以先将双向边连接的点用并查集并起来，如果一个集合中的点不构成一颗树，则说明存在环，那么这个环就可以视为答案，输出YES，如果所有集合都是生成树，那么接着考虑有向边，如果有向边连接的两个点属于同一集合，则存在环经过该有向边，可以直接输出YES，否则则将两端点所在的集合连边，最后进行一边拓扑排序，判断是否存在环，如果存在环输出YES，否则输出NO

代码

 #include<cstdio>
 #include<queue>
 using namespace std;
 const int N = ;
 int f[N],n,m1,m2,l[N],r[N],i,a,b,id[N],cnt,rd[N];
 int dp,pre[N],p[N],tt[N],vis[N];
 queue<int> Q;
 int gf(int x)
 {
     int t,p;
     p=x;
     while (p!=f[p]) p=f[p];
     while (x!=p)
     {
         t=f[x];
         f[x]=p;
         x=t;
     }
     return p;
 }
 void link(int x,int y)
 {
     dp++;pre[dp]=p[x];p[x]=dp;tt[dp]=y;
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d%d%d",&n,&m1,&m2);
     for (i=;i<=m1;i++)
     scanf("%d%d",&l[i],&r[i]);
     for (i=;i<=m2;i++)
     scanf("%d%d",&l[m1+i],&r[m1+i]);
     dp=;
     for (i=;i<=n;i++) f[i]=i,id[i]=rd[i]=p[i]=vis[i]=;
     for (i=;i<=m1;i++)
     {
         if (l[i]==r[i]) continue;
         a=gf(l[i]);b=gf(r[i]);
         if (a==b) break;
         f[a]=b;
     }
     if (i<=m1)
     {
         printf("YES\n");
         continue;
     }
     cnt=;
     for (i=;i<=n;i++)
     {
         if (id[gf(i)]==) id[gf(i)]=++cnt;
         id[i]=id[gf(i)];
     }
     for (i=m1+;i<=m1+m2;i++)
     {
         if (l[i]==r[i]) continue;
         if (id[l[i]]==id[r[i]]) break;
         link(id[l[i]],id[r[i]]);
         rd[id[r[i]]]++;
     }
     if(i<=m1+m2)
     {
         printf("YES\n");
         continue;
     }
     for (i=;i<=cnt;i++)
     if (rd[i]==) Q.push(i);
     while (!Q.empty())
     {
         int x=Q.front();Q.pop();
         i=p[x];
         while (i)
         {
             rd[tt[i]]--;
             if (!rd[tt[i]]) Q.push(tt[i]);
             i=pre[i];
         }
     }
     for (i=;i<=cnt;i++)
     if (rd[i]) break;
     if (i<=cnt) printf("YES\n");else printf("NO\n");
     }
 }

J.GCD

题意是给一些询问，每次询问区间[L,R]的gcd是多少，且得到的答案为w，问能否构造出一个使得所有询问都满足的答案，如果存在多个方案，输出一个序列和最小的方案。

一开始设序列所有数字为1，对于一个询问[L,R]我们可以把区间[L,R]中的数字ai变为lcm(ai,w),这样就可以构造出一个序列，最后用询问来验证一下这个序列是否合法，如果合法，那么该序列即为最小方案，若不合法即为无解。

　　代码

 #include<cstdio>
 const int N = ;
 int n,m,i,j,l[N],r[N],w[N],test,tmp;
 long long a[N];
 long long gcd(long long a,long long b)
 {
     if (b==) return a;
     return gcd(b,a%b);
 }
 int main()
 {
     scanf("%d",&test);
     while (test--)
     {
     scanf("%d%d",&n,&m);
     for (i=;i<=m;i++)
     scanf("%d%d%d",&l[i],&r[i],&w[i]);
     for (i=;i<=n;i++)
     {
         a[i]=;
         for (j=;j<=m;j++)
         if ((l[j]<=i)&&(i<=r[j]))
         {
             a[i]=(a[i]*w[j])/gcd(a[i],w[j]);
             if (a[i]>) break;
         }
         if (a[i]>) break;
     }
     if (i<=n)
     printf("Stupid BrotherK!\n");
     else
     {
         for (i=;i<=m;i++)
         {
             tmp=;
             for (j=l[i];j<=r[i];j++)
             tmp=gcd(tmp,a[j]);
             if (tmp!=w[i]) break;
         }
         if (i<=m) printf("Stupid BrotherK!\n");
         else
         {
             for (i=;i<n;i++)
             printf("%I64d ",a[i]);printf("%I64d\n",a[n]);
         }
     }
     }
 }