2018.03.14 丢人round1(模拟赛)

 1 Amusing
 2 背景&&描述
 3 
 4     “滑稽树上滑稽果,滑稽梯下你和我”
 5     当年儿童节的情景仍然历历在目,如今小K、小P和小M都已经长大到会压垮滑稽梯的地步了。
 6     总之,试着回到过去吧。
 7     在滑梯旁,小K带来了n个滑稽果,小P在滑梯顶端一个一个地放滑稽果,小M在和妹子谈笑风生。
 8     一开始每个滑稽果的大小都等于1,如果当前最上面的俩滑稽果大小一样的话,俩滑稽果就会合体,新的果子大小为原来的大小+1
 9     注意,放下一个滑稽果后可能引发多次合体;我们假装滑梯可以容纳无限个滑稽果;滑稽果不会滚出滑梯(小M和妹子坐在滑梯底部)
10     小M的妹子想知道最后剩下的那些滑稽果的情况,你能帮帮小M吗?
11 
12 输入格式
13 
14 一行,一个正整数n,表示总共放下了多少个滑稽果
15 
16 输出格式
17 
18 一行,若干个整数,描述剩下的滑稽果的大小(从滑梯的下到上输出),整数之间用一个空格分开。
19 
20  
21 
22 样例输入1
23 
24 3
25 
26 样例输出1
27 
28 2 1
29 
30 
31 样例输入2
32 
33 9
34 
35 样例输出2
36 
37 4 1
38 
39  
40 
41 数据范围与约定
42 
43 对于10%的数据:n=1
44 对于100%的数据:1\leq n\leq 23333
45 样例解释2
46 
47 每放一个之后的情况如下。(右边是滑梯顶端)
48 
49 1
50 2
51 2 1
52 3
53 3 1
54 3 2
55 3 2 1
56 4
57 4 1 
58  
59 
60 来源
61 
62 cf某题
T1

签到题,直接模拟。

 

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<algorithm>
 4 #include<cstring>
 5 #include<map>
 6 #include<set>
 7 #include<queue>
 8 #include<cmath>
 9 #include<cctype>
10 #include<stack>
11 using namespace std;
12 
13 
14 #define INF 0x3f3f3f3f
15 #define REP(i,a,b)    for(int i=a;i<=b;++i)
16 #define DOW(i,a,b)    for(int i=a;i>=b;--i)
17 #define CL(a,b)    memset(a,b,sizeof(a))
18 #define lint long long
19 #define N 20
20 //#define getchar()    (FS==FT&&(FT=(FS=BB)+fread(BB,1,1<<15,stdin),FS==FT)?EOF:*FS++)
21 char *FS,*FT,BB[1<<15];
22 
23 int read(){
24     int x=1,i=0;
25     char ch;
26     ch=getchar();
27     while(!isdigit(ch)){
28         if(ch==EOF){
29             exit(0);
30         }
31         if(ch=='-')x=-1;
32         ch=getchar();
33     }
34     while(isdigit(ch)){
35         i=i*10+ch-'0';
36         ch=getchar();
37     }
38     
39     return x*i;
40 }
41 
42 int get(char *S){
43     char ch;
44     int l=0;
45     ch=getchar();
46     while(!isalnum(ch)){
47         if(ch==EOF){
48             exit(0);
49         }
50         ch=getchar();
51     }
52     while(isalnum(ch)){
53         S[l++]=ch;
54         ch=getchar();
55     }
56     return l;
57 }
58 
59 stack<int> q,b;
60 
61 int main(){
62     int n;
63     n=read();
64     int yq;
65     REP(i,1,n){
66         yq=1;
67         while(!q.empty()&&q.top()==yq){
68             yq++;
69             q.pop();
70         }
71         q.push(yq);
72     }
73     while(!q.empty()){
74         b.push(q.top());
75         q.pop();
76     }
77     while(!b.empty()){
78         printf("%d ",b.top());
79         b.pop();
80     }
81     
82     return 0;
83 }
T1代码

 

 

 1 Assault
 2 背景&&描述
 3 
 4     KPM和mz们天天在小渔村各个场所秀恩爱,FFF团决定实行斩首计划
 5     KPM在ST市有n个窝点,第i个窝点的坐标是( X_{i},Y_{i} )(同个坐标可能有多个窝点,你可以认为那里是一座高楼的不同楼层)
 6     现在每个窝点都被一名团员占据着,但没有人见到KPM
 7     因为FFF团内部还处于石器时代,团员们只能用脚彼此联络
 8     具体一些的话就是,俩团员i和j能彼此联络,当且仅当他们所在的两个点的曼哈顿距离=欧拉距离,即
 9 
10         |X_{i}-X_{j}| + |Y_{i}-Y_{j}| = \sqrt{ (X_{i}-X_{j})^{2}+(Y_{i}-Y_{j})^{2} }
11 
12     如果俩团员彼此联络之后怒气值就会+1(因为都没找到KPM),在帝都军训的KPM想知道总怒气值是多少,即有多少对(i,j),1<=i<j<=n,满足上面那个式子。
13 
14 输入格式
15 
16     第一行一个整数n,接下来n行,每行俩整数,第i+1行的两个整数分别表示X_{i}和Y_{i}
17 
18 输出格式
19 
20     一个整数,表示怒气值总和。
21 
22 样例输入
23 
24 3
25 1 1
26 7 5
27 1 5
28 样例输出
29 
30 2
31 数据范围与约定
32 
33     1\leq n\leq 10^5 ,-10^9\leq X_{i},Y_{i}\leq 10^9
34 
35 样例解释
36 
37     (1,3)和(2,3)这两对。
38 
39 来源
40 
41     cf原题
T2

 

两个sort,扫描线,判定同一横纵坐标有多少个点,提前去重,完。

 

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<algorithm>
  4 #include<cstring>
  5 #include<map>
  6 #include<set>
  7 #include<queue>
  8 #include<cmath>
  9 #include<cctype>
 10 using namespace std;
 11 
 12 
 13 #define INF 0x3f3f3f3f
 14 #define REP(i,a,b)    for(lint i=a;i<=b;++i)
 15 #define DOW(i,a,b)    for(lint i=a;i>=b;--i)
 16 #define CL(a,b)    memset(a,b,sizeof(a))
 17 #define lint long long
 18 #define N 200000
 19 #define getchar()    (FS==FT&&(FT=(FS=BB)+fread(BB,1,1<<15,stdin),FS==FT)?EOF:*FS++)
 20 char *FS,*FT,BB[1<<15];
 21 
 22 lint read(){
 23     lint x=1,i=0;
 24     char ch;
 25     ch=getchar();
 26     while(!isdigit(ch)){
 27         if(ch==EOF){
 28             exit(0);
 29         }
 30         if(ch=='-')x=-1;
 31         ch=getchar();
 32     }
 33     while(isdigit(ch)){
 34         i=i*10+ch-'0';
 35         ch=getchar();
 36     }
 37     
 38     return x*i;
 39 }
 40 
 41 lint get(char *S){
 42     char ch;
 43     lint l=0;
 44     ch=getchar();
 45     while(!isalnum(ch)){
 46         if(ch==EOF){
 47             exit(0);
 48         }
 49         ch=getchar();
 50     }
 51     while(isalnum(ch)){
 52         S[l++]=ch;
 53         ch=getchar();
 54     }
 55     return l;
 56 }
 57 
 58 struct node{
 59     lint x,y;
 60     bool operator ==(const node &a)const{return (x==a.x)&&(y==a.y);}
 61 }E[N];
 62 
 63 bool cmp1(node a,node b){
 64     if(a.x!=b.x)return a.x<b.x;
 65     return a.y<b.y;
 66 }
 67 
 68 bool cmp2(node a,node b){
 69     if(a.y!=b.y)return a.y<b.y;
 70     return a.x<b.x;
 71 }
 72 
 73 int main(){
 74     lint n;
 75     n=read();
 76     REP(i,1,n){
 77         E[i].x=read();E[i].y=read();
 78     }
 79     E[n+1].x=E[n+1].y=INF+5;
 80     sort(E+1,E+1+n,cmp1);
 81     lint sum=0,S=0,X=0;
 82     REP(i,2,n+1){
 83         if(E[i]==E[i-1]){
 84             S++;
 85         }
 86         else X+=(S+1)*S/2,S=0;
 87     }
 88     S=0;
 89     REP(i,2,n+1){
 90         if(E[i].x==E[i-1].x){
 91             S++;
 92         }
 93         else sum+=(S+1)*S/2,S=0;
 94     }
 95     sort(E+1,E+1+n,cmp2);
 96     S=0;
 97     REP(i,2,n+1){
 98         if(E[i].y==E[i-1].y){
 99             S++;
100         }
101         else sum+=(S+1)*S/2,S=0;
102     }
103     printf("%lld",sum-X);
104     return 0;
105 }
T2代码

 

 

 

 

 1 Fluorite
 2 背景&&描述
 3 
 4         kisaki和琉璃拎着各种易燃品打算去山顶上那个废弃教堂
 5         魔法使为了阻止他们,变出了n座山,每座山上都搞了个教堂。
 6 
 7         然而琉璃并不打算找出真正的那个。
 8         第i座山的高度为ai,根据汽油往低处流这个生活常识,如果当前山上有汽油,并且旁边的山高度严格小于当前山的高度,旁边的山上也会有汽油。(“旁边”是指严格相邻)
 9         因为要留着汽油浇书,所以琉璃只会在一座山上倒汽油。
10         琉璃轻松地算出了最多能让多少座山沾上汽油。
11 
12         这时候沉迷拔作的栋栋跑过来捣乱,栋栋每次操作都会把连续一段山给拔起来,也就是给它们的高度增加一个相同的值。
13         kisaki想知道栋栋每次操作后的答案,你能帮帮琉璃吗?
14 
15 输入格式
16 
17         第一行俩整数n,表示山的数量。
18 
19         第二行n个整数,第i个表示第i座山的初始高度。
20 
21         第三行一个整数m,表示栋栋操作次数。
22 
23         接下来m行,每一行三个整数l,r,add,表示栋栋给第l...r座山的高度增加了add
24 
25 输出格式
26 
27         m行,第i行表示第i次操作后,只给一座山倒汽油,最多能使多少座山站上汽油。
28 
29 样例输入
30 
31 5
32 5 5 5 5 5
33 3
34 1 3 2
35 2 2 1
36 4 4 1
37 样例输出
38 
39 2
40 4
41 5
42 数据范围与约定
43 
44 对于20%的数据:m=1
45 对于40%的数据:n*m<=10^{7}
46 对于100%的数据:1\leq n,m\leq 3*10^{5} , 0\leq ai,add\leq 10^{9}
47 样例解释
48 
49  
50 
51     第一次操作后山的高度为[7,7,7,5,5],在第三座上浇汽油,可以让第3,4座都沾上。
52 
53     第二次操作后山的高度为[7,8,7,5,5],在第2座上浇汽油,可以让第1,2,3,4座都沾上。
54 
55     第一次操作后山的高度为[7,8,7,6,5],在第2座上浇汽油,可以让全部都沾上。
56 
57  
58 
59 来源
60 
61     某cf原题
62 
63 其他
64 
65     每个测试点时限+3s,输入输出文件大小在10M以内,实测可放心scanf
T3

 

考试时候看出来了是最大子段和,结果实在是懒得打代码,认为要维护九个域(傻子),考完看题解发现只要五个域(???)(不用区间查询会舒服很多),然后琢磨了好久,终于想明白了。

首先差分一下,然后可得山峰序列即为先正后负的最长子段,然后维护suf,pre和ans三个域,顺便维护左右端点的正负值,可易证只有正正,正负,负负三种情况是合法的,完。

(记得我们维护的前缀和后缀是一段山峰序列而并非单纯的升序或降序)(就是这个点卡了好久)

 

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<algorithm>
  4 #include<cstring>
  5 #include<map>
  6 #include<set>
  7 #include<queue>
  8 #include<cmath>
  9 #include<cctype>
 10 using namespace std;
 11 
 12 
 13 #define INF 0x3f3f3f3f
 14 #define REP(i,a,b)    for(lint i=a;i<=b;++i)
 15 #define DOW(i,a,b)    for(lint i=a;i>=b;--i)
 16 #define CL(a,b)    memset(a,b,sizeof(a))
 17 #define lint long long
 18 #define N 1000005
 19 //#define getchar()    (FS==FT&&(FT=(FS=BB)+fread(BB,1,1<<15,stdin),FS==FT)?EOF:*FS++)
 20 char *FS,*FT,BB[1<<15];
 21 
 22 lint read(){
 23     lint x=1,i=0;
 24     char ch;
 25     ch=getchar();
 26     while(!isdigit(ch)){
 27         if(ch==EOF){
 28             exit(0);
 29         }
 30         if(ch=='-')x=-1;
 31         ch=getchar();
 32     }
 33     while(isdigit(ch)){
 34         i=i*10+ch-'0';
 35         ch=getchar();
 36     }
 37     
 38     return x*i;
 39 }
 40 
 41 lint get(char *S){
 42     char ch;
 43     lint l=0;
 44     ch=getchar();
 45     while(!isalnum(ch)){
 46         if(ch==EOF){
 47             exit(0);
 48         }
 49         ch=getchar();
 50     }
 51     while(isalnum(ch)){
 52         S[l++]=ch;
 53         ch=getchar();
 54     }
 55     return l;
 56 }
 57 
 58 
 59 lint A[N],C[N];
 60 
 61 struct node{
 62     lint l,r,pre,suf,ans,len;
 63     node *ls,*rs;
 64 }pool[N<<1],*root;
 65 
 66 node *newnode(){
 67     static lint cnt=1;
 68     return &pool[cnt++];
 69 }
 70 
 71 bool check(lint a,lint b){
 72     return (a>0&&b!=0)||(a<0&&b<0);
 73 }
 74 
 75 void up(node *i){
 76     if(i->ls){
 77         i->l=i->ls->l;
 78         i->r=i->rs->r;
 79         i->ans=max(i->ls->ans,max(i->rs->ans,(check(i->ls->r,i->rs->l)?(i->ls->suf+i->rs->pre):-INF)));
 80         i->pre=max(i->ls->pre,((i->ls->ans==i->ls->len&&check(i->ls->r,i->rs->l))?i->ls->ans:-INF)+i->rs->pre);
 81         i->suf=max(i->rs->suf,((i->rs->ans==i->rs->len&&check(i->ls->r,i->rs->l))?i->rs->ans:-INF)+i->ls->suf);
 82     }
 83 }
 84 
 85 
 86 node *build(lint l,lint r){
 87     node *i=newnode();
 88     i->len=r-l+1;
 89     if(l<r){
 90         lint mid=(l+r)/2;
 91         i->ls=build(l,mid);
 92         i->rs=build(mid+1,r);
 93         up(i);
 94     }
 95     else{
 96         i->l=C[l],i->r=C[l],i->pre=i->suf=i->ans=((C[l]==0)?0:1);
 97     }
 98     return i;
 99 }
100 
101 void update(node *i,lint l,lint r,lint pos,lint k){
102     if(l==r){
103         i->l+=k;
104         i->r+=k;
105         if(i->l!=0)i->pre=i->suf=i->ans=1;
106         else i->pre=i->suf=i->ans=0;
107         return;
108     }
109     lint mid=(l+r)/2;
110     if(pos<=mid)update(i->ls,l,mid,pos,k);
111     else update(i->rs,mid+1,r,pos,k);
112     up(i);
113 }
114 
115 int main(){
116 //    freopen("yq.in","r",stdin);
117 //    freopen("yq.out","w",stdout);
118     lint n,m;
119     n=read();
120     REP(i,1,n){
121         A[i]=read();
122     }
123     REP(i,1,n-1){
124         C[i]=A[i+1]-A[i];
125     }
126     root=build(1,n-1);
127     m=read();
128     REP(i,1,m){
129         lint a,b,c;
130         a=read(),b=read(),c=read();
131         if(a-1>0)update(root,1,n-1,a-1,c);
132         if(b<=n-1)update(root,1,n-1,b,-c);
133         printf("%lld\n",root->ans+1);
134     }
135     return 0;
136 }
T3代码

 

 

 

 

 1 D 借不到的链
 2 背景&&描述
 3 
 4     琉璃平静地接受了事实,打算找条链子支撑自己的体重。
 5     在魔法使的监视下他没法到五金店买铁链,而其他人都不愿意借给他//点题成功
 6     他自己并不是没有链子,只是它和想要的不太一样。。。
 7     一条链由n个小铁环首尾相接组成,有n-1个铁环挂着装饰品,装饰品的颜色两两不同,颜色用1..n-1的整数表示
 8     也就是说有个铁环上没有东西,精通华容道的琉璃一次操作可以把它旁边的一个装饰品挪到它上面。
 9     琉璃把他拥有的铁链和理想中铁链的颜色告诉了你,想问问他是否可能通过若干次操作使得自己的铁链颜色和理想中的一样。
10 输入格式
11 
12     第一行一个整数n,表示铁环数量。
13 
14     第二行n个整数,表示一开始铁链各铁环的颜色,这n个数是0..n-1的一个排列。
15 
16     第二行n个整数,表示理想中铁链各铁环的颜色,这n个数是0..n-1的一个排列。
17 
18 输出格式
19 
20 如果可能,输出YES,不然输出NO。
21 
22 样例输入1
23 
24 3
25 1 0 2
26 2 0 1
27 样例输出1
28 
29 YES
30  
31 样例输入2
32 
33 4
34 1 2 3 0
35 0 3 2 1
36 样例输出2
37 
38 NO
39  
40 
41 数据范围与约定
42 
43 1\leq n\leq 10^5
44 样例解释1
45 
46 [1,0,2]-->[0,1,2]-->[2,1,0]-->[2,0,1]
47 
48 来源
49 
50 cf原题
T4

 

正解我还没看,不过考场上写了个hash,然后WA了一个点,结果发现是调试的时候把base改成了10好查错,结果没改回来。

其实两个序列就是去掉0之后看看一个序列旋转是否能得到另一个序列,所以选择hash,用unsigned long long自然溢出(感觉可能会被一些毒瘤卡)

 

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<algorithm>
  4 #include<cstring>
  5 #include<map>
  6 #include<set>
  7 #include<queue>
  8 #include<cmath>
  9 #include<cctype>
 10 using namespace std;
 11 
 12 
 13 #define INF 0x3f3f3f3f
 14 #define REP(i,a,b)    for(int i=a;i<=b;++i)
 15 #define DOW(i,a,b)    for(int i=a;i>=b;--i)
 16 #define CL(a,b)    memset(a,b,sizeof(a))
 17 #define lint long long
 18 #define ULL unsigned long long
 19 #define N 200000
 20 #define getchar()    (FS==FT&&(FT=(FS=BB)+fread(BB,1,1<<15,stdin),FS==FT)?EOF:*FS++)
 21 char *FS,*FT,BB[1<<15];
 22 
 23 int read(){
 24     int x=1,i=0;
 25     char ch;
 26     ch=getchar();
 27     while(!isdigit(ch)){
 28         if(ch==EOF){
 29             exit(0);
 30         }
 31         if(ch=='-')x=-1;
 32         ch=getchar();
 33     }
 34     while(isdigit(ch)){
 35         i=i*10+ch-'0';
 36         ch=getchar();
 37     }
 38     
 39     return x*i;
 40 }
 41 
 42 int get(char *S){
 43     char ch;
 44     int l=0;
 45     ch=getchar();
 46     while(!isalnum(ch)){
 47         if(ch==EOF){
 48             exit(0);
 49         }
 50         ch=getchar();
 51     }
 52     while(isalnum(ch)){
 53         S[l++]=ch;
 54         ch=getchar();
 55     }
 56     return l;
 57 }
 58 
 59 ULL A[N],B[N];
 60 
 61 int main(){
 62     ULL base=235281;
 63     ULL n,wan=0,Q=1,yq=0;
 64     scanf("%llu",&n);
 65     REP(i,1,n){
 66         scanf("%llu",&A[i]);
 67         if(A[i]!=0){
 68             wan=wan*base+A[i];
 69             if(i!=1)Q*=base;
 70         }
 71         else{
 72             i--,n--;
 73         }
 74     }
 75     n++;
 76     REP(i,1,n){
 77         scanf("%llu",&B[i]);
 78         if(B[i]!=0){
 79             yq=yq*base+B[i];
 80         }
 81         else{
 82             i--,n--;
 83         }
 84     }
 85     REP(i,1,n){
 86         if(yq==wan){
 87             printf("YES");
 88             return 0;
 89         }
 90 //        printf("%llu \n",yq);
 91         yq-=B[i]*Q;
 92         yq=yq*base+B[i];
 93     }
 94     if(yq==wan){
 95         printf("YES");
 96         return 0;
 97     }
 98     printf("NO");
 99     
100     return 0;
101 }
T4代码

转载于:https://www.cnblogs.com/MakiseKurisuLab004/p/8574913.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值