Codeforces Round #393 (Div. 2)
Petr wants to make a calendar for current month. For this purpose he draws a table in which columns correspond to weeks (a week is seven consequent days from Monday to Sunday), rows correspond to weekdays, and cells contain dates. For example, a calendar for January 2017 should look like on the picture:
Petr wants to know how many columns his table should have given the month and the weekday of the first date of that month? Assume that the year is non-leap.
The only line contain two integers m and d (1 ≤ m ≤ 12, 1 ≤ d ≤ 7) — the number of month (January is the first month, December is the twelfth) and the weekday of the first date of this month (1 is Monday, 7 is Sunday).
Print single integer: the number of columns the table should have.
- 1 7
- 6
- 1 1
- 5
- 11 6
- 5
The first example corresponds to the January 2017 shown on the picture in the statements.
In the second example 1-st January is Monday, so the whole month fits into 5 columns.
In the third example 1-st November is Saturday and 5 columns is enough.
题意:
假设没有闰年,给出每个月第一天是星期几,问这个月的日历有几列...
代码:
- #include<algorithm>
- #include<iostream>
- #include<cstring>
- #include<cstdio>
- //by NeighThorn
- using namespace std;
- int n,m,ans=0;
- inline int judge(int x){
- if(x<=7){
- if(x&1)
- return 31;
- else if(x==2)
- return 28;
- else
- return 30;
- }
- else{
- if(x&1)
- return 30;
- return 31;
- }
- }
- signed main(void){
- scanf("%d%d",&n,&m);
- n=judge(n);
- n-=7-m+1;
- ans=1+(n+6)/7;
- printf("%d\n",ans);
- return 0;
- }//Cap ou pas cap. Cap.
n hobbits are planning to spend the night at Frodo's house. Frodo has n beds standing in a row and m pillows (n ≤ m). Each hobbit needs a bed and at least one pillow to sleep, however, everyone wants as many pillows as possible. Of course, it's not always possible to share pillows equally, but any hobbit gets hurt if he has at least two pillows less than some of his neighbors have.
Frodo will sleep on the k-th bed in the row. What is the maximum number of pillows he can have so that every hobbit has at least one pillow, every pillow is given to some hobbit and no one is hurt?
The only line contain three integers n, m and k (1 ≤ n ≤ m ≤ 109, 1 ≤ k ≤ n) — the number of hobbits, the number of pillows and the number of Frodo's bed.
Print single integer — the maximum number of pillows Frodo can have so that no one is hurt.
- 4 6 2
- 2
- 3 10 3
- 4
- 3 6 1
- 3
In the first example Frodo can have at most two pillows. In this case, he can give two pillows to the hobbit on the first bed, and one pillow to each of the hobbits on the third and the fourth beds.
In the second example Frodo can take at most four pillows, giving three pillows to each of the others.
In the third example Frodo can take three pillows, giving two pillows to the hobbit in the middle and one pillow to the hobbit on the third bed.
题意:
有n张床排成一行,Frodo在第k张床,共有m个枕头,每个人至少有1个枕头,并且每个人相邻的两个人只能比他多至多一个枕头,问Frodo最多可以得到多少个枕头...
分析:
二分答案...
最优解一定是阶梯型的...
假设Frodo的一边有y张床,当前二分的ans=x,如果y大于x-1,那么这一边加上Frodo最少共有$\frac{(x+1)x}{2}+y-(x-1)$个枕头,否则就是$\frac{(x+x-y)(y+1)}{2}$...然后判断就好了...
代码:
- #include<algorithm>
- #include<iostream>
- #include<cstring>
- #include<cstdio>
- //by NeighThorn
- using namespace std;
- int n,m,k;
- inline long long calc(int x,int y){
- if(!y)
- return x;
- if(!x)
- return 0;
- if(y>x-1)
- return 1LL*(x+1)*x/2LL+y-(x-1);
- return 1LL*(x+x-y)*(y+1)/2LL;
- }
- signed main(void){
- scanf("%d%d%d",&n,&m,&k);
- int l=0,r=1e9,ans=0;
- while(l<=r){
- int mid=(l+r)>>1;
- if(calc(mid,k-1)+calc(mid,n-k)-mid<=m)
- ans=mid,l=mid+1;
- else
- r=mid-1;
- }
- printf("%d\n",ans);
- return 0;
- }//Cap ou pas cap. Cap.
C. Pavel and barbecue
Pavel cooks barbecue. There are n skewers, they lay on a brazier in a row, each on one of n positions. Pavel wants each skewer to be cooked some time in every of n positions in two directions: in the one it was directed originally and in the reversed direction.
Pavel has a plan: a permutation p and a sequence b1, b2, ..., bn, consisting of zeros and ones. Each second Pavel move skewer on position i to position pi, and if bi equals 1 then he reverses it. So he hope that every skewer will visit every position in both directions.
Unfortunately, not every pair of permutation p and sequence b suits Pavel. What is the minimum total number of elements in the given permutation p and the given sequence b he needs to change so that every skewer will visit each of 2n placements? Note that after changing the permutation should remain a permutation as well.
There is no problem for Pavel, if some skewer visits some of the placements several times before he ends to cook. In other words, a permutation p and a sequence b suit him if there is an integer k (k ≥ 2n), so that after k seconds each skewer visits each of the 2nplacements.
It can be shown that some suitable pair of permutation p and sequence b exists for any n.
The first line contain the integer n (1 ≤ n ≤ 2·105) — the number of skewers.
The second line contains a sequence of integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation, according to which Pavel wants to move the skewers.
The third line contains a sequence b1, b2, ..., bn consisting of zeros and ones, according to which Pavel wants to reverse the skewers.
Print single integer — the minimum total number of elements in the given permutation p and the given sequence b he needs to change so that every skewer will visit each of 2n placements.
- 4
4 3 2 1
0 1 1 1
- 2
- 3
2 3 1
0 0 0
- 1
In the first example Pavel can change the permutation to 4, 3, 1, 2.
In the second example Pavel can change any element of b to 1.
题意:
我真的没看懂题...现在都没看懂TAT...
A new innovative ticketing systems for public transport is introduced in Bytesburg. Now there is a single travel card for all transport. To make a trip a passenger scan his card and then he is charged according to the fare.
The fare is constructed in the following manner. There are three types of tickets:
- a ticket for one trip costs 20 byteland rubles,
- a ticket for 90 minutes costs 50 byteland rubles,
- a ticket for one day (1440 minutes) costs 120 byteland rubles.
Note that a ticket for x minutes activated at time t can be used for trips started in time range from t to t + x - 1, inclusive. Assume that all trips take exactly one minute.
To simplify the choice for the passenger, the system automatically chooses the optimal tickets. After each trip starts, the system analyses all the previous trips and the current trip and chooses a set of tickets for these trips with a minimum total cost. Let the minimum total cost of tickets to cover all trips from the first to the current is a, and the total sum charged before is b. Then the system charges the passenger the sum a - b.
You have to write a program that, for given trips made by a passenger, calculates the sum the passenger is charged after each trip.
The first line of input contains integer number n (1 ≤ n ≤ 105) — the number of trips made by passenger.
Each of the following n lines contains the time of trip ti (0 ≤ ti ≤ 109), measured in minutes from the time of starting the system. All ti are different, given in ascending order, i. e. ti + 1 > ti holds for all 1 ≤ i < n.
Output n integers. For each trip, print the sum the passenger is charged after it.
- 3
10
20
30
- 20
20
10
- 10
13
45
46
60
103
115
126
150
256
516
- 20
20
10
0
20
0
0
20
20
10
In the first example, the system works as follows: for the first and second trips it is cheaper to pay for two one-trip tickets, so each time 20 rubles is charged, after the third trip the system understands that it would be cheaper to buy a ticket for 90 minutes. This ticket costs 50 rubles, and the passenger had already paid 40 rubles, so it is necessary to charge 10 rubles only.
题意:
有三种车票可供选择:
No.0 坐一站,花费为20
No.1 坐90-1分钟,花费为50(因为在站台需要花费1分钟,所以要-1)
No.2 坐1440-1分钟,花费为120
给出n个站点,每一次给出到下一站点的时间,每一次买票都是最优选择,问每一次买票需要多交多少钱...
分析:
感觉这就是裸的DP然后输出每一次的结果减去上一次的结果...
代码:
- #include<algorithm>
- #include<iostream>
- #include<cstring>
- #include<cstdio>
- //by NeighThorn
- using namespace std;
- const int maxn=100000+5;
- int n,t[maxn];
- long long f[maxn];
- signed main(void){
- scanf("%d",&n);
- for(int i=1;i<=n;i++)
- scanf("%d",&t[i]);
- f[0]=0;
- for(int i=1;i<=n;i++){
- f[i]=f[i-1]+20;
- long long a=lower_bound(t+1,t+n+1,t[i]-89 )-t-1,w1=20*(i-a+1);
- long long b=lower_bound(t+1,t+n+1,t[i]-1439)-t-1,w2=20*(i-b+1);
- if(w1>50 )
- f[i]=min(f[i],f[a]+50 );
- else
- f[i]=min(f[i],f[a]+w1);
- if(w2>120)
- f[i]=min(f[i],f[b]+120);
- else
- f[i]=min(f[i],f[b]+w2);
- printf("%I64d\n",f[i]-f[i-1]);
- }
- return 0;
- }//Cap ou pas cap. Cap.
Nikita has a stack. A stack in this problem is a data structure that supports two operations. Operation push(x) puts an integer x on the top of the stack, and operation pop() deletes the top integer from the stack, i. e. the last added. If the stack is empty, then the operation pop() does nothing.
Nikita made m operations with the stack but forgot them. Now Nikita wants to remember them. He remembers them one by one, on the i-th step he remembers an operation he made pi-th. In other words, he remembers the operations in order of some permutation p1, p2, ..., pm. After each step Nikita wants to know what is the integer on the top of the stack after performing the operations he have already remembered, in the corresponding order. Help him!
The first line contains the integer m (1 ≤ m ≤ 105) — the number of operations Nikita made.
The next m lines contain the operations Nikita remembers. The i-th line starts with two integers pi and ti (1 ≤ pi ≤ m, ti = 0 or ti = 1) — the index of operation he remembers on the step i, and the type of the operation. ti equals 0, if the operation is pop(), and 1, is the operation is push(x). If the operation is push(x), the line also contains the integer xi (1 ≤ xi ≤ 106) — the integer added to the stack.
It is guaranteed that each integer from 1 to m is present exactly once among integers pi.
Print m integers. The integer i should equal the number on the top of the stack after performing all the operations Nikita remembered on the steps from 1 to i. If the stack is empty after performing all these operations, print -1.
- 2
2 1 2
1 0
- 2
2
- 3
1 1 2
2 1 3
3 0
- 2
3
2
- 5
5 0
4 0
3 1 1
2 1 1
1 1 2
- -1
-1
-1
-1
2
In the first example, after Nikita remembers the operation on the first step, the operation push(2) is the only operation, so the answer is 2. After he remembers the operation pop() which was done before push(2), answer stays the same.
In the second example, the operations are push(2), push(3) and pop(). Nikita remembers them in the order they were performed.
In the third example Nikita remembers the operations in the reversed order.
题意:
有一个栈...(就是普通的栈...
有m个操作,但是这m个操作不是按顺序给出的...每一次给出第p[i]个操作,每一次都询问按顺序执行完前i个给出操作后的栈顶元素...
分析:
我们把出栈操作看作-1,入栈操作看作+1,那么倒着数第一个使得操作为+的元素就是栈顶元素...
所以问题就转化为了每次给一个位置+1或者-1,最靠右的使得后缀和为1的数是多少...
这不就是线段树么...
代码:
- #include<algorithm>
- #include<iostream>
- #include<cstring>
- #include<cstdio>
- //by NeighThorn
- using namespace std;
- const int maxn=100000+5;
- int n,w[maxn];
- struct Tree{
- int l,r,push,pop;
- }tree[maxn<<2];
- inline void build(int l,int r,int tr){
- tree[tr].l=l,tree[tr].r=r,tree[tr].push=tree[tr].pop=0;
- if(l==r)
- return;
- int mid=(l+r)>>1;
- build(l,mid,tr<<1);build(mid+1,r,tr<<1|1);
- }
- inline void change(int pos,int x,int tr){
- if(tree[tr].l==tree[tr].r){
- if(x)
- tree[tr].push=1;
- else
- tree[tr].pop=1;
- return;
- }
- int mid=(tree[tr].l+tree[tr].r)>>1;
- if(pos<=mid)
- change(pos,x,tr<<1);
- else
- change(pos,x,tr<<1|1);
- int lala=min(tree[tr<<1].push,tree[tr<<1|1].pop);
- tree[tr].push=tree[tr<<1].push+tree[tr<<1|1].push-lala;
- tree[tr].pop =tree[tr<<1].pop +tree[tr<<1|1].pop -lala;
- }
- inline int query(int sum,int tr){
- if(!tree[tr].push)
- return -1;
- if(tree[tr].l==tree[tr].r)
- return w[tree[tr].l];
- int mid=(tree[tr].l+tree[tr].r)>>1;
- if(tree[tr<<1|1].push+sum>0)
- return query(sum,tr<<1|1);
- else
- return query(sum+tree[tr<<1|1].push-tree[tr<<1|1].pop,tr<<1);
- }
- signed main(void){
- scanf("%d",&n);build(1,n,1);
- for(int i=1,pos,opt,x;i<=n;i++){
- scanf("%d%d",&pos,&opt);
- if(opt==1)
- scanf("%d",&w[pos]);
- change(pos,opt,1);
- printf("%d\n",query(0,1));
- }
- return 0;
- }//Cap ou pas cap. Cap.
By NeighThorn
Codeforces Round #393 (Div. 2)的更多相关文章
- Codeforces Round #393 (Div. 2) (8VC Venture Cup 2017 - Final Round Div. 2 Edition) E - Nikita and stack 线段树好题
http://codeforces.com/contest/760/problem/E 题目大意:现在对栈有m个操作,但是顺序是乱的,现在每输入一个操作要求你输出当前的栈顶, 注意,已有操作要按它们的 ...
- Codeforces Round #393 (Div. 2) - C
题目链接:http://codeforces.com/contest/760/problem/C 题意:有n个烤串,并且每个烤串起初都放在一个火盆上并且烤串都正面朝上,现在定义p序列,p[i]表示在i ...
- Codeforces Round #393 (Div. 2) - B
题目链接:http://codeforces.com/contest/760/problem/B 题意:给定n张床,m个枕头,然后给定某个特定的人(n个人中的其中一个)他睡第k张床,问这个人最多可以拿 ...
- Codeforces Round #393 (Div. 2) - A
题目链接:http://codeforces.com/contest/760/problem/A 题意:给定一个2017年的月份和该月的第一天的星期,问该月份的日历表中需要多少列.行有7列表示星期一~ ...
- Codeforces Round #393 (Div. 2) (8VC Venture Cup 2017 - Final Round Div. 2 Edition) D - Travel Card
D - Travel Card 思路:dp,类似于单调队列优化. 其实可以写的更简单... #include<bits/stdc++.h> #define LL long long #de ...
- Codeforces Round #393 (Div. 2) (8VC Venture Cup 2017 - Final Round Div. 2 Edition)A 水 B 二分 C并查集
A. Petr and a calendar time limit per test 2 seconds memory limit per test 256 megabytes input stand ...
- 【线段树】Codeforces Round #393 (Div. 1) C. Nikita and stack
就是给你一些元素的进栈 出栈操作,不按给定的顺序,要求你对于每次输入,都依据其及其之前的输入,判断出栈顶的元素是谁. 用线段树维护,每次push,将其位置的值+1,pop,将其位置的值-1.相当于寻找 ...
- 【二分】【动态规划】Codeforces Round #393 (Div. 1) B. Travel Card
水dp,加个二分就行,自己看代码. B. Travel Card time limit per test 2 seconds memory limit per test 256 megabytes i ...
- 【置换群】Codeforces Round #393 (Div. 1) A. Pavel and barbecue
就是先看排列p,必须满足其是一个环,才满足题意.就处理出有几个环,然后把它们合起来,答案就是多少. 然后再看序列b,自己稍微画一画就会发现,如果有偶数个1肯定是不行哒,否则,它就会再置换一圈回到它自己 ...
随机推荐
- centos7安装mongodb3.6
1. 安装一下centos(6.5) + 虚拟机,在VMware中安装mongodb 2. 下载mongodb最新版本:mongodb-linux-x86_64-3.6.4.tgz,传到centos ...
- ATM-interface-bank
from lib import commonfrom db import db_handler user_logger = common.get_logger('bank') def check_ba ...
- Python基础函数必学
我们知道圆的面积计算公式为: S = πr2 当我们知道半径r的值时,就可以根据公式计算出面积.假设我们需要计算3个不同大小的圆的面积: r1 = 12.34 r2 = 9.08 r3 = 73.1 ...
- Python学习笔记(二):数据类型
一.python中的数据类型 python中的数据类型包括:整型.浮点型.布尔型.字符串类型 整型(int)和浮点型(float) Python中的整型只有int,没有short.long:浮点型fl ...
- 递推:Number Sequence(mod找规律)
解题心得: 1.对于数据很大,很可怕,不可能用常规手段算出最后的值在进行mod的时候,可以思考找规律. 2.找规律时不必用手算(我傻,用手算了好久).直接先找前100项进行mod打一个表出来,直接看就 ...
- HDU 3966 Aragorn's Story 树链拋分
一.写在前面 终于开始开坑link-cut-tree这个了,对于网上找到的大佬的前进路线,进行了一番研发,发现实际上可以实现对于树链拋分的制作.经历了若干长时间之后终于打了出来(为什么每次学什么东西都 ...
- Flume-NG源码分析-整体结构及配置载入分析
在 http://flume.apache.org 上下载flume-1.6.0版本,将源码导入到Idea开发工具后如下图所示: 一.主要模块说明 flume-ng-channels 里面包含了fil ...
- volley框架使用
volley网络请求一个json数据很简单,一句话就搞定了. StringRequest stringRequest=new StringRequest(url, new Listener<St ...
- getshell不用英文数字 或者不用下划线
getshell不用英文字母和数字 上代码 实际代码没有echo strlen($code);我测试的时候加上去的 思路是eval执行getFlag函数. 过滤了字母和数字,长度得小于40 直接看pa ...
- Leetcode 639.解码方法2
解码方法2 一条包含字母 A-Z 的消息通过以下的方式进行了编码: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 除了上述的条件以外,现在加密字符串可以包含字符 ' ...