A. Jumping Ball
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
In a new version of the famous Pinball game, one of the most important parts of the game field is a sequence of n bumpers. The bumpers are numbered with integers from 1 to n from left to right. There are two types of bumpers. They are denoted by the characters '<' and '>'. When the ball hits the bumper at position i it goes one position to the right (to the position i + 1) if the type of this bumper is '>', or one position to the left (to i - 1) if the type of the bumper at position i is '<'. If there is no such position, in other words if i - 1 < 1 ori + 1 > n, the ball falls from the game field.
Depending on the ball's starting position, the ball may eventually fall from the game field or it may stay there forever. You are given a string representing the bumpers' types. Calculate the number of positions such that the ball will eventually fall from the game field if it starts at that position.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the sequence of bumpers. The second line contains the string, which consists of the characters '<' and '>'. The character at the i-th position of this string corresponds to the type of the i-th bumper.
Output
Print one integer — the number of positions in the sequence such that the ball will eventually fall from the game field if it starts at that position.
Examples
input
4
<<><
output
2
input
5
>>>>>
output
5
input
4
>><<
output
0
Note
In the first
sample, the ball will fall from the field if starts at position 1 or
position 2.
In the second
sample, any starting position will result in the ball falling from the field.
A题题意： 就是打保龄球，遇到 '<' 要是左边没了，就可以滚粗平台，右边同理。
#include <bits/stdc++.h>
using namespace std; char str[]; int main()
{
int n;
scanf("%d%s",&n,str);
int ans = ;
for(int i=;i<n;i++) {
if(str[i]=='<')
ans++;
else break;
} if(ans!=n) {
for(int i=n-;i>=;i--) {
if(str[i]=='>')
ans++;
else break;
}
}
printf("%d\n",ans); return ;
}
B. Food on the Plane
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
A new airplane SuperPuperJet has an infinite number of rows, numbered with positive integers starting with 1 from cockpit to tail. There are six seats in each row, denoted with letters from 'a' to 'f'. Seats 'a', 'b' and 'c' are located to the left of an aisle (if one looks in the direction of the cockpit), while seats 'd', 'e' and 'f' are located to the right. Seats 'a' and 'f' are located near the windows, while seats 'c' and 'd' are located near the aisle.
It's lunch time and two flight attendants have just started to serve food. They move from the first rows to the tail, always maintaining a distance of two rows from each other because of the food trolley. Thus, at the beginning the first attendant serves row 1 while the second attendant serves row 3. When both rows are done they move one row forward: the first attendant serves row 2 while the second attendant serves row 4. Then they move three rows forward and the first attendant serves row 5 while the second attendant serves row 7. Then they move one row forward again and so on.
Flight attendants work with the same speed: it takes exactly 1 second to serve one passenger and 1 second to move one row forward. Each attendant first serves the passengers on the seats to the right of the aisle and then serves passengers on the seats to the left of the aisle (if one looks in the direction of the cockpit). Moreover, they always serve passengers in order from the window to the aisle. Thus, the first passenger to receive food in each row is located in seat 'f', and the last one — in seat 'c'. Assume that all seats are occupied.
Vasya has seat s in row n and wants to know how many seconds will pass before he gets his lunch.
Input
The only line of input contains a description of Vasya's seat in the format ns, where n (1 ≤ n ≤ 1018) is the index of the row and s is the seat in this row, denoted as letter from 'a' to 'f'. The index of the row and the seat are not separated by a space.
Output
Print one integer — the number of seconds Vasya has to wait until he gets his lunch.
Examples
input
1f
output
1
input
2d
output
10
input
4a
output
11
input
5e
output
18
Note
In the first sample, the first flight attendant serves Vasya first, so Vasya gets his lunch after 1 second.
In the second sample, the flight attendants will spend 6 seconds to serve everyone in the rows 1 and 3, then they will move one row forward in 1 second. As they first serve seats located to the right of the aisle in order from window to aisle, Vasya has to wait 3 more seconds. The total is 6 + 1 + 3 = 10.
B题题意：
有两个空姐，一个从第1行开始照顾1，2两行；另一个从第二行开始照顾3，4两行，对每个乘客，给他东西需要1个单位时间，换一行需要一个单位时间；然后两个空姐同时处理，对每一行都是fed,abc，然后换行，两个空姐同时处理完两行以后，跳两行继续处理；求这个人要多长时间才能得到食物。
unsigned long long 型。
#include <bits/stdc++.h>
using namespace std; char str[] = {'f','e','d','a','b','c'}; int main()
{
unsigned long long N;
char c;
scanf("%I64d%c",&N,&c); unsigned long long ans = ;
unsigned long long counts = N / ;
int n = N % ;
if(n==)
ans += (counts-)*;
else ans+=counts*; if(n==)
{
ans+=;
}
else if(n==)
{
ans +=;
} for(int i=; i<; i++)
{
if(c==str[i])
{
ans += i+;
break;
}
}
printf("%I64d\n",ans); return ;
}
C. Hidden Word
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output
Let’s define a grid to be a set of tiles with 2 rows and 13 columns. Each tile has an English letter written in it. The letters don't have to be unique: there might be two or more tiles with the same letter written on them. Here is an example of a grid:
ABCDEFGHIJKLM
NOPQRSTUVWXYZ
We say that two
tiles are adjacent if they share a side or a corner. In the example grid above,
the tile with the letter 'A' is adjacent only to the tiles with letters 'B', 'N', and 'O'. A tile is not adjacent to itself.
A sequence of
tiles is called a path if each tile in the sequence is adjacent to the tile
which follows it (except for the last tile in the sequence, which of course has
no successor). In this example, "ABC" is a path, and so is "KXWIHIJK". "MAB" is not a path because 'M' is not adjacent to 'A'. A single tile can be used more than
once by a path (though the tile cannot occupy two consecutive places in the
path because no tile is adjacent to itself).
You’re given a
string s which consists of 27 upper-case English letters. Each
English letter occurs at least once in s. Find a grid
that contains a path whose tiles, viewed in the order that the path visits
them, form the string s. If there’s no solution, print "Impossible" (without the quotes).
Input
The only line of
the input contains the string s, consisting of 27 upper-case
English letters. Each English letter occurs at least once in s.
Output
Output two
lines, each consisting of 13 upper-case English characters, representing the
rows of the grid. If there are multiple solutions, print any of them. If there
is no solution print "Impossible".
Examples
input
ABCDEFGHIJKLMNOPQRSGTUVWXYZ
output
YXWVUTGHIJKLM
ZABCDEFSRQPON
input
BUVTYZFQSNRIWOXXGJLKACPEMDH
output
Impossible
C题题意：
题意：给你一个27大写字母的字符串，每个字母至少出现一次。要你能否构造一个2*13的图，保证给出的字符串是条通路，图通路的定义是：相邻或对角的两个能相通。
思路想复杂了，就很难写了，参考了一下大神的神技。
#include<bits/stdc++.h>
using namespace std; char s[];
int main()
{
scanf("%s",s);
int x,y;
x=y=; for(int i=; i<; i++)
{
for(int j=i+; j<; j++)
{
if (s[i]==s[j])
{
x=i;
y=j;
}
}
} if (x+==y)
{
puts("Impossible");
return ;
} x+=;
y+=;
int p=(x+y+)/;
for(int i=; i<=; i++)
if (i+p!=y) putchar(s[(i+p)%]);
puts("");
for(int i=; i<=; i++)
putchar(s[(p-i+)%]);
puts("");
return ;
}