codeforces #578(Div.2)
A. Hotelier
Amugae has a hotel consisting of 1010 rooms. The rooms are numbered from 00 to 99 from left to right.
The hotel has two entrances — one from the left end, and another from the right end. When a customer arrives to the hotel through the left entrance, they are assigned to an empty room closest to the left entrance. Similarly, when a customer arrives at the hotel through the right entrance, they are assigned to an empty room closest to the right entrance.
One day, Amugae lost the room assignment list. Thankfully Amugae's memory is perfect, and he remembers all of the customers: when a customer arrived, from which entrance, and when they left the hotel. Initially the hotel was empty. Write a program that recovers the room assignment list from Amugae's memory.
Input
The first line consists of an integer nn (1≤n≤1051≤n≤105), the number of events in Amugae's memory.
The second line consists of a string of length nn describing the events in chronological order. Each character represents:
- 'L': A customer arrives from the left entrance.
- 'R': A customer arrives from the right entrance.
- '0', '1', ..., '9': The customer in room xx (00, 11, ..., 99 respectively) leaves.
It is guaranteed that there is at least one empty room when a customer arrives, and there is a customer in the room xx when xx (00, 11, ..., 99) is given. Also, all the rooms are initially empty.
Output
In the only line, output the hotel room's assignment status, from room 00 to room 99. Represent an empty room as '0', and an occupied room as '1', without spaces.
Examples
input
8 LLRL1RL1
output
1010000011
input
9 L0L0LLRR9
output
1100000010
Note
In the first example, hotel room's assignment status after each action is as follows.
- First of all, all rooms are empty. Assignment status is 0000000000.
- L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
- L: one more customer from the left entrance. Assignment status is 1100000000.
- R: one more customer from the right entrance. Assignment status is 1100000001.
- L: one more customer from the left entrance. Assignment status is 1110000001.
- 1: the customer in room 11 leaves. Assignment status is 1010000001.
- R: one more customer from the right entrance. Assignment status is 1010000011.
- L: one more customer from the left entrance. Assignment status is 1110000011.
- 1: the customer in room 11 leaves. Assignment status is 1010000011.
So after all, hotel room's final assignment status is 1010000011.
In the second example, hotel room's assignment status after each action is as follows.
- L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
- 0: the customer in room 00 leaves. Assignment status is 0000000000.
- L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000 again.
- 0: the customer in room 00 leaves. Assignment status is 0000000000.
- L: a customer arrives to the hotel through the left entrance. Assignment status is 1000000000.
- L: one more customer from the left entrance. Assignment status is 1100000000.
- R: one more customer from the right entrance. Assignment status is 1100000001.
- R: one more customer from the right entrance. Assignment status is 1100000011.
- 9: the customer in room 99 leaves. Assignment status is 1100000010.
So after all, hotel room's final assignment status is 1100000010.
题意：10个房间两个门，在左右两端，从那边的门进优先安排进最近的房间，任意客人可以离开房间，n个事件从左进、从右进、客人离开房间。问最后的房间 分布情况。
思路：按照题意模拟即可。如果是哪个房间的客人离开了，利用Ascll码的到数组下标访问数组即可，反之就遍历数组找最近的。代码如下：
#include <bits/stdc++.h>
#define LL long long
using namespace std;
int n,a[10];
string s;
int main(){
cin>>n>>s;
for(int i=0;i<n;i++){
if(s[i]=='L'){for(int j=0;j<10;j++)if(!a[j]){a[j]=1;break;}}
else if(s[i]=='R'){for(int j=9;j>=0;j--)if(!a[j]){a[j]=1;break;}}
else a[s[i]-'0']=0;
}
for(int i=0;i<10;i++)printf("%d",a[i]);
return 0;
}B. Block Adventure
Gildong is playing a video game called Block Adventure. In Block Adventure, there are nn columns of blocks in a row, and the columns are numbered from 11 to nn. All blocks have equal heights. The height of the ii-th column is represented as hihi, which is the number of blocks stacked in the ii-th column.
Gildong plays the game as a character that can stand only on the top of the columns. At the beginning, the character is standing on the top of the 11-st column. The goal of the game is to move the character to the top of the nn-th column.
The character also has a bag that can hold infinitely many blocks. When the character is on the top of the ii-th column, Gildong can take one of the following three actions as many times as he wants:
- if there is at least one block on the column, remove one block from the top of the ii-th column and put it in the bag;
- if there is at least one block in the bag, take one block out of the bag and place it on the top of the ii-th column;
- if i<ni<n and |hi−hi+1|≤k|hi−hi+1|≤k, move the character to the top of the i+1i+1-st column. kk is a non-negative integer given at the beginning of the game. Note that it is only possible to move to the next column.
In actions of the first two types the character remains in the ii-th column, and the value hihi changes.
The character initially has mm blocks in the bag. Gildong wants to know if it is possible to win the game. Help Gildong find the answer to his question.
Input
Each test contains one or more test cases. The first line contains the number of test cases tt (1≤t≤10001≤t≤1000). Description of the test cases follows.
The first line of each test case contains three integers nn, mm, and kk (1≤n≤1001≤n≤100, 0≤m≤1060≤m≤106, 0≤k≤1060≤k≤106) — the number of columns in the game, the number of blocks in the character's bag at the beginning, and the non-negative integer kk described in the statement.
The second line of each test case contains nn integers. The ii-th integer is hihi (0≤hi≤1060≤hi≤106), the initial height of the ii-th column.
Output
For each test case, print "YES" if it is possible to win the game. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
input
5 3 0 1 4 3 5 3 1 2 1 4 7 4 10 0 10 20 10 20 2 5 5 0 11 1 9 9 99
output
YES NO YES NO YES
Note
In the first case, Gildong can take one block from the 11-st column, move to the 22-nd column, put the block on the 22-nd column, then move to the 33-rd column.
In the second case, Gildong has to put the block in his bag on the 11-st column to get to the 22-nd column. But it is impossible to get to the 33-rd column because |h2−h3|=3>k|h2−h3|=3>k and there is no way to decrease the gap.
In the fifth case, the character is already on the nn-th column from the start so the game is won instantly.
题意： 小G在玩一款电子游戏。游戏规则是有n列柱子（每列柱子上有若干等高积木）并排放在一起，给定小G的跨越能力k（即他只能站在柱顶，自左向右地走，且两列柱子之间的差值不能大于k）。小G有一个袋子（袋子中的积木数为m，袋子的容量是无限大的），可以进行如下操作，拿起一个积木放进袋子里，从袋子里掏出一个积木置于柱顶。如果小G能走到最后一个柱子的顶端则算他赢，否则算他输。
思路：首先来考虑a[i]>=a[i+1]的情况，此时无论k、m为多少都能走到下一列，在结合k的作用；可以推出a[i]+k>=a[i+1]时也是一定可以走到下一列的，此时应该在保证能够走到下一列的情况下尽可能地把积木装进袋子，继而可以得到一个最低通过高度（a[i+1]-k）；反过来的话，则要从袋子里拿出积木以达到最低通过高度。代码如下：
#include <bits/stdc++.h>
#define LL long long
using namespace std;
int const maxn=101;
int n,m,k;
struct node{
int data;
}q[maxn];
bool text()
{
bool qaq=false;
for(int i=0;i<n-1;i++){
if(i==n-2){
if(q[i].data+m+k>=q[i+1].data){//如果走到了最后一列返回真
qaq=true;
break;
}
}
if(q[i].data+k>=q[i+1].data){//如果q[i].data大于当前最小通过高度，就尽可能往及袋子里装积木
if(q[i+1].data>=k){
m+=q[i].data-(q[i+1].data-k);
}else{
m+=q[i].data;
}
}
else{//否则判断加上袋子里的积木能否达到当前最大高度
if(q[i].data+m+k<q[i+1].data)break;
else{
m-=q[i+1].data-k-q[i].data;
if(m<0)break;//这句不加也能过，保险起见还是留着吧
}
}
}
return qaq;
}
int main()
{
int t;
scanf("%d",&t);//测试数据组数
while(t--){
scanf("%d %d %d",&n,&m,&k);
for(int i=0;i<n;i++)scanf("%d",&q[i].data);
if(n==1){//特判下只有1列的情况
printf("YES\n");
continue;
}
if(text())printf("YES\n");
else printf("NO\n");
}
return 0;
}
