Unnamed: 0 int64 0 3.55k | id stringlengths 1 13 | title stringlengths 2 50 | difficulty stringclasses 6 values | category stringclasses 15 values | text stringlengths 226 7.79k |
|---|---|---|---|---|---|
1,200 | 2205 | Asteroid Rangers | Médio | AD-HOC | The year is 2112 and humankind has conquered the solar system. The Space Ranger Corps have set up bases on any hunk of rock that is even remotely inhabitable. Your job as a member of the Asteroid Communications Ministry is to make sure that all of the Space Ranger asteroid bases can communicate with one another as cheaply as possible. You could set up direct communication links from each base to every other base, but that would be prohibitively expensive. Instead, you want to set up the minimum number of links so that everyone can send messages to everyone else, potentially relayed by one or more bases. The cost of any link is directly proportional to the distance between the two bases it connects, so this doesn’t seem that hard of a problem.
There is one small difficulty, however. Asteroids have a tendency to move about, so two bases that are currently very close may not be so in the future. Therefore as time goes on, you must be willing to switch your communication links so that you always have the cheapest relay system in place. Switching these links takes time and money, so you are interested in knowing how many times you will have to perform such a switch.
A few assumptions make your task easier. Each asteroid is considered a single point. Asteroids always move linearly with a fixed velocity. No asteroids ever collide with other asteroids. Also, any relay system that becomes optimal at a time t ≥ 0 will be uniquely optimal for any time s satisfying t < s < t+10−6 . The initial optimal relay system will be unique.
Entrada
Each test case starts with a line containing an integer n (2 ≤ n ≤ 50) indicating the number of asteroid bases. Following this are n lines, each containing six integers x, y, z, vx, vy, vz. The first three specify the initial location of an asteroid (−150 ≤ x, y, z ≤ 150), and the last three specify the x, y, and z components of that asteroid’s velocity in space units per time unit (−100 ≤ vx, vy, vz ≤ 100).
Saída
For each test case, display a single line containing the case number and the number of times that the relay system needs to be set up or modified.
Exemplo de Entrada Exemplo de Saída
3
0 0 0 0 0 0
5 0 0 0 0 0
10 1 0 -1 0 0
4
0 0 0 1 0 0
0 1 0 0 -1 0
1 1 1 3 1 1
-1 -1 2 1 -1 -1
Case 1: 3
Case 2: 3
ICPC 2012 World Finals |
1,201 | 2207 | Bus Tour | Médio | AD-HOC | Imagine you are a tourist in Warsaw and have booked a bus tour to see some amazing attraction just outside of town. The bus first drives around town for a while (a long while, since Warsaw is a big city) picking up people at their respective hotels. It then proceeds to the amazing attraction, and after a few hours goes back into the city, again driving to each hotel, this time to drop people off.
For some reason, whenever you do this, your hotel is always the first to be visited for pickup, and the last to be visited for dropoff, meaning that you have to suffer through two not-so-amazing sightseeing tours of all the local hotels. This is clearly not what you want to do (unless for some reason you are really into hotels), so let’s fix it. We will develop some software to enable the sightseeing company to route its bus tours more fairly—though it may sometimes mean longer total distance for everyone, but fair is fair, right?
For this problem, there is a starting location (the sightseeing company headquarters), h hotels that need to be visited for pickups and dropoffs, and a destination location (the amazing attraction). We need to find a route that goes from the headquarters, through all the hotels, to the attraction, then back through all the hotels again (possibly in a different order), and finally back to the headquarters. In order to guarantee that none of the tourists (and, in particular, you) are forced to suffer through two full tours of the hotels, we require that every hotel that is visited among the first [h/2] hotels on the way to the attraction is also visited among the first [h/2] hotels on the way back. Subject to these restrictions, we would like to make the complete bus tour as short as possible. Note that these restrictions may force the bus to drive past a hotel without stopping there (this is not considered visiting) and then visit it later, as illustrated in the first sample input.
Entrada
The first line of each test case consists of two integers n and m satisfying 3 ≤ n ≤ 20 and 2 ≤ m, where n is the number of locations (hotels, headquarters, attraction) and m is the number of pairs of locations between which the bus can travel.
The n different locations are numbered from 0 to n−1, where 0 is the headquarters, 1 through n−2 are the hotels, and n − 1 is the attraction. Assume that there is at most one direct connection between any pair of locations and it is possible to travel from any location to any other location (but not necessarily directly).
Following the first line are m lines, each containing three integers u, v, and t such that 0 ≤ u, v ≤ n−1, u != v, 1 ≤ t ≤ 3600, indicating that the bus can go directly between locations u and v in t seconds (in either direction).
Saída
For each test case, display the case number and the time in seconds of the shortest possible tour.
Exemplo de Entrada Exemplo de Saída
5 4
0 1 10
1 2 20
2 3 30
3 4 40
4 6
0 1 1
0 2 1
0 3 1
1 2 1
1 3 1
2 3 1
Case 1: 300
Case 2: 6
ICPC 2012 World Finals |
1,202 | 2208 | Fibonacci Words | Difícil | AD-HOC | The Fibonacci word sequence of bit strings is defined as:
$$F(n) =\begin{cases} & \text 0 \\ & \text 1 \\ & \text F(n-1)+F(n-2)\\ \end{cases} \begin{matrix} \mathbf{if} n = 0 \\ \mathbf{if} n = 1\\ \mathbf{if} n \geqslant 2 \end{matrix}$$
Here + denotes concatenation of strings. The first few elements are:
Given a bit pattern p and a number n, how often does p occur in F(n)?
Entrada
The first line of each test case contains the integer n (0 ≤ n ≤ 100). The second line contains the bit pattern p. The pattern p is nonempty and has a length of at most 100 000 characters.
Saída
For each test case, display its case number followed by the number of occurrences of the bit pattern p in F(n). Occurrences may overlap. The number of occurrences will be less than 263 .
Exemplo de Entrada Exemplo de Saída
6
10
7
10
6
01
6
101
96
10110101101101
Case 1: 5
Case 2: 8
Case 3: 4
Case 4: 4
Case 5: 7540113804746346428
ICPC 2012 World Finals |
1,203 | 2209 | Infiltration | Médio | AD-HOC | Good morning, agent W-12. Your mission, should you choose to accept it, is as follows.
We are infiltrating the ever so insidious Association of Chaos and Mischief (ACM) in order to take down their command structure. Unfortunately, they appear to be prepared for such an eventuality, and have given their command structure an annoyingly complex design which makes our infiltration quite difficult.
The ACM command structure is divided into several cells. For each pair of cells A and B, either A controls B or B controls A. But this “control” relation can be cyclic, so it could happen that A controls B and B controls C and C controls A.
We can send in agents to infiltrate any particular cell, which gives us control over that cell and the cells that it controls, but not any other cells. So in the example above, infiltrating A would give us control over A and B, but not C.
For a successful infiltration of the ACM, we must obtain control over all of its cells, otherwise the cells that are out of our control will discover us and start causing some of their trademark chaos and mischief. As you know, we’re on a tight spending leash from higher authority these days, so we need to execute this mission as efficiently as possible. Your mission is to figure out the minimum number of cells we need to infiltrate in order to succeed.
This mission briefing will self-destruct in five hours. Good luck!
Entrada
The first line of a test case contains the number n of cells the ACM has (1 ≤ n ≤ 75). Each of the next n lines contains a binary string of length n where the ith character of the jth line is 1 if cell j controls cell i, and 0 otherwise (1 ≤ i, j ≤ n).
The ith character of the ith line is 0 and for i != j, either the ith character of the jth line is 1 or the jth character of the ith line is 1, but not both.
Saída
For each test case, display its case number followed by the minimum number m of cells that must be infiltrated to obtain complete control of the ACM. Then display m numbers c1, . . . , cm in any order, indicating the list of cells to infiltrate (cells are numbered from 1 to n). If more than one set of m cells gives complete control, any one will be accepted.
Exemplo de Entrada Exemplo de Saída
2
00
10
3
010
001
100
5
01000
00011
11001
10100
10010
Case 1: 1 2
Case 2: 2 1 2
Case 3: 2 2 3
ICPC 2012 World Finals |
1,204 | 2210 | Keys | Médio | AD-HOC | Adam carries a bunch of keys attached to key rings, some of which may be connected to each other. The rings are common key rings, so a key can be attached to or detached from a ring by sliding along the spiral. In the same way, two rings can be connected or disconnected. Adam wants to give some of the keys to Brenda. Since manipulating the keys and rings is often an annoying task (and also dangerous to one’s fingernails), Adam is looking for a way to minimize the number of key and ring operations.
Every key attachment, key detachment, ring connection, or ring disconnection is considered one operation. Since manipulating two rings is significantly easier than sliding a key, we first want to minimize the number of keys being detached and attached. Among solutions with the same minimal number of key operations, you need to find the one with the minimal number of ring connections and disconnections.
When all the operations are complete, Adam and Brenda must each carry one connected group of rings and keys. The only exception is when either of them would have no keys at all—in such a case, no ring is needed. Each key must be attached to exactly one ring. Some rings (but not keys) may be considered leftovers and may remain disconnected from the two groups.
The left side of the following figure shows an initial configuration consisting of four keys on three rings. Adam wishes to give Brenda the two keys labeled N and R. This can be accomplished by two key operations and one ring operation, resulting in the configuration shown on the right side of the figure.
Entrada
Each test case contains one or more lines, each containing a two letter string. Lowercase letters (a - z) represent key rings and uppercase letters (A - Z) represent keys. The two letters on a line specify either a key attached to a ring or two rings connected together. The end of each test case is denoted by a line containing the digit zero.
Keys denoted by letters A through M remain with Adam, and keys denoted by letters N through Z are given to Brenda.
No line contains two uppercase letters. No pair of letters are specified more than once in the same test case. Each key is connected to exactly one ring. There are no “circles” in the ring configurations (disconnecting any two rings will increase the number of connected groups). All existing keys and rings are mentioned at least once.
Saída
For each test case, display the case number followed by the minimal number of key attach/detach operations and the minimal number of ring connect/disconnect operations.
If there is no way to split the keys as requested, display the case number and the word 'impossible' instead of the two integers.
Exemplo de Entrada Exemplo de Saída
ab
bc
aA
aN
Rb
cB
0
aA
bB
Cc
0
aA
aZ
0
aA
bB
cC
xX
yY
ax
xb
by
yc
0
Case 1: 2 1
Case 2: 0 2
Case 3: impossible
Case 4: 0 7
ICPC 2012 World Finals |
1,205 | 2211 | Minimum Cost Flow | Médio | AD-HOC | You have been hired to construct a system to transport water between two points in an old factory building using some existing components of the old plumbing. The old components consist of pipes and junctions. Junctions are points where pipes may have previously been joined. We say previously joined, because some of the old pipes were damaged and have been removed, effectively leaving open holes in the junctions to which they were connected. If water should enter one of these junctions, it would pour out of an open hole and eventually flood the building—clearly an undesirable event.
You can remedy this situation by installing new pipes between some of the open holes and installing plugs to close other open holes as necessary. When you install a new pipe connecting two holes (which must be in two different junctions), the two holes are no longer open and water will be able to flow through the new pipe. The cost of installing a new pipe is equal to the distance between the centers of the two junctions the pipe connects. The cost of installing a plug in an open hole is 0.5. You are not concerned about open holes in junctions that will never be reached by water.
Two of the junctions are special. One, called the source, is the point where water will be pumped into the new system. The other, called the destination, is where the water is needed. After any plugs and new pipes have been added to the system, water will be pumped into it at the source with a pressure sufficient to reach a specified height (in the absence of leaks, of course). You are allowed to select the pressure arbitrarily, and are guaranteed that the pressure will not change during the operation of the system. Naturally the pressure must be sufficient to force water up to the heights of both the source and the destination. Your task is simply to find the most inexpensive way of getting water from the source junction to the destination junction without flooding the building.
The figure below corresponds to the first sample input case, where black dots represent open holes, junction 1 is the source, and junction 7 is the destination. (The position of a black dot on its circle has no significance and is used for illustration purposes only.)
Water flows through the system according to the laws of physics. If the pressure is sufficient to fill a junction with water, then that junction will remain filled with water. If there are pipes extending horizontally or downward from a junction, then water will also flow through those pipes. Water will also flow upward through pipes connected to a junction up to the height determined by the water pressure. Of course, if the water reaches an open hole in a junction, it will flow through the hole and flood the building.
In the first sample input case, you can connect junctions 1 and 5 at a cost of 3, plug the open holes in junction 2, and set the pressure so that the water flows up to junction 7 only. The water will fill junctions 1, 2, 5, 6 and 7, and will flow no higher. A different (more expensive) solution would be to simply plug all the holes at a total cost of 5, and let the water flow through all the junctions. You cannot solve this case by connecting junctions 1 and 6 and plugging holes in junctions 2 and 5, since junction 6 has no open holes to which a new pipe can be connected.
Assume existing pipes and any new pipes do not interfere with each other or with any junctions, except those to which they are connected. That is, even if a straight line from junction A to junction B passes through junction C, any pipe from A to B will not touch C.
Entrada
The first line of each test case contains two integers N and M, where N (2 ≤ N ≤ 400) is the number of junctions in the building (numbered 1 through N) and M (0 ≤ M ≤ 50 000) is the number of existing usable pipes. Each of the next N lines contains four integers xi , yi , zi , and ki satisfying −10 000 ≤ xi , yi , zi ≤ 10 000 and 0 ≤ ki ≤ 400, i = 1, 2, ..., N. The ith line describes junction i: (xi , yi , zi) is the location of the ith junction where the z-axis is the vertical axis; ki indicates the number of open holes in the junction. Each of the next M lines contains two integers aj and bj satisfying 1 ≤ aj < bj ≤ N. The jth line indicates that pipe j connects junctions aj and bj . At most one pipe connects any pair of junctions, and no two junctions share the same coordinates. The source is junction 1, and the destination is junction N.
Saída
For each case, display the case number. Then if suitable new pipes and plugs can be used to construct the desired system, display the minimum cost of connecting the source junction to the destination junction, accurate to four decimal places. If it is impossible to connect the source to the destination, display the word 'impossible'.
Exemplo de Entrada Exemplo de Saída
7 6
2 0 1 1
0 0 0 2
1 0 4 3
3 0 4 3
5 0 1 1
3 0 2 0
5 0 3 0
1 2
1 3
3 4
4 7
5 7
6 7
4 1
2 0 0 0
3 0 1 0
4 1 0 1
5 1 1 1
1 2
Case 1: 4.0000
Case 2: impossible
ICPC 2012 World Finals |
1,206 | 2212 | Room Service | Médio | AD-HOC | You are working for a company designing cute, funny robot vacuum cleaners. At a high level, the robots’ behavior is divided into three modes:
Exploration
Vacuuming
Rampant Killing
Unfortunately, while consumer testing shows that the last two modes are working perfectly, the exploration mode still has bugs. You’ve been put in charge of debugging.
At the beginning of the exploration mode, the robot is placed into a convex polygonal room. It has sensors that should tell it where all the walls are. Your job is to write a program that verifies that these readings are correct. To do this, the robot needs to physically touch every wall in the room.
Your problem is this: given the shape of a convex polygonal room with N walls and a starting point P inside it, determine the shortest route that touches each wall and then returns to P. Touching a corner counts as touching both incident walls.
Entrada
Each test case starts with a line containing the number of vertices N of the polygon (3 ≤ N ≤ 100) and the integer coordinates Px and Py of the robot’s starting point (−10 000 ≤ Px, Py ≤ 10 000). This is followed by N lines, each containing two integers x, y (−10 000 ≤ x, y ≤ 10 000) defining a vertex of the polygon. Vertices are given in counterclockwise order, all interior angles are less than 180 degrees, the polygon does not self-intersect, and the robot’s starting point is strictly inside the polygon
Saída
For each test case, display the case number and the length of the desired route, accurate to two decimal places.
Exemplo de Entrada Exemplo de Saída
4 0 0
-1 -1
1 -1
1 1
-1 1
3 10 1
0 0
30 0
0 20
Case 1: 5.66
Case 2: 36.73
ICPC 2012 World Finals |
1,207 | 2213 | A Safe Bet | Médio | AD-HOC | Safe Ltd. is a company that manufactures high-quality safes. Its latest invention is an optical closure mechanism that uses a laser beam passing through a rectangular grid with several mirrors.
When the laser is activated, a beam enters the top row of the grid horizontally from the left. The beam is reflected by every mirror that it hits. Each mirror has a 45 degree diagonal orientation, either / or \ . If the beam exits the bottom row of the grid horizontally to the right, it is detected and the safe opens (see the left side of the figure above). Otherwise the safe remains closed and an alarm is raised.
Each safe has a missing mirror, which prevents the laser beam from traveling successfully through the grid (see the right side of the figure above). The safe has a mechanism that enables the user to drop a single mirror into any empty grid cell. A legitimate user knows the correct position and orientation of the missing mirror ( / in row 4 column 3 above) and can thus open the safe. Without this knowledge the user has to guess correctly, which can be difficult for safes with large grids.
Your job is to determine if particular safes are actually secure. A secure safe does not open right away without inserting a mirror, and there is at least one valid location and orientation for the missing mirror. There may indeed be multiple such locations and orientations.
Entrada
Each test case describes a single safe and starts with a line containing four integer numbers r, c, m, and n (1 ≤ r, c ≤ 1 000 000 and 0 ≤ m, n ≤ 200 000). The mechanism’s grid has r rows and c columns. Each of the next m lines contains two integer numbers ri and ci (1 ≤ ri ≤ r and 1 ≤ ci ≤ c) specifying that there is a / mirror in row ri column ci . The following n lines specify the positions of the \ mirrors in the same way. The m + n positions of the mirrors are pairwise distinct.
Saída
For each test case, display its case number followed by:
0 if the safe opens without inserting a mirror.
k r c if the safe does not open without inserting a mirror, there are exactly k positions where inserting a mirror opens the safe, and (r, c) is the lexicographically smallest such row, column position. A position where both a / and a \ mirror open the safe counts just once.
'impossible' if the safe cannot be opened with or without inserting a mirror.
Exemplo de Entrada Exemplo de Saída
5 6 1 4
2 3
1 2
2 5
4 2
5 5
100 100 0 2
1 77
100 77
100 100 0 0
Case 1: 2 4 3
Case 2: 0
Case 3: impossible
ICPC 2012 World Finals |
1,208 | 2214 | Shortest Flight Path | Médio | AD-HOC | Commercial flights are statistically quite safe (in terms of number of deaths per passenger-kilometer, only going to the moon is safer). But there are still reasons for precautions and safety regulations. An early such rule was the so-called “60-minute rule,” which required that a two-engine plane must always be within 60 minutes of the nearest adequate airport along its entire flight path. A variety of similar rules have existed, but at their core, they remain the same: the flight path can not take the airplane more than a certain maximum allowed distance from the nearest airport. With these restrictions, planes cannot always use a direct route for flying from one airport to another.
In this problem we will compute the shortest flight path between two airports while adhering to a maximum allowed distance rule. In the figure below, which illustrates the first sample test case, any flight route has to stay within the three circles. Thus a plane going from airport 2 to airport 3 has to detour from the direct route via the region around airport 1. Note that the plane would not necessarily have to go to airport 1 itself.
Things are further complicated by the fact that planes have limited fuel supply, and to go longer distances they may need to make a stopover at intermediate airports. Thus, depending on the fuel capacity, a plane going from airport 2 to airport 3 in the figure might have to stop over at airport 1 (or the fuel capacity might be too low even to go to airport 1, in which case the trip would be impossible to make).
We make the following simplifying assumptions:
The surface of the earth is a sphere of radius 6370 km.
Both time and fuel consumption are directly proportional to distance traveled. In other words we are interested only in total distance traveled.
The difference in distance caused by planes flying at different altitudes is negligible. Thus, effectively, we assume them to be flying along the earth’s surface.
A plane may stop for refueling at as many intermediate airports as needed, each time getting a full tank.
Entrada
The first line of each test case contains two integers N and R, where 2 ≤ N ≤ 25 is the number of airports and 1 ≤ R ≤ 10 000 is the maximum allowed flight distance (in km) from the nearest airport. Each of the next N lines contains two integers φ, θ satisfying 0 ≤ φ < 360 and −90 ≤ θ ≤ 90, the longitude and latitude (respectively) of an airport, in degrees. The airports are numbered according to their order in the input starting from one. No two airports are at the same position.
Following this is a line containing an integer Q, satisfying 1 ≤ Q ≤ 100. Each of the next Q lines contains three integers s, t, c satisfying 1 ≤ s, t ≤ N, s != t, and 1 ≤ c ≤ 50 000, indicating a plane going from airport s to airport t with a fuel capacity yielding a range of c km.
Saída
For each test case, display the case number followed by one line for each query containing the length in km of the shortest flight path between airport s and t, subject to the fuel constraint c. Display the length accurate to three decimal places. If there is no permissible path between the two airports, then display the word impossible instead.
You may assume the answer is numerically stable for perturbations of up to 0.1 km of R or c.
Exemplo de Entrada Exemplo de Saída
3 2000
0 0
0 30
30 0
3
2 3 5000
2 3 4000
2 3 3000
2 10000
45 45
225 -45
2
1 2 50000
2 1 50000
Case 1:
4724.686
6670.648
impossible
Case 2:
impossible
impossible
ICPC 2012 World Finals |
1,209 | 2215 | Stacking Plates | Médio | AD-HOC | The Plate Shipping Company is an Internet retailer that, as their name suggests, exclusively sells plates. They pride themselves in offering the widest selection of dinner plates in the universe from a large number of manufacturers.
In a recent cost analysis the company has discovered that they spend a large amount of money on packing the plates for shipment. Part of the reason is that plates have to be stacked before being put into shipping containers. And apparently, this is taking more time than expected. Maybe you can help.
A shipment of plates consists of plates from several manufacturers. The plates from each manufacturer come stacked, that is, each arranged in a single stack with plates ordered by size (the smallest at the top, the largest at the bottom). We will call such a stack properly ordered. To ship all these plates, you must combine them into a single stack, again properly ordered. To join the manufacturers’ stacks into a single stack, two kinds of operations are allowed:
Split: a single stack can be split into two stacks by lifting any top portion of the stack and putting it aside to form a new stack.
Join: two stacks can be joined by putting one on top of the other. This is allowed only if the bottom plate of the top stack is no larger than the top plate of the bottom stack, that is, the joined stack has to be properly ordered.
Note that a portion of any stack may never be put directly on top of another stack. It must first be split and then the split portion must be joined with the other stack. Given a collection of stacks, you have to find the minimum number of operations that transforms them into a single stack. The following example corresponds to the sample input, and shows how two stacks can be transformed to a single stack in five operations:
Entrada
Each test case starts with a line containing a single integer n (1 ≤ n ≤ 50), the number of stacks that have to be combined for a shipment. This is followed by n lines, each describing a stack. These lines start with an integer h (1 ≤ h ≤ 50), the height of the stack. This number is followed by h positive integers that give the diameters of the plates, from top to bottom. All diameters are at most 10 000. These numbers will be in non-decreasing order.
Saída
For each test case, display the case number and the minimum number of operations (splits and joins) that have to be performed to combine the given stacks into a single stack.
Exemplo de Entrada Exemplo de Saída
2
3 1 2 4
2 3 5
3
4 1 1 1 1
4 1 1 1 1
4 1 1 1 1
Case 1: 5
Case 2: 2
ICPC 2012 World Finals |
1,210 | 2216 | Takeover Wars | Médio | AD-HOC | You are studying a takeover war between two large corporations, Takeover Incorporated and Buyout Limited. Each of these corporations controls a number of subsidiaries. The aim in this war is simply to drive the competition out of the market. There are N subsidiaries of Takeover Incorporated and M subsidiaries of Buyout Limited, and you know the market value of each subsidiary.
Each company can designate one of its subsidiaries to perform a takeover. The takeover can either be friendly or hostile. A friendly takeover means a subsidiary of a corporation merges with a different subsidiary of the same corporation. The market value of the merged subsidiary is the sum of the market values of the constituent subsidiaries. There is no constraint on the relative sizes of the subsidiaries participating in a friendly takeover.
A hostile takeover means a subsidiary A of a corporation attempts to take over a subsidiary B of the other corporation. For this to succeed, the market value of A has to be greater than the market value of B. After this move, B disappears from the market. The market value of A does not change (the gain of incorporating B’s assets is offset by the monetary cost of the takeover). For simplicity we assume that no sequence of moves leads to two subsidiaries of different corporations having the same market value.
The companies take turns making moves in this takeover war, with Takeover Incorporated going first. A company will do nothing on its turn only if it cannot make a takeover. A company loses the takeover war if all its subsidiaries are taken over.
Your aim is to learn which company can guarantee a victory from this war. In the first case of the sample data, Takeover Incorporated can simply take over one of the companies of Buyout Limited in its first move with the 7-value subsidiary. Then it will lose one of its small (1-value) subsidiaries to a hostile takeover, and then it will take over the second subsidiary of Buyout Limited. In the second case, Takeover has to make a friendly takeover in its first move. Buyout Limited will join its two subsidiaries into a single company with market value 10. Takeover will have to make a friendly takeover again (as again it will not have a large enough subsidiary to take over Buyout’s giant). Now Takeover will have two subsidiaries, valued either 9 and 3 or 6 and 6. In either case, Buyout takes over one of these subsidiaries, Takeover has to pass, and Buyout takes over the other one.
Entrada
Each test case is described by three lines of input. The first line contains two numbers 1 ≤ N ≤ 105 and 1 ≤ M ≤ 105 denoting respectively the number of subsidiaries of Takeover Incorporated and Buyout Limited. The next line lists the N sizes ai of the subsidiaries of Takeover Incorporated (1 ≤ ai ≤ 1012), and the third line lists the M sizes bj of the subsidiaries of Buyout Limited (1 ≤ bj ≤ 1012).
Saída
For each test case, display the case number and either the phrase 'Takeover Incorporated' or the phrase 'Buyout Limited' depending on who wins the takeover war if both corporations act optimally.
Exemplo de Entrada Exemplo de Saída
3 2
7 1 1
5 5
4 2
3 3 3 3
5 5
Case 1: Takeover Incorporated
Case 2: Buyout Limited
ICPC 2012 World Finals |
1,211 | 2217 | Nove | Fácil | AD-HOC | Paulo Bruno é um menino que adora Pokemons, porém odeia matemática, ele detesta exponenciação e por algum motivo não calcula corretamente operações que envolvam o número 9. Sabendo disso, seu amigo Werlesson decidiu fazer um desafio, ele quer que Paulo Bruno calcule a N-ésima potência de 9 e diga o último dígito dessa potência. Por exemplo, sendo N=2, o resultado seria 1, pois 92=81. O problema é que, dependendo do valor de N, o resultado da exponenciação pode ser um número muito grande. Sem ideias, Paulo Bruno decidiu pedir sua ajuda.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância é composta por apenas uma linha, que contêm o número inteiro N(0 ≤ N ≤ 109).
Saída
Para cada instância na entrada, imprima uma linha contendo um inteiro, o último dígito de 9N.
Exemplo de Entrada Exemplo de Saída
2
1
2
9
1
II Maratona de programação do IFCE-Aracati |
1,212 | 2218 | O Temível Evil-Son | Muito Fácil | MATEMÁTICA | Em um lugar muito distante existe um reino pacífico chamado Lá-Ara. Seu governante, o rei Naldo, mestre pokemon experiente, está em apuros. Um raro pokemon matemático chamado Evil-Son invadiu o seu território e ameaçou destruir todo o reino caso ninguém resolvesse o desafio descrito a seguir.
Um conjunto de retas no plano está em posição geral se não existe duas retas paralelas e também não existe três retas que se interceptam em um mesmo ponto. A seguir, temos na figura (A) um conjunto de retas em posição geral, já o conjunto de retas na figura (B) não está em posição geral.
O desafio consiste em computar o número de regiões no plano formadas por um conjunto de N retas em posição geral. O rei Naldo conta com a sua habilidade, em matemática e programação, para salvar o reino de Lá-Ara do temível Evil-Son.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância é composta de uma única linha que contém o número N representando o número de retas no conjunto.
Saída
Para cada instância na entrada, imprima uma única linha contendo o número de regiões formadas no plano pelas retas do conjunto.
Exemplo de Entrada Exemplo de Saída
3
1
3
7
2
7
29
II Maratona de programação do IFCE-Aracati |
1,213 | 2219 | Passando Pelos PokeStops | Difícil | AD-HOC | Rhayane adora cálculo, e claro, também adora pokémons. Ela acredita que seus conhecimentos matemáticos ajudarão na sua jornada de treinadora pokémon. Num momento ela se encontra num longo caminho em linha reta com vários PokeStops no caminho, Rhayane deseja saber qual a maior distância que ela irá andar sem achar nenhum PokeStop e pediu sua ajuda para essa tarefa.
Dado o comprimento do caminho em metros e dadas as distâncias, também em metros, dos PokeStops até a posição inicial que Rhayane está (onde ela está não tem nenhum PokeStop) faça um programa que determine tal distância. Por exemplo, se as distâncias são: {2, 4, 5, 1} e o caminho tem 7 metros, então a maior distância que ela andará sem encontrar nenhum PokeStop é 2 metros (entre 2 e 4, ou 5 e 7).
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T (1 ≤ T ≤ 20) indicando o número de instâncias.
Para cada instância do problema será dada uma linha composta de dois inteiros n e m (1 ≤ n, m ≤ 105) que representam respectivamente o comprimento do caminho e o número de PokeStops no caminho.
Depois haverá uma linha onde serão dados m inteiros representando distâncias de vários PokeStops à posição inicial de Rhayane. A distância de um PokeStop à posição inicial de Rhayane é sempre menor ou igual que 106.
Saída
Para cada instância um único inteiro que é a máxima distância que Rhayane irá percorrer sem encontrar um PokeStop. Deve haver apenas uma quebra de linha entre a saída de cada instância.
Exemplos de Entrada Exemplos de Saída
3
10 3
1 5 8
10 3
1 4 2
5 2
3 4
4
6
3
II Maratona de programação do IFCE-Aracati |
1,214 | 2220 | Ajudando Gust-Avô | Difícil | PARADIGMAS | K-rina é uma jovem mestre pokemon que gosta de ajudar pokemons anciãos. Em uma de suas últimas caçadas, ela capiturou um velho, dislexo e gago pokemon escritor, chamado Gust-Avô. Por causa de sua gagueira e dislexia, Gust-Avô quando escreve uma palavra, as vezes repete letras e/ou adiciona caracteres não pertencentes a palavra que deseja escrever. K-rina quer ajudá-lo interpretando seus textos. Para isso precisa resolver o problema descrito abaixo.
Dados, A e B duas sequências de letras, nós dizemos que B é uma subsequência de A se nós podemos encontrar todas as letras de B em A, na mesma ordem em que elas aparecem em B, não necessariamente adjacentes. Por exemplo, abc é subsequência de xaywbzc, enquanto xyz não é subsequência de xabzcy.
Dado uma sequência B, nós definimos Bi como sendo uma sequência onde cada caractere de B aparece i vezes. Por exemplo, se B=xyzzx, então B3=xxxyyyzzzzzzxxx.
Para ajudar K-rina e Gust-Avô, sua tarefa é, dado duas sequências A e B, encontrar o maior valor i, tal que Bi é uma subsequência de A.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância é composta de duas linhas. A primeira linha de cada instância contêm uma sequência de letras que representa A (|A| ≤ 105) e a segunda linha ontêm uma sequência de letras que representa B (|B| ≤ 104).
Saída
Para cada instância na entrada, imprima uma única linha contendo o maior valor inteiro i, tal que Bi é subsequência de A. Caso B não seja subsequencia de A, imprima 0 (zero).
Exemplo de Entrada Exemplo de Saída
4
qwer
qr
qweqwewseerfgr
qr
aaaaaaaaa
a
qwer
asdf
1
2
9
0
II Maratona de programação do IFCE-Aracati |
1,215 | 2221 | Batalha de Pomekons | Muito Fácil | INICIANTE | Depois de capturar muitos Pomekons, Dabriel e Guarte resolveram batalhar. A forma de duelo é simples, cada treinador coloca um Pomekon na batalha e vence quem tem o Pomekon com maior valor de golpe, que é definido da seguinte maneira:
O Bônus será dado ao Pomekon do treinador que estiver em um level de valor par.
Neste problema será dado a você o valor do bônus aplicado, os valores de ataque e defesa do Pomekon de Dabriel e Guarte e seus respectivos níveis, cabe a você informar o ganhador da batalha.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância começa com um inteiro B (0 ≤ B ≤ 100), que indica o valor do bônus aplicado. Nas duas linhas seguintes terão três inteiros Ai, Di e Li (1 ≤ Ai, Di ≤ 100, 1 ≤ Li ≤ 50), representado o valor de ataque do Pomekon, o valor de defesa e o level do treinador. A primeira linha representa o Pomekon de Dabriel e a segunda o de Guarte.
Saída
Para instância na entrada você deverá imprimir o nome do treinador que irá vencer a batalha, em caso de empate imprima: "Empate", sem aspas.
Exemplo de Entrada Exemplo de Saída
3
5
12 23 15
42 12 20
2
52 1 11
1 52 1
3
95 12 22
5 51 21
Guarte
Empate
Dabriel
II Maratona de programação do IFCE-Aracati |
1,216 | 2222 | Brincando com Conjuntos | Difícil | MATEMÁTICA | Dabriel é um menino fissurado por matemática, ele acaba de aprender em sua escola operações sobre conjuntos.
Após passar a tarde toda brincando com alguns conjuntos que ele possui, chega a hora de resolver as lições de casa, porém ele já está muito cansado e com medo de que possa cometer alguns erros, solicitou sua ajuda.
Dabriel deseja um programa de computador que dado N conjuntos e os elementos de cada conjunto, ele possa realizar algumas operações, são elas:
1 X Y: Retorna a quantidade de elementos distintos da intersecção entre o conjunto X com o Y.
2 X Y: Retorna a quantidade de elementos distintos da união entre o conjunto X com o Y.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância inicia com um inteiro N (1 ≤ N ≤ 10⁴), representando a quantidade de conjuntos que Dabriel possui. As próximas N linhas começam com um inteiro Mi (1 ≤ Mi ≤ 60), que indica o total de elementos que o conjunto i possui, segue então Mi inteiros Xij (1 ≤ Xij ≤ 60), que representam o valor de cada elemento. Na próxima linha contém um inteiro Q (1 ≤ Q ≤ 10⁶), representando quantas operações Dabriel deseja realizar. Nas próximas Q linhas terá a descrição de uma operação.
Saída
Para cada operação seu programa deverá imprimir a quantidade de elementos, conforme explicado na descrição.
Exemplo de Entrada Exemplo de Saída
1
4
1 1
2 1 5
3 2 4 6
4 1 3 5 7
5
1 1 2
1 1 4
2 1 4
2 3 4
1 2 4
1
1
4
7
2
II Maratona de programação do IFCE-Aracati |
1,217 | 2223 | Inventário de Pomekon | Muito Difícil | ESTRUTURAS E BIBLIOTECAS | Depois de capturar diversos Pomekons, Dabriel resolveu separá-los em diversas pilhas e aplicar algumas operações sobre elas. Como todos já sabem, Dabriel é um Mestre Pomekon, então seus conhecimentos com programação são bem limitados, com isso ele solicitou sua ajuda para resolver o problema dele.
Dabriel deseja realizar Q operações nas pilhas, cada operação poderá ser de 2 tipos, como descrito abaixo:
1 X Y K: Retorna a quantidade de Pomekons que existiam no intervalo entre as posições X e Y, após a K-ésima operação do tipo 2. É garantido que a K-ésima operação já terá sido feita.
2 X W: Atualiza o total de Pomekons da pilha X com o valor W.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. Cada instância inicia com um inteiro N (1 ≤ N ≤ 10⁵), representando a quantidade de pilhas existentes. A segunda linha terá N inteiros pi (1 ≤ pi ≤ 10⁵), representando quantos Pomekons existem na pilha i. Na próxima linha haverá um inteiro Q (1 ≤ Q ≤ 10⁵), que representa a quantidade de operações que serão realizadas. Seguirão Q linhas, representando as Q operações realizadas.
Saída
Para cada operação do tipo 1, imprima uma única linha contendo a quantidade de Pomekons que existem entre as pilhas X e Y após a K-ésima operação.
Exemplo de Entrada Exemplo de Saída
1
4
1 2 3 4
9
1 1 2 0
1 1 3 0
1 1 4 0
2 1 5
1 1 4 1
1 1 1 1
2 4 0
1 1 4 0
1 1 4 2
3
6
10
14
5
10
10
II Maratona de programação do IFCE-Aracati |
1,218 | 2224 | Torneio de Pomekon | Médio | PARADIGMAS | Será realizado em sua cidade um grande torneio de Pomekon, onde todos os grandes Mestres irão disputar batalhas. A equipe organizadora do evento não contava com a grande quantidade de inscrições, portanto a equipe modificou um pouco as regras do torneio.
As invés de cada Mestre Pomekon participar sozinho das batalhas, serão formadas duplas, a seleção dos pares será feita pela equipe organizadora, pois como todos já sabem os Mestres Pomekons são solitários em suas jornadas, assim nenhum participante conhece o outro.
Os participantes do torneiro gostaram da nova regra no torneiro, mas ficaram preocupados de não conhecer seu parceiro e acabar não conseguindo um bom desempenho na competição, portanto foi decidido que as duplas seriam formadas por pessoas que morem o mais perto possível, assim ficaria fácil os Mestres Pomekons treinarem antes do grande dia.
Sua tarefa nesse problema é formar duplas de forma que a soma das distâncias entre as casas de cada dupla seja a menor possível. Em outras palavras, seja X1 a distância entre os membros da equipe 1 e X2 a distância entre os membros da equipe 2, você deverá minimizar o valor de X1 + X2.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias.
Cada instância inicia com um inteiro par N (1 < N ≤ 16), que corresponde a quantidade de Mestre Pomekons inscritos. Nas próximas N linhas terão dois inteiros Xi, Yi (0 ≤ Xi, Yi ≤ 1000), descrevendo a coordenada da casa do participante i.
Saída
Para cada instância imprima a soma das distâncias das casas de todas as duplas, com duas casas decimais.
Exemplo de Entrada Exemplo de Saída
2
2
9 9
10 10
10
10 10
20 10
5 5
1 1
120 3
6 6
50 60
3 24
6 9
0 0
1.41
118.40
II Maratona de programação do IFCE-Aracati |
1,219 | 2225 | Penalização | Muito Difícil | GRAFOS | No jogo Pomekon, um dos objetivos é visitar lugares reais para conseguir novos itens e experiência. Como Fulyane não gosta muito de sair de casa, ela fez um programa que simula sua localização, fornecendo falsas coordenadas de sua localização para o jogo. Ela também fez um controle, que faz com que ela possa se movimentar nas coordenadas falsas, simulando como se estivesse realmente caminhando, porém sem sair de casa.
Pesquisando em fóruns, viu que para não ser banida do jogo, teria que se mover utilizando apenas as rotas reais, porém, também viu que podia se mover instantaneamente de um lugar para outro, sem utilizar as rotas reais, no máximo K vezes por dia, pois caso ela se teletransportar além de K vezes, poderia ser banida do jogo para sempre.
Fulyane começa sempre no lugar identificado pelo índice 1, e quer visitar todos os demais o mais rápido possível, se teletransportando no máximo K vezes.
Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro T indicando o número de instâncias. A primeira linha de cada instância contém três inteiros N (1 ≤ N ≤ 15), M (1 ≤ M ≤ N2) e (0 ≤ K ≤ 5), representando, respectivamente, a quantidade de lugares, quantidade de rotas e a quantidade máximo permitida de teletransportes. Então seguiram M linhas, cada uma contendo três inteiros A, B e C (1 ≤ C ≤ 30000), representando que uma rua conecta os lugares A e B, e Fulyane demora C minutos para ir de A até B utilizando esta rua.
Saída
Para cada instância, imprima a quantidade mínima de minutos para Fulyane visitar todos os N lugares utilizando, no máximo, K teletransportes. Caso não seja possível visitar os N lugares, imprima -1.
Exemplo de Entrada Exemplo de Saída
2
3 2 0
1 2 3
1 3 2
5 4 0
4 3 16
3 3 13
5 2 15
2 4 20
7
-1
II Maratona de programação do IFCE-Aracati |
1,220 | 2226 | Fabrica de Balões | Muito Difícil | PARADIGMAS | Dâmião acabou de ser contratado como gerente da linha de produção de uma fabrica que produz os balões comercializados em Nlogonia. Dâmião quer mostrar serviço, e para isso aumentou e muito a produção da fabrica. Os balões produzidos por tal fabrica são empacotados e cada pacote recebe um código de identificação de até 18 dígitos, no processo de otimização da produção Dâmião fez com que o código do primeiro pacote fosse o numero 0, e para cada pacote produzido a partir de então, seu código seria o valor do ultimo pacote somado de uma unidade. Porém um imprevisto aconteceu, Dâmião não é natural da Nlogonia, por tanto não conhecia as superstições locais, e somente depois que vários pacotes foram produzidos foi alertado de que existem alguns números que são tidos com mal agouro para os habitantes de Nlogonia, e por este motivo nenhum pacote em que o numero aparece em seu código pode ser comercializado, independente do numero ser todo o código do produto ou apenas uma sub string do mesmo. Por exemplo, supondo que o numero 13 é tido como mal agouro, e ultimo pacote produzido foi o de código 130, somente os pacotes 13 e 130 não podem ser comercializados. Agora Dâmião quer saber o prejuízo que ele causou a empresa, e para isso ele precisa de sua ajuda
Entrada
A entrada é composta de diversos casos de teste. Cada caso de teste começa com uma linha com os inteiros N (0 ≤ N ≤ 1018 ) que representa o código do ultimo pacote produzido. A linha seguinte contem um inteiro M ( 0 ≤ M ≤ 5000 ) que representa a quantidade de números tidos como mal agouro, segue então M inteiros Ci ( 0 ≤ Ci ≤ 1018 ) representando o i-ésimo numero que não pode aparecer em qualquer código. O final da entrada é representado pelo caso onde N = 0 e não deve ser processado.
Saída
Para cada caso de teste seu programa deve imprimir uma linha contendo o numero de pacotes que não poderão ser comercializados
Exemplo de Entrada Exemplo de Saída
20
1 1
1000
2 201 731
0
11
2 |
1,221 | 2227 | Aeroporto | Fácil | AD-HOC | A crescente utilização do transporte aéreo preocupa os especialistas, que prevêem que o congestionamento em aeroportos poderá se tornar um grande problema no futuro. Os números atuais já são alarmantes: relatórios oficiais demonstram que na Europa, em junho de 2001, houve uma média de 7.000 atrasos de vôos por dia. Preocupada com a previsão dos seus especialistas em trá- fego aéreo, a Associação de Transporte Aéreo Internacional (ATAI) está começando um estudo para descobrir quais são os aeroportos onde o tráfego aéreo pode vir a ser mais problemático no futuro.
Como programador recém contratado pela ATAI você foi encarregado de escrever um programa para determinar, a partir de uma listagem de aeroportos e vôos, qual aeroporto possui maior probabilidade de congestionamento no futuro. Como medida da probabilidade de congestionamento será utilizado neste estudo o número total de vôos que chegam ou que partem de cada aeroporto.
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém dois números inteiros A (0 ≤ A ≤ 100) e V (0 ≤ V ≤ 10000), que indicam respectivamente o número de aeroportos e o número de vôos. Os aeroportos são identificados por inteiros de 1 a A. As V linhas seguintes contêm cada uma a informação de um vôo, representada por um par de números inteiros positivos X e Y (1 ≤ X ≠ Y ≤ A), indicando que há um vôo do aeroporto X para o aeroporto Y. O final da entrada é indicado quando A = V = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas. A primeira linha identifica o conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o identificador do aeroporto que possui maior tráfego aéreo. Caso mais de um aeroporto possua este valor máximo, você deve listar todos estes aeroportos, em ordem crescente de identificação, e separados por pelo menos um espaço em branco. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
5 7
1 3
2 1
3 2
3 4
4 5
3 5
2 5
3 5
1 3
1 2
3 2
1 2
2 1
0 0
Teste 1
3
Teste 2
1 2
OBI - Olimpíada Brasileira de Informática 2002 |
1,222 | 2228 | Caça ao Tesouro | Difícil | AD-HOC | Quando limpavam o porão da casa recentemente herdada, os primos João e José descobriram um antigo mapa guardado no baú que havia sido de seu bisavô. O mapa parecia descrever uma ilha, era muito antigo, e em meio a indicações de caminhos pela ilha, continha apenas um nome: Huyn Chong Chong. Curiosos, João e José pesquisaram o nome na bilbioteca do colégio e na Internet. Para sua surpresa e excitação, o nome era relacionado a uma antiga lenda de um tesouro escondido por piratas no século XVIII.
Encantados com a lenda, os primos acreditaram ter encontrado o mapa que os levaria ao tesouro, escondido na ilha de Huyn Chong Chong, próximo à Coréia do Sul. O tesouro, dizia a lenda, continha uma arca cheia de pedras preciosas muito raras e valiosas. Certos de que encontrariam o tesouro, os primos embarcaram rumo à ilha. Cada um dos primos se imaginava mais esperto do que o outro, e acreditava que encontraria o tesouro primeiro. Assim, eles combinaram que cada um ficaria com a parte do tesouro que encontrasse. Os primos então se separaram, e começaram a procurar o tesouro, especialmente a arca. Cada um dos primos tomou o caminho que imaginava que o levaria até a arca, e seguindo a indicação do mapa, ambos foram encontrando várias jóias pelo caminho. Coincidentemente, os dois primos cheragam ao mesmo tempo no local onde a arca estava escondida. Como os dois encontraram a arca ao mesmo tempo, eles tinham agora que decidir como dividir o tesouro. Depois de analisar algumas alternativas, os primos concordaram em fazer a divisão da seguinte forma. Cada um ficaria com a parte do tesouro que encontrou antes de chegar à arca, e o conteúdo da arca seria dividido de forma que os dois ficassem com partes do tesouro total de mesmo valor. Para fazer a divisão desta forma, ao chegar de volta ao Brasil, os primos mandaram avaliar cada jóia do tesouro. Contudo, eles estão agora em dúvida se é possível fazer a divisão conforme eles haviam combinado. Você, como amigo dos dois primos (agora milionários), e esperando receber alguma recompensa, dispôs-se a ajudá-los a descobrir se é possível fazer tal divisão.
São dados:
• o valor dos objetos coletados por João e por José antes de encontrarem a arca;
• uma lista de valores, correspondentes aos objetos encontrados dentro da arca.
Como as jóias são muito valiosas, estes valores são dados em unidades de R$ 1.000,00, ou seja, o valor 10 significa R$ 10.000,00. Você deve escrever um programa que determina se é possível dividir os objetos da arca de forma que, considerados também os valores dos objetos encontrados anteriormente (que ficarão com quem os encontrou), os primos recebam partes do tesouro com o mesmo valor.
Entrada
Seu programa deve ler vários conjuntos de testes. A primeira linha de um conjunto de testes contém três números inteiros X (0 ≤ X ≤ 50), Y (0 ≤ Y ≤ 50) e N (0 ≤ N ≤ 100). Os valores X e Y representam respectivamente a soma dos valores encontrados por João e por José antes de chegarem à arca. O valor N indica o número de objetos encontrados na arca. Seguem-se N linhas, cada uma contendo um número inteiro V (1 ≤ V ≤ 100), correspondendo ao valor de um dos objetos da arca. O final da entrada é indicado por X = Y = N = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o caractere ‘S’ caso seja possível dividir o tesouro como combinado pelos dois primos, ou o caractere ‘N’ caso contrário. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
10 20 4
3
8
7
2
1 1 6
2
7
7
12
5
3
0 0 0
Teste 1
S
Teste 2
N
OBI - Olimpíada Brasileira de Informática 2002 |
1,223 | 2229 | Dobradura | Fácil | AD-HOC | Zezinho tem aulas de Iniciação Artística em sua escola, e recentemente aprendeu a fazer dobraduras em papel. Ele ficou fascinado com as inúmeras possibilidades de se dobrar uma simples folha de papel. Como Zezinho gosta muito de matemática, resolveu inventar um quebra-cabeça envolvendo dobraduras. Zezinho definiu uma operação de dobradura D que consiste em dobrar duas vezes uma folha de papel quadrada de forma a conseguir um quadrado com 1/4 do tamanho original, conforme ilustrado na figura.
Depois de repetir N vezes esta operação de dobradura D sobre o papel, Zezinho cortou o quadrado resultante com um corte vertical e um corte horizontal, conforme a figura abaixo.
Zezinho lançou então um desafio aos seus colegas: quem adivinha quantos pedaços de papel foram produzidos?
Entrada
A entrada é composta de vários conjuntos de teste. Cada conjunto de teste é composto de uma única linha, contendo um número inteiro N (-1 ≤ N ≤ 15) que indica o número de vezes que a operação de dobradura D foi aplicada. O final da entrada é indicado por N = -1.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o número de pedaços de papel obtidos depois de cortar a dobradura, calculado pelo seu programa. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
1
0
-1
Teste 1
9
Teste 2
4
OBI - Olimpíada Brasileira de Informática 2002 |
1,224 | 2230 | Pedágio | Difícil | AD-HOC | Como prêmio pela primeira colocação na Olimpíada Brasileira de Informática, Juquinha e sua família ganharam uma viagem de uma semana à Coréia do Sul. Como o país é deslumbrante, com tradições, cultura, arquitetura e culinária muito diferentes das do Brasil, o pai de Juquinha, o Sr. Juca, decidiu alugar um carro para conhecer melhor o país. As estradas são muito bem cuidadas; todas são de sentido duplo, e duas cidades podem ser ligadas diretamente por mais de uma estrada. No entanto, em todas as estradas paga-se um pedágio de valor fixo (há um pedágio em cada direção, entre duas cidades). Como o Sr. Juca não tem muito dinheiro para gastar, as viagens com o carro devem ser muito bem planejadas.
Escreva um programa que, conhecidas as cidades e estradas existentes no país, e a cidade onde Juquinha e sua família estão, encontre cada cidade (que não a cidade onde eles estão) que possa ser visitada por eles, dada a restrição de que o Sr. Juca deseja pagar no máximo P pedágios (considerando apenas a viagem de ida).
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém quatro números inteiros C (0 ≤ C ≤ 50), E (0 ≤ E ≤ 2500), L (0 ≤ L ≤ C) e P (0 ≤ P ≤ C). Os valores C e E indicam respectivamente o número de cidades e o número de estradas existentes. As cidades são identificadas por inteiros de 1 a C. os valores L e P indicam, respectivamente, a cidade onde a família de Juquinha está no momento e o número máximo de pedágios que o Sr. Juca está disposto a pagar. As E linhas seguintes contêm cada uma a informação de uma estrada, representada por um par de números inteiros positivos X e Y (1 ≤ X,Y ≤ C), indicando que há uma estrada (de sentido duplo) da cidade X para a cidade Y. O final da entrada é indicado por C = E = L = P = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. Na segunda linha devem aparecer os identificadores das cidades que podem ser alcançadas, em ordem crescente, separados por pelo menos um espaço em branco. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
5 4 2 1
1 2
2 3
3 4
4 5
9 12 1 2
2 1
1 5
2 1
3 2
9 3
3 4
4 8
4 7
7 6
5 6
4 5
3 7
0 0 0 0
Teste 1
1 3
Teste 2
2 3 4 5 6
OBI - Olimpíada Brasileira de Informática 2002 |
1,225 | 2231 | Temperatura Lunar | Médio | AD-HOC | Sem as proteções da atmosfera e do cinturão magnético que existem na Terra, a Lua fica exposta ao ataque do Sol, que é um astro em constante explosão atômica. As explosões do Sol emitem ondas letais de partículas. Uma pessoa que ficasse desprotegida na superfície da Lua, num lugar onde o Sol incidisse diretamente, sofreria um bombardeio radioativo tão intenso quanto se estivesse nas imediações da usina russa de Chernobyl no momento do acidente que matou 31 pessoas, em 1986. Além da radiação solar, outro efeito desta falta de proteção contra o Sol que existe na Lua é a enorme variação de temperatura. Nas regiões próximas do equador lunar, a variação de temperatura é brutal, passando de cerca de 130 graus positivos durante o dia a 129 graus negativos à noite.
Para estudar com mais precisão as variações de temperatura na superfície da Lua, a NASA enviou à Lua uma sonda com um sensor que mede a temperatura de 1 em 1 minuto. Um dado importante que os pesquisadores desejam descobrir é como se comporta a média da temperatura, considerada em intervalos de uma dada duração (uma hora, meia hora, oito horas, etc.). Por exemplo, para a seqüência de medições 8, 20, 30, 50, 40, 20, -10, e intervalos de quatro minutos, as médias são respectivamente 108/4=27, 140/4=35, 140/4=35 e 100/4=25.
Você foi recentemente contratado pela NASA, e sua primeira tarefa é escrever um programa que, conhecidos a seqüência de temperaturas medidas pelo sensor, e o tamanho do intervalo desejado, informe qual a maior e qual a menor temperatura média observadas, considerando o tamanho do intervalo dado.
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém dois números inteiros positivos N (0 ≤ N ≤ 10000) e M (1 ≤ M ≤ N), que indicam respectivamente o número total de medições de temperatura (-200 ≤ temperatura ≤ 200) de uma seqüência obtida pelo sensor, e o tamanho dos intervalos, em minutos, em que as médias devem ser calculadas. As N linhas seguintes contêm um número inteiro cada, representando a seqüência de medidas do sensor. O final da entrada é indicado quando N = M = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas. A primeira linha identifica o conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter dois números inteiros X e Y, separados por ao menos um espaço em branco, representando respectivamente os valores da menor e da maior média de temperatura, conforme determinado pelo seu programa. O valor da média deve ser truncado, se a média não for um número inteiro (ou seja, deve ser impressa apenas a parte inteira). A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
4 2
-5
-12
0
6
7 4
35
-35
5
100
100
50
50
0 0
Teste 1
-8 3
Teste 2
26 75
OBI - Olimpíada Brasileira de Informática 2002 |
1,226 | 2232 | Triângulo de Pascal | Muito Fácil | MATEMÁTICA | O triângulo de Pascal (alguns países, nomeadamente em França, é conhecido como Triângulo de Tartaglia) é um triângulo numérico infinito formado por números binomiais , onde n representa o número da linha e k representa o número da coluna, iniciando a contagem a partir do zero. O triângulo foi descoberto pelo matemático chinês Yang Hui, e 500 anos depois várias de suas propriedades foram estudadas pelo francês Blaise Pascal. Cada número do triângulo de Pascal é igual à soma do número imediatamente acima e do antecessor do número de cima.
David, o fera do seu time de programação competitiva, descobriu que a soma da i-ésima linha de um triângulo de pascal é 2i. Ele quer agora descobrir a soma do triângulo inteiro, de N linhas. Mas como ele achou que este problema era muito trivial para merecer a atenção dele, ele decidiu tentar resolver um problema sobre grafos bipartidos (um tópico muito mais difícil) e assim, sobrou para você encontrar a solução deste problema.
Entrada
A primeira linha da entrada contém um inteiro T, o número de casos de teste. As próximas T linhas contêm um inteiro N (1 ≤ N ≤ 31), o número de linhas do Triângulo de Pascal.
Saída
Para cada caso de teste, a saída deve conter uma linha com um inteiro S, a soma do triângulo de pascal de N linhas.
Exemplo de Entrada Exemplo de Saída
4
1
2
5
31
1
3
31
2147483647 |
1,227 | 2233 | Etiquetas Coloridas | Médio | AD-HOC | Temos uma etiqueta quadrada vermelha de lado inteiro R, uma quantidade ilimitada de etiquetas quadradas verdes de lado inteiro G e uma quantidade ilimitada de etiquetas quadradas azuis de lado inteiro B. Sempre podemos colar a etiqueta vermelha na parede. Uma etiqueta verde só pode ser colada na parede sobre a etiqueta vermelha e tem que estar inteiramente sobre ela. Uma etiqueta azul só pode ser colada na parede sobre uma única etiqueta verde e tem que estar inteiramente sobre ela. Não pode haver qualquer sobreposição de etiquetas da mesma cor e as bases de todas as etiquetas têm que estar na horizontal. Na figura ao lado, conseguimos colar 14 etiquetas na parede. Neste problema, seu programa deve computar a quantidade máxima de etiquetas que podemos colar na parede. Só um detalhe: os inteiros R, G, e B serão dados em hexadecimal e a resposta também deve ser em hexadecimal.
Entrada
A entrada consiste de três linhas contendo, respectivamente, os inteiros R, G e B, 1 ≤ R, G, B ≤ ffffff. Todos os três inteiros na entrada estão em hexadecimal, com letras minúsculas.
Saída
Imprima uma linha na saída contendo um inteiro positivo, em hexadecimal com letras minúsculas, representando a quantidade máxima de etiquetas que podemos colar na parede.
Exemplos de Entrada Exemplos de Saída
1fa8
3bc
12
2be81
fffff0
ffffff
ab2c1
1
ffffff
1
1
1fffffc000003
Maratona de Programação SBC 2016 |
1,228 | 2234 | Cachorros-Quentes | Muito Fácil | INICIANTE | Em 2012 foi alcançado um novo recorde mundial na famosa Competição de Cachorros-Quentes do Nathan: o campeão, Joey Chestnut, devorou 68 cachorros-quentes em dez minutos, um aumento incrível em relação aos 62 sanduíches devorados pelo mesmo Chestnut em 2011.
O restaurante Nathan’s Famous Corporation, localizado no Brooklyn, NY, é o responsável pela competição. Eles produzem deliciosos cachorros-quentes, mundialmente famosos, mas quando o assunto é matemática eles não são tão bons. Eles desejam ser listados no Livro de Recordes do Guinness, mas para isso devem preencher um formulário descrevendo os fatos básicos da competição. Em particular, eles devem informar o número médio de cachorros-quentes consumidos pelos participantes durante a competição.
Você pode ajudá-los? Eles prometeram pagá-lo com um dos seus saborosos cachorros-quentes. Dados o número total de cachorros-quentes consumidos e o número total de participantes na competição, você deve escrever um programa para determinar o número médio de cachorros-quentes consumidos pelos participantes.
Entrada
A entrada consiste de uma única linha que contém dois inteiros H e P (1 ≤ H, P ≤ 1000) indicando respectivamente o número total de cachorros-quentes consumidos e o número total de participantes na competição.
Saída
Seu programa deve produzir uma única linha com um número racional representando o número médio de cachorros-quentes consumidos pelos participantes. O resultado deve ser escrito como um número racional com exatamente dois dígitos após o ponto decimal, arredondado se necessário.
Exemplos de Entrada Exemplos de Saída
10 90
0.11
840 11
76.36
1 50
0.02
34 1000
0.03
35 1000
0.04
Maratona de Programação SBC 2016 |
1,229 | 2235 | Andando no Tempo | Muito Fácil | INICIANTE | Imagine que você tenha uma máquina do tempo que pode ser usada no máximo três vezes, e a cada uso da máquina você pode escolher voltar para o passado ou ir para o futuro. A máquina possui três créditos fixos; cada crédito representa uma certa quantidade de anos, e pode ser usado para ir essa quantidade de anos para o passado ou para o futuro. Você pode fazer uma, duas ou três viagens, e cada um desses três créditos pode ser usado uma vez apenas. Por exemplo, se os créditos forem 5, 12 e 9, você poderia decidir fazer duas viagens: ir 5 anos para o futuro e, depois, voltar 9 anos para o passado. Dessa forma, você terminaria quatro anos no passado, em 2012. Também poderia fazer três viagens, todas indo para o futuro, usando os créditos em qualquer ordem, terminando em 2042.
Neste problema, dados os valores dos três créditos da máquina, seu programa deve dizer se é ou não possível viajar no tempo e voltar para o presente, fazendo pelo menos uma viagem e, no máximo, três viagens; sempre usando cada um dos três créditos no máximo uma vez.
Entrada
A entrada consiste de uma linha contendo os valores dos três créditos A, B e C (1 ≤ A, B, C ≤ 1000).
Saída
Seu programa deve imprimir uma linha contendo o caracter “S” se é poss ível viajar e voltar para o presente, ou “N” caso contrário.
Exemplos de Entrada Exemplos de Saída
22 5 22
S
31 110 79
S
45 8 7
N
Maratona de Programação SBC 2016 |
1,230 | 2236 | Batata Quente | Muito Difícil | PARADIGMAS | Batata quente é uma brincadeira bastante popular entre crianças na escola. A brincadeira é simples: a criança que está com a batata a joga para uma outra criança. Em algum momento, o professor, que não está olhando para o que está acontecendo, irá dizer que a brincadeira acabou. Quando isso acontece, a criança que está com a batata perde.
Uma variação da brincadeira, jogada na fila da cantina, é proposta por um professor. As crianças estão numeradas de 1 a N de acordo com sua posição na fila, onde a criança com o número 1 é a primeira da fila. Cada uma receberá um papel com um número, e sempre que receber a batata, deverá passá-la para a criança na posição anotada em seu papel. O jogo termina com o professor vitorioso se a batata chegar em uma posição menor ou igual a X na fila, com X definido no início da brincadeira. Se isso nunca acontecer, o jogo nunca termina, porém as crianças saem vitoriosas: no dia seguinte todas ganham um desconto na cantina.
O professor começa o jogo jogando a batata para alguma criança na fila. Como sua mira não é muito boa, ele só consegue garantir que vai jogar a batata para alguma criança em um invervalo L . . . R da fila com a mesma probabilidade. Ele está considerando vários possíveis intervalos da fila para iniciar a brincadeira. Para isso, o professor gostaria de descobrir, para cada um desses intervalos, qual o valor de X que ele deve escolher para que o jogo seja o mais justo possível, ou seja, a probabilidade de o jogo terminar seja a mais próxima possível da probabilidade de o jogo não terminar.
Você deve auxiliar o professor a avaliar as propostas. Dados os papéis de cada criança da fila e vários intervalos possíveis, responda, para cada intervalo, o valor de X que torne o jogo mais justo possível. Se houver empate, responda o X mais próximo do início da fila.
Entrada
A primeira linha da entrada contém dois inteiros, N e Q (2 ≤ N ≤ 50000, 1 ≤ Q ≤ 105). A linha seguinte contém N inteiros p1, p2 . . . pN (1 ≤ pi ≤ N ), os valores dos papéis recebidos por cada uma das crianças. Seguem então Q linhas, cada uma com dois inteiros L e R (1 ≤ L ≤ R ≤ N ), representando um intervalo considerado pelo professor.
Saída
Imprima Q linhas, cada uma contendo, para cada intervalo considerado pelo professor, o número inteiro X que o professor deverá escolher para que a brincadeira seja a mais justa possível.
Exemplos de Entrada Exemplos de Saída
9 4
2 3 4 5 6 7 4 9 5
1 3
3 5
2 8
7 9
1
3
3
1
3 3
1 3 3
1 1
1 2
2 3
1
1
2
Maratona de Programação SBC 2016 |
1,231 | 2237 | Containers | Difícil | AD-HOC | O SBC–Sistema de Balanceamento de Containers precisa ser atualizado para funcionar com uma nova classe de navios, a “dois por quatro”, que são navios que podem carregar oito grandes containers numa disposição de duas linhas e quatro colunas, como mostrado na figura ao lado. Esses navios possuem um guindaste fixo que é capaz de realizar um único tipo de movimentação: levantar dois containers adjacentes, na linha ou na coluna, e trocá-los de posição. Para acelerar o carregamento nos portos, os oito containers são embarcados em qualquer uma das oito posições, definindo uma configuração inicial. Depois que o navio deixa o porto, o guindaste precisa mover os containers para deixá-los numa configuração final pré-definida para a viagem.
O problema é que o custo de combustível para o guindaste realizar uma movimentação é igual à soma dos pesos dos dois containers adjacentes cujas posições foram trocadas. Dados os pesos dos containers em cada posição nas configurações inicial e final, o SBC precisa computar o custo total mínimo possível de uma sequência de movimentações que leve os containers da configuração inicial à configuração final.
Entrada
A entrada consiste de quatro linhas contendo, cada uma, quatro inteiros entre 1 e 1000, inclusive. As duas primeiras linhas definem os pesos na configuração inicial e as duas últimas linhas, os pesos na configuração final. Sempre existe uma solução, pois os containers nas configurações inicial e final são os mesmos, com as posições possivelmente trocadas.
Saída
Seu programa deve produzir uma única linha contendo um inteiro, representando o custo total mínimo de uma sequência de movimentos que leve da configuração inicial à configuração final.
Exemplos de Entrada Exemplos de Saída
3 1 2 1
4 7 52 9
7 1 2 1
3 9 52 4
81
1 2 3 4
5 10 7 8
1 2 3 4
5 8 7 10
50
34 5 6 998
4 17 77 84
34 5 6 998
4 17 77 84
0
Maratona de Programação da SBC – 2016 |
1,232 | 2238 | Divisores | Difícil | MATEMÁTICA | Pense um número positivo n. Agora me diga um divisor A de n. Agora me dê um outro número B que não seja divisor de n. Agora um múltiplo C. E um não múltiplo D. O número que você pensou é...
Parece um truque de mágica, mas é matemática! Será que, conhecendo os números A, B, C e D, você consegue descobrir qual era o número original n? Note que pode existir mais de uma solução!
Neste problema, dados os valores de A, B, C e D, você deve escrever um programa que determine qual o menor número n que pode ter sido pensado ou concluir que não existe um valor possível.
Entrada
A entrada consiste de uma única linha que contém quatro números inteiros A, B, C, e D, como descrito acima (1 ≤ A, B, C, D ≤ 109).
Saída
Seu programa deve produzir uma única linha. Caso exista pelo menos um número n para os quais A, B, C e D façam sentido, a linha deve conter o menor n possível. Caso contrário, a linha deve conter -1.
Exemplos de Entrada Exemplos de Saída
2 12 8 2
4
3 4 60 105
6
Maratona de Programação da SBC – 2016 |
1,233 | 2239 | Estatística Hexa | Muito Difícil | ESTRUTURAS E BIBLIOTECAS | Dada uma sequência de inteiros positivos em hexadecimal, por exemplo, S = [9af47c0b, 2545557, ff6447979], definimos soma(S) como sendo a soma de todos os elementos de S. Considere agora uma certa permutação dos 16 dígitos hexadecimais, por exemplo, p = [4, 9, 5, a, 0, c, f, 3, d, 7, 8, b, 1, 2, 6, e]. A partir da sequência base S, podemos definir uma sequência transformada S[4] , que é obtida pela remoção de todas as ocorrêcias do dígito hexadecimal 4 de todos os inteiros em S, S[4] = [9af7c0b, 255557, ff67979]. Em seguida, podemos remover o dígito 9 e obter S[4,9] = [af7c0b, 255557, ff677]. Seguindo a ordem dos dígitos na permutação p, podemos definir dessa forma 16 sequências: S[4] , S[4,9] , S[4,9,5] ,...,S[4,9,5,a,0,c,f,3,d,7,8,b,1,2,6,e] . Estamos interessados em somar todos os elementos dessas 16 sequências:
total(S, p) = soma(S[4]) + soma(S[4,9]) + soma(S[4,9,5]) + ··· + soma(S[4,9,5,a,0,c,f,3,d,7,8,b,1,2,6,e])
Claramente, esse total depende da permutação p usada na remoção sucessiva. Dada uma sequência de N inteiros positivos em hexadecimal, seu programa deve computar, considerando todas as possíveis permutações dos 16 dígitos hexadecimais: o total mínimo, o total máximo e o somatório dos totais de todas as permutações. Para o somatório dos totais de todas as permutações, imprima o resultado módulo 3b9aca07 (109 + 7 na base 10).
Entrada
A primeira linha da entrada contém um inteiro N, 1 ≤ N ≤ 3f, representando o tamanho da sequência. As N linhas seguintes contêm, cada uma, um inteiro positivo P, 0 ≤ P ≤ fffffffff, definindo a sequência inicial S de inteiros. Todos os números na entrada estão em hexadecimal, com letras minúsculas.
Saída
Seu programa deve produzir uma única linha na saída contendo três inteiros positivos, em hexadecimal com letras minúsculas, representando o total mínimo, o total máximo e o somatório dos totais considerando todas as permutações possíveis dos 16 dígitos hexadecimais.
Exemplos de Entrada Exemplos de Saída
3
9af47c0b
2545557
ff6447979
1312c99c b4e87e9387 5bb5fc
1
fffffffff
0 effffffff1 15dac189
Maratona de Programação da SBC – 2016 |
1,234 | 2240 | Fundindo Árvores | Difícil | ESTRUTURAS E BIBLIOTECAS | Em Computação árvores são objetos estranhos: a raiz está no topo e as folhas estão embaixo! Uma árvore é uma estrutura de dados composta de N vértices conectados por N-1 arestas de forma que é possível chegar de um vértice a qualquer outro vértice seguindo as arestas. Em uma árvore enraizada, cada aresta conecta um vértice pai a um vértice filho. Um único vértice não tem pai, e é chamado de raiz. Assim, partir da raiz é possivel chegar a qualquer outro vértice da árvore seguindo as arestas na direção de pai para filho.
Em uma árvore ternária cada vértice pode ter até três vértices filhos, chamados esquerdo, central e direito. Uma árvore ternária canhota é uma árvore ternária enraizada em que nenhum vértice tem filho direito. Uma árvore ternária destra é uma árvore ternária enraizada em que nenhum vértice tem filho esquerdo. A raiz de uma árvore ternária é sempre um vértice central. A figura abaixo mostra exemplos de uma árvore canhota e de uma árvore destra.
A superposição S de uma árvore canhota C com uma árvore destra D é uma árvore ternária enraizada em que a raiz é ou a raiz de C ou a raiz de D ou ambas as raízes, de C e de D, superpostas, e que contém a estrutura de ambas as árvores superpostas. A figura abaixo mostra algumas árvores formadas pela superposição da árvore canhota e da árvore destra da figura acima.
Note que na Figura (a) a raiz é o vértice x (da árvore destra) e os pares de vértices (a, y)e(c, u) são superpostos. Na Figura (b) a raiz é o vértice a (da árvore canhota) e os pares de vértices (d, x),(e, y)e(f, u) são superpostos. Na Figura (c) a raiz também é o vértice a (da árvore canhota) e o par de vértices (f, x) é superposto.
Dadas uma árvore canhota e uma árvore destra, sua tarefa é determinar o número mínimo de vértices necessários para construir uma árvore ternária que é uma superposição das árvores dadas.
Entrada
A primeira linha de um caso de teste contém um inteiro N indicando o número de vértices da árvore canhota (1 ≤ N ≤ 104). Vértices nesta árvore são identificados por números de 1 a N, e a raiz é o vértice de número 1. Cada uma das N linhas seguintes contém três inteiros I, L e K, indicando respectivamente o identificador de um vértice I, o identificador do filho esquerdo L de I e o identificador do filho central K de I (0 ≤ I, L, K ≤ N). A linha seguinte contém um inteiro M indicando o número de vértices da árvore destra (1 ≤ M ≤ 104). Vértices nesta árvore são identificados por números de 1 a M, e a raiz é o vértice de número 1. Cada uma das M linhas seguintes contém três inteiros P, Q e R, indicando respectivamente o identificador de um vértice P, o identificador do filho central Q de P e o identificador do filho direito R de P (0 ≤ P, Q, R ≤ N). O valor zero indica um vértice não existente (usado quando um vértice não tem um ou ambos os seus filhos).
Saída
Imprima o número mínimo de vértices de uma árvore que é a superposição das duas árvores dadas na entrada.
Exemplos de Entrada Exemplos de Saída
7
1 2 3
2 0 0
3 4 0
4 0 5
5 0 6
6 7 0
7 0 0
7
1 2 3
2 4 0
3 5 0
4 0 6
5 0 0
6 0 7
7 0 0
11
5
1 2 3
2 4 5
3 0 0
4 0 0
5 0 0
3
1 2 3
2 0 0
3 0 0
6
3
3 0 2
2 0 0
1 0 3
2
2 0 0
1 2 0
3
Maratona de Programação da SBC – 2016 |
1,235 | 2241 | Go-- | Fácil | ESTRUTURAS E BIBLIOTECAS | Go-- é até parecido com o tradicional jogo de Go, mas é bem mais fácil! Ele é jogado em um tabuleiro quadrado de dimensão N, inicialmente vazio, no qual dois jogadores, um jogando com as pedras pretas e o outro com as brancas, se alternam colocando uma pedra por vez dentro de qualquer célula que ainda não esteja ocupada. A partida termina depois que cada jogador colocou P pedras no tabuleiro. Considere todas as possíveis sub-áreas quadradas de dimensão de 1 a N. Uma sub-área pertence ao jogador que joga com as pedras pretas se ela contém pelo menos uma pedra preta e nenhuma pedra branca. Da mesma forma, uma sub-área quadrada pertence ao jogador que joga com as pedras brancas se contém ao menos uma pedra branca e nenhuma pedra preta. Note que as áreas que não contenham nenhuma pedra, ou que contenham tanto pedras pretas quanto brancas, não pertencem a nenhum jogador.
Neste problema, dada a posição final do tabuleiro, seu programa deve computar quantas sub-áreas quadradas pertencem a cada jogador, para descobrir quem ganhou a partida. Na figura, as pretas possuem 12 sub-áreas (cinco de dimensão 1, seis de dimensão 2 e uma de dimensão 3). As brancas, que perderam a partida, possuem apenas 10.
Entrada
A primeira linha da entrada contém dois inteiros N e P, 2 ≤ N ≤ 500, 1 ≤ P ≤ 500 e P ≤ N2/2, representando, respectivamente, a dimensão do tabuleiro e o número de pedras que cada jogador coloca. Cada uma das P linhas seguintes contém dois inteiros L e C (1 ≤ L, C ≤ N) definindo as coordenadas (linha, coluna) das pedras pretas. Depois, cada uma das próximas P linhas contém dois inteiros L e C (1 ≤ L, C ≤ N) definindo as coordenadas (linha, coluna) das pedras brancas. Todas as pedras são colocadas em células distintas.
Saída
Imprima uma linha contendo dois inteiros separados por um espaço: quantas áreas distintas pertencentes às pretas e às brancas.
Exemplos de Entrada Exemplos de Saída
2 1
1 1
2 2
1 1
5 5
1 3
2 3
2 4
4 1
5 3
1 5
2 1
3 5
4 4
5 1
12 10
500 3
500 498
500 499
500 500
120 124
251 269
499 498
4 12463784
Maratona de Programação da SBC – 2016 |
1,236 | 2242 | Huaauhahhuahau | Muito Fácil | STRINGS | Em chats, é muito comum entre jovens e adolescentes utilizar sequências de letras, que parecem muitas vezes aleatórias, para representar risadas. Alguns exemplos comuns são:
huaauhahhuahau
hehehehe
ahahahaha
jaisjjkasjksjjskjakijs
huehuehue
Cláudia é uma jovem programadora que ficou intrigada pela sonoridade das “risadas digitais”. Algumas delas ela nem mesmo consegue pronunciar! Mas ela percebeu que algumas delas parecem transmitir melhor o sentimento da risada que outras. A primeira coisa que ela percebeu é que as consoantes não interferem no quanto as risadas digitais influenciam na transmissão do sentimento. A segunda coisa que ela percebeu é que as risadas digitais mais engraçadas são aquelas em que as sequências de vogais são iguais quando lidas na ordem natural (da esquerda para a direita) ou na ordem inversa (da direita para a esquerda), ignorando as consoantes. Por exemplo, “hahaha” e “huaauhahhuahau” estão entre as risadas mais engraçadas, enquanto “riajkjdhhihhjak” e “huehuehue” não estão entre as mais engraçadas.
Cláudia está muito atarefada com a análise estatística das risadas digitais e pediu sua ajuda para escrever um programa que determine, para uma risada digital, se ela é das mais engraçadas ou não.
Entrada
A entrada é composta por uma linha, contendo uma sequência de no máximo 50 caracteres, formada apenas por letras minúsculas sem acentuação. As vogais são as letras ‘a’,‘e’,‘i’,‘o’,‘u’. A sequência contém pelo menos uma vogal.
Saída
Seu programa deve produzir uma linha contendo um caractere, “S” caso a risada seja das mais engraçadas, ou “N” caso contrário.
Exemplos de Entrada Exemplos de Saída
hahaha
S
riajkjdhhihhjak
N
a
S
huaauhahhuahau
S
Maratona de Programação da SBC 2016 |
1,237 | 2243 | Isósceles | Fácil | PARADIGMAS | Os irmãos Sérgio e Luiz estavam brincando com cubinhos de madeira e queriam construir um muro, que acabou ficando incompleto, com as colunas tendo diferentes alturas, como nessa figura.
Eles decidiram agora que a brincadeira seria retirar cubinhos, sempre de cima para baixo nas colunas, de maneira que no final restasse apenas um triângulo isósceles de cubinhos. Eles podem apenas retirar cubinhos do muro, sem recolocar em outra coluna, e os triângulos têm que ser completos. A figura abaixo ilustra os cinco primeiros triângulos isósceles de cubinhos, do tipo que eles querem, com alturas 1, 2, 3, 4 e 5 respectivamente.
Dada a sequência de alturas das colunas do muro, seu programa deve ajudar Sérgio e Luiz a descobrir qual é a altura máxima que o triângulo poderia ter ao final. No muro da primeira figura, com 30 colunas de cubinhos, o triângulo mais alto possível teria altura igual a sete.
Entrada
A primeira linha da entrada contém um inteiro N, 1 ≤ N ≤ 50000, representando o número de colunas do muro. A segunda linha contém N inteiros Ai, 1 ≤ Ai ≤ N, para 1 ≤ i ≤ N, indicando as alturas de cada coluna.
Saída
Seu programa deve produzir uma única linha com um inteiro H, representando a altura máxima que um triângulo poderia ter ao final.
Exemplos de Entrada Exemplos de Saída
16
5 6 5 8 9 10 5 8 9 5 7 9 9 9 6 3
6
8
5 1 1 1 1 1 1 3
1
Maratona de Programação da SBC 2016 |
1,238 | 2244 | Jogos Olímpicos | Muito Difícil | AD-HOC | Um grupo de investidores está pensando em investir pesado em atletas da delegação brasileira após as olimpíadas do Rio. Para isso, eles vêm observando N atletas e perceberam que alguns estão em decadência e outros em ascensão. Em especial, o grupo está de olho em dois fatores sobre cada atleta: seu cansaço e sua habilidade. Eles anotaram os valores de habilidade e cansaço de cada atleta logo ao final das olimpíadas de 2016. Em seguida, o grupo estimou a taxa com a qual cada atleta perde ou ganha habilidade e a taxa com a qual cada atleta se cansa ao longo do tempo, e percebeu que essas taxas são constantes para os dois atributos.
Os investidores perceberam que esses dados lhes permitem definir o que resolveram chamar de atleta de ouro: um atleta que, em um determinado período de tempo, é o atleta menos cansado e o mais habilidoso. Ficou decidido que investimentos serão feitos apenas em atletas de ouro. Descubra quantos jogadores, entre os observados inicialmente, receberão algum investimento. Considere que o tempo t = 0 é o tempo das olimpíadas do Rio: nenhum atleta que foi de ouro antes desse tempo pode receber investimento. Considere também que qualquer tempo após as olimpíadas do Rio deve ser considerado, por maior que seja. Um atleta que é de ouro exatamente no tempo t = 0 deve ser contado.
Entrada
A primeira linha da entrada contém um inteiro, N (1 ≤ N ≤ 105), o número de atletas. Seguem N linhas, cada uma com quatro números inteiros: Hi, Hti , Ci, Cti (-106 < Hi, Hti , Ci, Cti ≤ 106, Hti, Cti ≠ 0), representando, respectivamente, a habilidade ao final das olimpíadas, a taxa de variação da habilidade, o cansaço ao final das olimpíadas e a taxa de variação do cansaço do i-ésimo atleta.
Saída
Seu programa deve produzir uma única linha com um inteiro O, representando o número de atletas que receberão algum investimento do grupo.
Exemplos de Entrada Exemplos de Saída
3
3 2 1 2
2 2 2 2
1 2 3 2
1
6
1 10 5 8
8 7 12 -5
10 -2 -3 8
-3 -5 -8 -12
0 1 10 2
8 3 9 -3
0
Maratona de Programação da SBC 2016 |
1,239 | 2245 | Kit de Encolhimento de Polígonos | Muito Difícil | GEOMETRIA COMPUTACIONAL | Um Kit de Encolhimento de Polígonos é um material muito utilizado nas aulas de magia geométrica na Nlogônia. O kit consiste de dois pontos, A e B no plano cartesiano. Considere um polígono convexo dado pelos vértices 1, 2...N, nessa ordem. Para encolher esse polígono usando o kit, algumas regras devem ser respeitadas. Cada vértice x do polígono deve ser movido uma vez só: para o ponto médio do segmento Ax ou para o ponto médio do segmento Bx. A operação de encolhimento deve produzir um novo polígono convexo que preserve a ordem relativa dos vértices do polígono original. Em outras palavras, considerando todas as possíveis maneiras de aplicar o kit, apenas aquelas cuja sequência final dos vêrtices 1, 2...N representa um polígono convexo são válidas. Veja que o polígono convexo original pode estar em sentido horário e uma operação de encolhimento válida produzir um polígono convexo em sentido anti-horário, na mesma ordem dos vértices. Apenas a ordem relativa dos pontos é importante, não o sentido.
E sabido que magia geométrica não é o forte da maioria dos alunos. A professora pediu que eles usassem o kit de encolhimento para encolher um polígono convexo fornecido por ela de forma a obter a menor área possível e um amigo seu implorou para que você resolva a questão por ele. Responda a menor área possível do polígono para ele.
A Figura acima ilustra um uso válido do kit, onde o polígono sombreado é o de menor área possível que preserva a sequência dos vértices. Os pontos A e B correspondem aos pontos do kit. Note que, apesar do nome encolhimento, às vezes é possível utilizar o kit para aumentar a área dos polígonos! Como geometria é difícil!
Observe que um único ponto ou uma reta não são considerados polígonos. Sendo assim, se um uso do kit produzir como resultado algo diferente de um polígono convexo, esse não é um uso válido.
Entrada
A primeira linha da entrada contém um inteiro N (3 ≤ N ≤ 105), o némero de vértices do polígono. Seguem N linhas, cada uma com dois inteiros x, y (-106 ≤ x, y ≤ 106), os vértices do poligono. A última linha da entrada contém quatro inteiros, Ax, Ay, Bx e By (-106 ≤ Ax, Ay, Bx, By ≤ 106), as coordenadas x e y de A e as coordenadas x e y de B, respectivamente. Os pontos da entrada serão dados na ordem correta em que aparecem no polígono, no sentido horário ou anti-horário. Não haverão pontos repetidos e o polígono será convexo.
Saída
Seu programa deve produzir uma linha, contendo um número real, com 3 casas decimais de precisão, representando a menor área possível para um polígono obtido com o uso do kit.
Exemplos de Entrada Exemplos de Saída
3
20 6
4 8
2 6
0 0 4 0
3.500
3
0 4
4 4
0 0
3 -2 -3 -2
1.000
3
0 4
4 4
0 0
2 -2 -2 -2
2.000
Maratona de Programação da SBC 2016 |
1,240 | 2246 | Ladrilhos | Fácil | GRAFOS | Avelino tem um mosaico em uma das paredes de sua casa. É uma mosaico muito antigo, composto por pequenos ladrilhos coloridos. Como é um mosaico antigo, alguns ladrilhos se soltaram ao longo dos anos formando buracos.
Agora, Avelino quer restaurar o mosaico cobrindo os buracos com novos ladrilhos. Entretanto, para economizar, Avelino quer comprar ladrilhos de uma única cor para tapar os buracos. Em particular, quer comprar ladrilhos de uma das cores originais ou de uma cor ainda não contida no mosaico.
Por ser um mosaico, não se deseja que hajam áreas muito grandes com a mesma cor. Avelino resolveu que vai escolher a cor dos ladrilhos tentando fazer com que o tamanho da menor área monocromática seja o menor possível, para que haja mais detalhes. Veja que pode existir mais de uma cor possível. Uma área é monocromática se todos os ladrilhos nela são da mesma cor. Dois ladrilhos adjacentes fazem parte da mesma área se possuem a mesma cor, e dois ladrilhos são adjacentes se compartilham um lado.
Veja o primeiro caso de exemplo, temos três áreas da cor 1 (uma de tamanho 3 e duas de tamanho 2), uma área da cor 2 (de tamanho 3) e uma área da cor 3 de tamanho 7. Uma resposta possível seria escolher a cor 2, fazendo com que a menor área monocromática seja de tamanho 2. Se escolhermos a cor 1 a menor área seria de tamanho 3.
Crie um programa que imprima o tamanho da menor área possível.
Entrada
A primeira linha contém dois inteiros H e L, a altura e largura do mosaico, respectivamente, satisfazendo 1 ≤ H ≤ 200 e 1 ≤ L ≤ 200 . Em seguida, H linhas conterão cada uma L inteiros, separados por espaço, correspondendo às cores dos ladrilhos. Um inteiro 0 corresponde a um buraco e um inteiro i ≠ 0 corresponde a um ladrilho com a i-ésima cor, podendo ir de 1 até 40000 no máximo.
Saída
Seu programa deve produzir uma linha, contendo um inteiro, o tamanho da menor área possível.
Exemplos de Entrada Exemplos de Saída
3 8
3 3 3 1 1 0 0 0
3 1 1 0 2 2 0 1
3 3 3 0 0 2 1 1
2
3 7
1 1 0 2 2 1 1
1 1 0 2 2 1 1
1 1 0 0 3 3 3
3
3 6
2 2 2 2 0 2
2 2 2 0 2 2
2 2 2 2 0 2
1
Maratona de Programação da SBC 2016 |
1,241 | 2247 | Cofrinhos da Vó Vitória | Muito Fácil | AD-HOC | Vó Vitória mantém, desde o nascimento dos netos Joãozinho e Zezinho, um ritual que faz a alegria dos meninos. Ela guarda todas as moedas recebidas como troco em dois pequenos cofrinhos, um para cada neto. Quando um dos cofrinhos fica cheio, ela chama os dois netos para um alegre almoço, ao final do qual entrega aos garotos as moedas guardadas nos cofrinhos de cada um.
Ela sempre foi muito zelosa quanto à distribuição igualitária do troco arrecadado. Quando, por força do valor das moedas, ela não consegue depositar a mesma quantia nos dois cofrinhos, ela memoriza a diferença de forma a compensá-la no próximo depósito.
Vó Vitória está ficando velha e tem medo que deslizes de memória a façam cometer injustiças com os netos, deixando de compensar as diferenças entre os cofrinhos. Sua tarefa é ajudar Vó Vitória, escrevendo um programa de computador que indique as diferenças entre os depósitos, de forma que ela não tenha que preocupar-se em memorizá-las.
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém um número inteiro N (0 ≤ N ≤ 100), que indica o número de depósitos nos cofrinhos. As N linhas seguintes descrevem cada uma um depósito nos cofrinhos; o depósito é indicado por dois valores inteiros J e Z (0 ≤ J,Z ≤ 100), separados por um espaço em branco, representando respectivamente os valores, em centavos, depositados nos cofres de Joãozinho e Zezinho. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir um conjunto de linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A seguir seu programa deve escrever uma linha para cada depósito do conjunto de testes. Cada linha deve conter um inteiro que representa a diferença (em centavos) entre o valor depositado nos cofrinhos do Joãozinho e do Zezinho. Deixe uma linha em branco ao final de cada conjunto de teste. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
3
20 25
10 5
10 10
4
0 5
12 0
0 20
17 1
0
Teste 1
-5
0
0
Teste 2
-5
7
-13
3
OBI - Olimpíada Brasileira de Informática 2003 |
1,242 | 2248 | Estágio | Fácil | AD-HOC | Você conseguiu um estágio para trabalhar como programador na secretaria da sua escola. Como primeira tarefa, Dona Vilma, a coordenadora, solicitou que você aprimore um programa que foi desenvolvido pelo estagiário anterior. Esse programa tem como entrada uma lista de nomes e de médias finais dos alunos de uma turma, e determina o aluno com a maior média na turma. Dona Vilma pretende utilizar o programa para premiar o melhor aluno de cada turma da escola. O programa desenvolvido pelo estagiário anterior encontra-se nas páginas a seguir (programa Pascal na página 5, programa C na página 6, programa C++ na página 7).
Como você pode verificar, o programa na forma atual tem uma imperfeição: no caso de haver alunos empatados com a melhor média na turma, ele imprime apenas o primeiro aluno que aparece na lista.
Dona Vilma deseja que você altere o programa para que ele produza uma lista com todos os alunos da turma que obtiveram a maior média, e não apenas um deles. Você consegue ajudá-la nesta tarefa?
Entrada
A entrada é constituída de vários conjuntos de teste, representando várias turmas. A primeira linha de um conjunto de testes contém um número inteiro N (1 ≤ N ≤ 1000) que indica o total de alunos na turma. As N linhas seguintes contêm, cada uma, um par de números inteiros C (1 ≤ C ≤ 20000) e M (0 ≤ M ≤ 100), indicando respectivamente o código e a média de um aluno. O final da entrada é indicado por uma turma com N = 0.
Saída
Para cada turma da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Turma n”, onde n é numerado a partir de 1. A segunda linha deve conter os códigos dos alunos que obtiveram a maior média da turma. Os códigos dos alunos devem aparecer na mesma ordem da entrada, e cada um deve ser seguido de um espaço em branco. A terceira linha deve ser deixada em branco. O formato mostrado no exemplo de saída abaixo deve ser seguido rigorosamente.
Exemplo de Entrada Exemplo de Saída
3
1 85
2 91
3 73
5
12300 81
12601 99
15023 76
10111 99
212 99
0
Turma 1
2
Turma 2
12601 10111 212
OBI - Olimpíada Brasileira de Informática 2003 |
1,243 | 2249 | Número de Erdos | Médio | AD-HOC | O matemático húngaro Paul Erdos (1913-1996), um dos mais brilhantes do século XX, é considerado o mais prolífico matemático da história. Erdos publicou mais de 1500 artigos, em colabora- ção com cerca de outros 450 matemáticos. Em homenagem a este gênio húngaro, os matemáticos criaram um número, denominado "número de Erdos". Toda pessoa que escreveu um artigo com Erdos tem o número 1. Todos que não possuem número 1, mas escreveram algum artigo juntamente com alguém que possui número 1, possuem número 2. E assim por diante. Quando nenhuma ligação pode ser estabelecida entre Erdos e uma pessoa, diz-se que esta possui número de Erdos infinito. Por exemplo, o número de Erdos de Albert Einstein é 2. E, talvez surpreendentemente, o número de Erdos de Bill Gates é 4.
Sua tarefa é escrever um programa que, a partir de uma lista de autores de artigos, determine o número de Erdos dos autores.
Entrada
A entrada é constituída por vários conjuntos de teste. A primeira linha de um conjunto de teste contém um número inteiro A (1 ≤ A ≤ 100), que indica o número de artigos. Cada uma das A linhas seguintes contém a lista de autores de um artigo. Cada autor é identificado pela inicial de seu nome (em maiúscula), seguida de um ponto e de um espaço em branco (indicando que o nome está abreviado), seguida de seu último sobrenome (‘P. Erdos’, por exemplo). O sobrenome de um autor possui, no máximo, 15 letras, e apenas a letra inicial aparece em maiúscula. Os autores são separados por vírgulas, e a lista de autores de um artigo termina com um ponto (veja os exem- plos abaixo). Um único espaço em branco separa a abreviatura do nome do sobrenome, bem como o nome de um autor do anterior. Espaços em branco não são usados em outros locais. Um artigo possui, no máximo, 10 autores, e o total de autores não excede 100. O final da entrada é indicado por A = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir um conjunto de linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A seguir devem aparecer uma linha para cada autor do conjunto de testes (exceto o próprio P. Erdos). Cada linha deve conter o nome do autor seguido pelo caractere ‘:’, um espaço em branco e o seu número de Erdos. Caso o número de Erdos de um determinado autor seja infinito, escreva ‘infinito’. A saída deve ser ordenada alfabeticamente pelo sobrenome do autor, e, em caso de mesmo sobrenome, o desempate deve ser feito pela inicial do primeiro nome. Imprima uma linha em branco ao final de cada conjunto de teste. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
5
P. Erdos, A. Selberg.
P. Erdos, J. Silva, M. Souza.
M. Souza, A. Selberg, A. Oliveira.
J. Ninguem, M. Ninguem.
P. Duarte, A. Oliveira.
2
Z. Silva, P. Erdos.
Z. Souza.
0
Teste 1
P. Duarte: 3
J. Ninguem: infinito
M. Ninguem: infinito
A. Oliveira: 2
A. Selberg: 1
J. Silva: 1
M. Souza: 1
Teste 2
Z. Silva: 1
Z. Souza: infinito
OBI - Olimpíada Brasileira de Informática 2003 |
1,244 | 2250 | Tetris | Médio | AD-HOC | A sua turma do colégio resolveu organizar um campeonato de tetris. Após discussão sobre as regras, ficou definido que cada aluno jogaria um total de 12 partidas. Das 12 pontuações obtidas por um aluno, a maior e a menor são descartadas, e as demais são somadas, resultando na pontuação final do aluno.
Como você possui conhecimentos de programação, acabou sendo designado pela turma para escrever um programa para imprimir a classificação final do campeonato, a partir das pontuações de cada jogador.
Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de testes contém um número inteiro J (0 ≤ J ≤ 1000), que indica o número de jogadores que participaram do campeonato. A seguir, para cada jogador há duas linhas na entrada: a primeira possui o nome do jogador (formado apenas por letras, sendo apenas a inicial em maiúscula, e com no máximo 15 letras), e a segunda possui as 12 pontuações que o jogador obteve, separadas por espaço. As pontuações são inteiros entre 0 e 1000. O final da entrada é indicado por um conjunto de teste com J = 0.
Saída
Para cada conjunto de teste, o seu programa deve escrever uma linha contendo o identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A seguir, o seu programa deve escrever a classificação final no campeonato, utilizando uma linha para cada participante. Cada linha deve conter três informações, separadas por um espaço em branco: a classificação do jogador, a sua pontuação final, e o seu nome. A classificação de um jogador é igual a 1 mais o número de jogadores que obtiveram pontuação maior do que a sua. Em caso de empate, os jogadores devem ser ordenados em ordem alfabética. Depois de toda a classificação, deve ser deixada uma linha em branco. O formato do exemplo de saída abaixo deve ser seguido rigorosamente.
Exemplo de Entrada Exemplo de Saída
4
Zezinho
100 123 133 333 400 300 129 200 360 340 200 600
Luizinho
60 50 120 250 170 190 190 220 260 270 290 300
Carlinhos
10 10 20 10 10 10 10 20 20 20 20 20
Joaozinho
200 300 400 400 500 500 500 600 650 650 700 810
3
Pedrinho
100 100 200 200 300 300 400 400 500 500 600 600
Huguinho
50 100 200 200 300 300 500 500 400 400 600 700
Zezinho
100 100 100 100 100 100 100 100 100 100 100 100
0
Teste 1
1 5200 Joaozinho
2 2518 Zezinho
3 2020 Luizinho
4 150 Carlinhos
Teste 2
1 3500 Huguinho
1 3500 Pedrinho
3 1000 Zezinho
OBI - Olimpíada Brasileira de Informática 2003 |
1,245 | 2251 | Torres de Hanói | Fácil | AD-HOC | O quebra-cabeças Torres de Hanoi é muito antigo e conhecido, sendo constituído de um conjunto de N discos de tamanhos diferentes e três pinos verticais, nos quais os discos podem ser encaixados.
Cada pino pode conter uma pilha com qualquer número de discos, desde que cada disco não seja colocado acima de outro disco de menor tamanho. A configuração inicial consiste de todos os discos no pino 1. O objetivo do quebra-cabeças é mover todos os discos para um dos outros pinos, sempre obedecendo à restrição de não colocar um disco sobre outro menor.
Um algoritmo para resolver este problema é o seguinte.
procedimento Hanoi(N, Orig, Dest, Temp)
se N = 1 então
mover o menor disco do pino Orig para o pino Dest;
senão
Hanoi(N-1, Orig, Temp, Dest);
mover o N-ésimo menor disco do pino Orig para o pino Dest;
Hanoi(N-1, Temp, Dest, Orig);
fim-se
fim
Sua tarefa é escrever um programa que determine quantos movimentos de trocar um disco de um pino para outro serão executados pelo algoritmo acima para resolver o quebra-cabeça.
Entrada
A entrada possui vários conjuntos de teste. Cada conjunto de teste é composto por uma única linha, que contém um único número inteiro N (0 ≤ N ≤ 30), indicando o número de discos. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste, o seu programa deve escrever três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter o número de movimentos que são executados pelo algoritmo dado para resolver o problema das Torres de Hanói com N discos. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
1
2
0
Teste 1
1
Teste 2
3
OBI - Olimpíada Brasileira de Informática 2003 |
1,246 | 2252 | Descobrindo Senha | Médio | AD-HOC | Sherlock é um garoto muito inteligente, que nasceu em Londres na Inglaterra. Desde os dois anos ele sempre gostou de solucionar desafios. Com três anos foi campeão escolar de Sudoku. Seu tio Paul Harrison sempre gostou de desafiar o garoto trazendo problemas de lógica. Dessa vez Paul lançou um desafio, mas não é só um desafio, ele quer descobrir a senha da sala de seu chefe, para conseguir pegar alguns documentos importantes da empresa. Sua tarefa é construir um programa que ajude o seu tio com esse problema, dado a informação da quantidade de óleo sobre cada tecla.
Por exemplo, 0 = 0.80, 1 = 0.12, 2 = 0.01, 3 = 0.22, 4 = 0.35, 5 = 0.25, 6 = 0.77, 7 = 0.50, 8 = 0.63, 9 = 0.45 e n = 5, a senha será 06879.
Entrada
A entrada é composta por diversos casos de teste, e é concluida com final de arquivo. A primeira linha de cada caso é composta por um valor inteiro N (0 < N < 11), que corresponde a quantidade de dígitos da senha. Em seguida lê-se 10 valores Vi, onde (0 <= Vi < 1), o i-ésimo valor corresponde ao nível de oleosidade da tecla i da fechadura. Quanto maior o nível de oleosidade de uma tecla mais vezes ela foi utilizada. A senha formada não contém dígitos repetidos e é formada pelos N dígitos mais ultilizados.
Saída
Para cada caso de teste imprima um linha com a mensagem "Caso k: ", onde k indica o número do caso de teste seguido pela senha de acesso a sala do chefe. Mostre o resultado conforme o exemplo de saída. Em caso de duas teclas terem o mesmo nível de oleosidade, a tecla com o menor valor deve preceder as outras. Imprimir a senha de forma que comece mostrando a tecla de maior oleosidade para a menor.
Exemplo de Entrada Exemplo de Saída
5
0.02 0.23 0.07 0.18 0.17 0.72 0.48 0.36 0.67 0.35
4
0.76 0.52 0.74 0.19 0.15 0.99 0.13 0.59 0.48 0.45
4
0.83 0.86 0.37 0.16 0.41 0.38 0.36 0.67 0.32 0.20
Caso 1: 58679
Caso 2: 5027
Caso 3: 1074 |
1,247 | 2253 | Validador de Senhas | Médio | STRINGS | Rolien e Naej são os desenvolvedores de um grande portal de programação. Para ajudar no novo sistema de cadastro do site, eles requisitaram a sua ajuda. Seu trabalho é fazer um código que valide as senhas que são cadastradas no portal, para isso você deve atentar aos requisitos a seguir:
A senha deve conter, no mínimo, uma letra maiúscula, uma letra minúscula e um número;
A mesma não pode ter nenhum caractere de pontuação, acentuação ou espaço;
Além disso, a senha pode ter de 6 a 32 caracteres.
Entrada
A entrada contém vários casos de teste e termina com final de arquivo. Cada linha tem uma string S, correspondente a senha que é inserida pelo usuário no momento do cadastro.
Saída
A saída contém uma linha, que pode ser “Senha valida.”, caso a senha tenha cada item dos requisitos solicitados anteriormente, ou “Senha invalida.”, se um ou mais requisitos não forem atendidos.
Exemplo de Entrada Exemplo de Saída
beecrowd
AbcdEfgh99
URIOnlineJudge12
beecrowd 12
Aass9
Aassd9
Senha invalida.
Senha valida.
Senha valida.
Senha invalida.
Senha invalida.
Senha valida. |
1,248 | 2254 | Bem-me-quer, Malmequer Japonês | Médio | AD-HOC | No Japão, a primavera sempre dar o ar de sua graça e todos ficam ansiosos pelo Hanami, um ritual para contemplar a florada das flores de cerejeira, mais conhecidas como sakuras.
Kikuka Bakana, um rapaz inteligente e apaixonado, mora no Japão e decidiu inventar uma brincadeira chamada de bem-me-quer/malmequer de chomsky. Ele pretende contar a quantidade de pétalas da sakura que estão espalhadas pelo seu quintal para servir de índice para a sequência gerada pela sua brincadeira. Obviamente, ele não é louco para varrer todo o quintal e contar quantas pétalas estão no chão. Então, ele pretende estimar a quantidade de pétalas usando suas habilidades matemáticas e usar um programa feito pelo seu melhor amigo brasileiro para saber se “she loves me” ou “she loves not".
O bem-me-quer/malmequer de chomsky possui um símbolo inicial e um conjunto de regras geradoras. A partir de cada símbolo de uma sequência, podemos aplicar as regras geradoras sucessivamente (ad infinitum) para gerar uma nova sequência.
Kikuka Bakana utilizou a seguinte definição para sua brincadeira:
Símbolo Inicial: she loves not
Regras: (she loves not ==> she loves not, she loves me), (she loves me ==> she loves me, she loves not)
Exemplo de 3 etapas da geração:
{she loves not} ==> {she loves not, she loves me} ==> {she loves not, she loves me, she loves me, she loves not}
Entrada
A entrada possui vários casos de teste. Cada caso de teste contem uma linha com o número N (0 <= N <= 10^9) de pétalas estimadas. A entrada termina com EOF.
Saída
Para cada caso mostre, em uma linha, a frase correspondente na sequência gerada pelo bem-me-quer/malmequer de chomsky. (A primeira frase da sequência tem índice 0)
Exemplo de Entrada Exemplo de Saída
0
1
2
3
4
1234
she loves not
she loves me
she loves me
she loves not
she loves me
she loves me
- |
1,249 | 2255 | Self-Assembly | Médio | AD-HOC | Automatic Chemical Manufacturing is experimenting with a process called self-assembly. In this process, molecules with natural affinity for each other are mixed together in a solution and allowed to spontaneously assemble themselves into larger structures. But there is one problem: sometimes molecules assemble themselves into a structure of unbounded size, which gums up the machinery.
You must write a program to decide whether a given collection of molecules can be assembled into a structure of unbounded size. You should make two simplifying assumptions: 1) the problem is restricted to two dimensions, and 2) each molecule in the collection is represented as a square. The four edges of the square represent the surfaces on which the molecule can connect to other compatible molecules.
In each test case, you will be given a set of molecule descriptions. Each type of molecule is described by four two-character connector labels that indicate how its edges can connect to the edges of other molecules. There are two types of connector labels:
An uppercase letter (A, . . . , Z) followed by + or −. Two edges are compatible if their labels have the same letter but different signs. For example, A+ is compatible with A− but is not compatible with A+ or B−.
Two zero digits 00. An edge with this label is not compatible with any edge (not even with another edge labeled 00).
Assume there is an unlimited supply of molecules of each type, which may be rotated and reflected. As the molecules assemble themselves into larger structures, the edges of two molecules may be adjacent to each other only if they are compatible. It is permitted for an edge, regardless of its connector label, to be connected to nothing (no adjacent molecule on that edge).
Figure A.1 shows an example of three molecule types and a structure of bounded size that can be assembled from them (other bounded structures are also possible with this set of molecules).
Figure A.1: Illustration of Sample Input 1.
Entrada
The input consists of a single test case. A test case consists of two lines. The first contains an integer n (1 ≤ n ≤ 40 000) indicating the number of molecule types. The second line contains n eight-character strings, each describing a single type of molecule, separated by single spaces. Each string consists of four two-character connector labels representing the four edges of the molecule in clockwise order.
Saída
Display the word 'unbounded' if the set of molecule types can generate a structure of unbounded size. Otherwise, display the word 'bounded'.
Exemplos de Entrada Exemplos de Saída
3
A+00A+A+ 00B+D+A- B-C+00C+
bounded
1
K+K-Q+Q
unbounded
ICPC 2013 World Finals |
1,250 | 2257 | Surely You Congest | Médio | AD-HOC | You are in charge of designing an advanced centralized traffic management system for smart cars. The goal is to use global information to instruct morning commuters, who must drive downtown from the suburbs, how best to get to the city center while avoiding traffic jams.
Unfortunately, since commuters know the city and are selfish, you cannot simply tell them to travel routes that take longer than normal (otherwise they will just ignore your directions). You can only convince them to change to different routes that are equally fast.
The city’s network of roads consists of intersections that are connected by bidirectional roads of various travel times. Each commuter starts at some intersection, which may vary from commuter to commuter. All commuters end their journeys at the same place, which is downtown at intersection 1. If two commuters attempt to start travelling along the same road in the same direction at the same time, there will be congestion; you must avoid this. However, it is fine if two commuters pass through the same intersection simultaneously or if they take the same road starting at different times.
Determine the maximum number of commuters who can drive downtown without congestion, subject to all commuters starting their journeys at exactly the same time and without any of them taking a suboptimal route.
Figure C.1: Illustration of Sample Input 2.
In Figure C.1, cars are shown in their original locations. One car is already downtown. Of the cars at intersection 4, one can go along the dotted route through intersection 3, and another along the dashed route through intersection 2. But the remaining two cars cannot reach downtown while avoiding congestion. So a maximum of 3 cars can reach downtown with no congestion.
Entrada
The input consists of a single test case. The first line contains three integers n, m, and c, where n (1 ≤ n ≤ 25 000) is the number of intersections, m (0 ≤ m ≤ 50 000) is the number of roads, and c (0 ≤ c ≤ 1 000) is the number of commuters. Each of the next m lines contains three integers xi , yi , and ti describing one road, where xi and yi (1 ≤ xi , yi ≤ n) are the distinct intersections the road connects, and ti (1 ≤ ti ≤ 10 000) is the time it takes to travel along that road in either direction. You may assume that downtown is reachable from every intersection. The last line contains c integers listing the starting intersections of the commuters.
Saída
Display the maximum number of commuters who can reach downtown without congestion.
Exemplos de Entrada Exemplos de Saída
3 3 2
1 2 42
2 3 1
2 3 1
2 3
2
4 4 5
1 2 5
1 3 4
4 2 5
4 3 6
4 4 4 4 1
3
ICPC 2013 World Finals |
1,251 | 2258 | Factors | Médio | AD-HOC | The fundamental theorem of arithmetic states that every integer greater than 1 can be uniquely represented as a product of one or more primes. While unique, several arrangements of the prime factors may be possible. For example:
10 = 2 · 5
10 = 5 · 2
20 = 2 · 2 · 5
20 = 2 · 5 · 2
20 = 5 · 2 · 2
Let f(k) be the number of different arrangements of the prime factors of k. So f(10) = 2 and f(20) = 3. Given a positive number n, there always exists at least one number k such that f(k) = n. We want to know the smallest such k.
Input
The input consists of at most 1 000 test cases, each on a separate line. Each test case is a positive integer n < 263 .
Output
For each test case, display its number n and the smallest number k > 1 such that f(k) = n. The numbers in the input are chosen such that k < 263. Remember to let a blank space at the end of the line.
Input Sample Output Sample
1
2
3
105
1 2
2 6
3 12
105 720
ICPC 2013 World Finals |
1,252 | 2259 | Harvard | Médio | AD-HOC | The term “Harvard architecture” applies to a computer that has physically separate memories for instructions and data. The term originated with the Harvard Mark I computer, delivered by IBM in 1944, which used paper tape for instructions and relays for data.
Some modern microcontrollers use the Harvard architecture – but not paper tape and relays! Data memory is organized in banks, each containing the same number of data items. Each data-referencing instruction has a byte offset f to a bank, and a bit a that is used to select the bank to be referenced. If a is 0, then bank 0 is referenced. If a is 1, then the value in a bank select register (BSR) identifies the bank to be used. Assume each instruction takes the same time to execute, and there is an instruction that can set the BSR’s value.
For example, suppose there are 4 banks of 8 bytes each. To access location 5, either use a single instruction with a = 0 and f = 5, or set the BSR to 0 in one instruction and then use an instruction with a = 1 and f = 5. The first approach is faster since it does not require setting the BSR.
Now suppose (with the same memory) the location to access is 20. Only one approach will work here: execute an instruction that sets the BSR to 2 (unless the BSR already has the value 2) and then use an instruction with a = 1 and f = 4.
A program is a sequence of operations. Each operation is either
a variable reference, written as Vi, where i is a positive integer, or
a repetition, written as Rn <program> E, where n is a positive integer and <program> is an arbitrary program. This operation is equivalent to n sequential occurrences of <program>.
Your problem is to determine the minimum running time of programs. In particular, given the number and size of the memory banks and a program to be executed, find the minimum number of instructions (which reference memory location and possibly set the BSR) that must be executed to run the program. To do this you must identify a mapping of variables to memory banks that yields the smallest execution time, and report that execution time – that is, the number of memory references and BSR register settings required. The BSR’s value is initially undefined, and changes only when an instruction explicitly sets its value.
Input
The input consists of a single test case. A test case consists of two lines. The first line contains two integers b and s, where 1 ≤ b ≤ 13 is the number of memory banks and 1 ≤ s ≤ 13 is the number of variables that can be stored in each memory bank. The second line contains a non-empty program with at most 1 000 space-separated elements (each Rn, Vi, and E counts as one element).
You may assume the following:
In a repetition Rn, the number of repetitions satisfies 1 ≤ n ≤ 106 .
In a loop operation Rn <program> E, the loop body <program> is not empty.
In a variable reference Vi, the variable index satisfies 1 ≤ i ≤ min(b · s, 13).
The total number of variable references performed by an execution of the program is at most 1012.
Output
Display the minimum number of instructions that must be executed to complete the program.
Input Samples Output Samples
1 2
V1 V2 V1 V1 V2
5
2 1
V1 V2 V1 V1 V2
6
1 2
R10 V1 V2 V1 E
30
4 1
V1 R2 V2 V4 R2 V1 E V3 E
17
ICPC 2013 World Finals |
1,253 | 2260 | Low Power | Médio | AD-HOC | You are building advanced chips for machines. Making the chips is easy, but the power supply turns out to be an issue since the available batteries have varied power outputs.
Consider the problem of n machines, each with two chips, where each chip is powered by k batteries. Surprisingly, it does not matter how much power each chip gets, but a machine works best when its two chips have power outputs as close as possible. The power output of a chip is simply the smallest power output of its k batteries.
You have a stockpile of 2nk batteries that you want to assign to the chips. It might not be possible to allocate the batteries so that in every machine both chips have equal power outputs, but you want to allocate them so that the differences are as small as possible. To be precise, you want to tell your customers that in all machines the difference of power outputs of the two chips is at most d, and you want to make d as small as possible. To do this you must determine an optimal allocation of the batteries to the machines.
Consider Sample Input 1. There are 2 machines, each requiring 3 batteries per chip, and a supply of batteries with power outputs 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12. You can, for instance, assign the batteries with power outputs 1, 3, 5 to one chip, those with power 2, 4, 12 to the other chip of the same machine, those with power 6, 8, 9 to the third chip, and those with power 7, 10, 11 to the fourth. The power outputs of the chips are 1, 2, 6, and 7, respectively, and the difference between power outputs is 1 in both machines. Note that there are many other ways to achieve this result.
Entrada
The input consists of a single test case. A test case consists of two lines. The first line contains two positive integers: the number of machines n and the number of batteries per chip k (2nk ≤ 106 ). The second line contains 2nk integers pi specifying the power outputs of the batteries (1 ≤ pi ≤ 109 )
Saída
Display the smallest number d such that you can allocate the batteries so that the difference of power outputs of the two chips in each machine is at most d.
Exemplos de Entrada Exemplos de Saída
2 3
1 2 3 4 5 6 7 8 9 10 11 12
1
2 2
3 1 3 3 3 3 3 3
2
ICPC 2013 World Finals |
1,254 | 2261 | Map Tiles | Médio | AD-HOC | Publishing maps is not an easy task. First you need some appropriate transformation to display the earth’s spherical shape in a two-dimensional plane. Then another issue arises – most high-quality maps are too large to be printed on a single page of paper. To cope with that, map publishers often split maps into several rectangular tiles, and print each tile on one page. In this problem, you will examine this “tiling” process.
The International Cartographic Publishing Company (ICPC) needs to cut their printing costs by minimizing the number of tiles used for their maps. Even with a fixed tile size (determined by the page size) and map scale, you can still optimize the situation by adjusting the tile grid.
The left side of Figure G.1 shows 14 map tiles covering a region. The right side shows how you can cover the same region with only 10 tiles, without changing the tile sizes or orientation.
Figure G.1: Two possible ways of tiling Texas.
Your task is to help the ICPC find the minimum number of tiles needed to cover a given region. For simplicity, the region will be given as a closed polygon that does not intersect itself.
Note that the tiles must be part of a rectangular grid aligned with the x-axis and y-axis. That is, they touch each other only with their whole sides and cannot be rotated. Also note that although all input coordinates are integers, tiles may be located at non-integer coordinates.
The polygon may touch the edges of marginal lines (as in Sample Input 2). However, to avoid floatingpoint issues, you may assume the optimal answer will not change even if the polygon is allowed to go outside the map tiles by a distance of 10−6 .
Entrada
The input consists of a single test case. The first line of a test case contains three integers: n, xs, and ys. The number of polygon vertices is n (3 ≤ n ≤ 50), and xs and ys (1 ≤ xs, ys ≤ 100) are the dimensions of each tile. Each of the next n lines contains two integers x and y (0 ≤ x ≤ 10xs, 0 ≤ y ≤ 10ys), specifying the vertices of the polygon representing the region (in either clockwise or counter-clockwise order).
Saída
Display the minimal number of tiles necessary to cover the whole interior of the polygon.
Exemplos de Entrada Exemplos de Saída
12 9 9
1 8
1 16
6 16
9 29
19 31
23 24
30 23
29 18
20 12
22 8
14 0
14 8
10
4 5 7
10 10
15 10
15 17
10 17
1
ICPC 2013 World Finals |
1,255 | 2262 | Matryoshka | Médio | AD-HOC | Matryoshkas are sets of traditional Russian wooden dolls of decreasing size placed one inside the other. A matryoshka doll can be opened to reveal a smaller figure of the same sort inside, which has, in turn, another figure inside, and so on.
The Russian Matryoshka Museum recently exhibited a collection of similarly designed matryoshka sets, differing only in the number of nested dolls in each set. Unfortunately, some over-zealous (and obviously unsupervised) children separated these sets, placing all the individual dolls in a row. There are n dolls in the row, each with an integer size. You need to reassemble the matryoshka sets, knowing neither the number of sets nor the number of dolls in each set. You know only that every complete set consists of dolls with consecutive sizes from 1 to some number m, which may vary between the different sets.
When reassembling the sets, you must follow these rules:
You can put a doll or a nested group of dolls only inside a larger doll.
You can combine two groups of dolls only if they are adjacent in the row.
Once a doll becomes a member of a group, it cannot be transferred to another group or permanently separated from the group. It can be temporarily separated only when combining two groups.
Your time is valuable, and you want to do this reassembly process as quickly as possible. The only time-consuming part of this task is opening and subsequently closing a doll, so you want to minimize how often you do this. For example, the minimum number of openings (and subsequent closings) when combining group [1, 2, 6] with the group [4] is two, since you have to open the dolls with sizes 6 and 4. When combining group [1, 2, 5] with the group [3, 4], you need to perform three openings.
Write a program to calculate the minimum number of openings required to combine all disassembled matryoshka sets.
Input
The input consists of a single test case. A test case consists of two lines. The first line contains one integer n (1 ≤ n ≤ 500) representing the number of individual dolls in the row. The second line contains n positive integers specifying the sizes of the dolls in the order they appear in the row. Each size is between 1 and 500 inclusive.
Output
Display the minimum number of openings required when reassembling the matryoshka sets. If reassembling cannot be done (some of the kids might have been excessively zealous and taken some dolls), display the word 'Impossible'.
Input Samples Output Samples
7
1 2 1 2 4 3 3
Impossible
7
1 2 3 2 4 1 3
7
ICPC 2013 World Finals |
1,256 | 2263 | Pirate Chest | Médio | AD-HOC | Pirate Dick finally had enough of fighting, marauding, theft, and making life miserable for many on the open seas. So he decided to retire, and he found the perfect island to spend the rest of his days on, provided he does not run out of money. He has plenty of gold coins now, and he wants to store them in a chest (he is a pirate after all). Dick can construct a rectangular chest with integer dimensions of any size up to a specified maximum size for the top but with an arbitrary integer height. Now he needs a place to hide the chest. While exploring the island, he found the perfect solution.
Dick will hide his chest by submerging it in a murky pond. The pond has a rectangular surface, and it completely fills the bottom of a valley that has high vertical rocky walls. Dick surveyed the pond and knows its depth for each of the squares of a Cartesian coordinate grid system placed on the pond surface. When Dick submerges the chest, it will sink as far as possible until it touches the bottom. The top of the chest will remain parallel to the pond’s surface and the chest will be aligned with the grid squares. The water displaced by the submerged chest will raise the level of the pond’s surface (this will occur even if there is no space around the chest for the displaced water to rise). The walls of the valley are high enough that the water can never splash out of the valley. Of course, since the chest must be invisible, its top must be strictly below the surface of the pond. Your job is to find the volume of the largest chest that Pirate Dick can hide this way.
In Figure I.1, the leftmost image shows a pond, the middle image shows a possible placement of a chest of volume 3, and the rightmost image shows a placement of a chest of volume 4, which is the maximum possible volume. Note that if the second chest were made one unit taller, its top would be visible because it would be at exactly the same height as the surface of the water.
Figure I.1: Illustration of Sample Input 1.
Entrada
The input consists of a single test case. A test case starts with a line containing four integers a, b, m, and n (1 ≤ a, b, m, n ≤ 500). The pond’s surface dimensions are m × n and the maximum size of the top (and bottom) of the chest is a × b. In addition, a and b are small enough that it is not possible to cover the entire pond with a chest with top size a × b. Each of the remaining m lines in a test case contains n integers di,j specifying the pond’s depth at grid square (i, j), where 0 ≤ di,j ≤ 109 for each 1 ≤ i ≤ m and 1 ≤ j ≤ n.
Saída
Display the maximum volume of a rectangular chest with integer dimensions (where one of the dimensions of the top is bounded by a and the other is bounded by b) that can be completely submerged below the surface of the pond. If no chest can be hidden in the pond, display 0.
Exemplos de Entrada Exemplos de Saída
3 1 2 3
2 1 1
2 2 1
4
4 1 1 5
2 0 2 2 2
12
2 3 3 5
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
18
ICPC 2013 World Finals |
1,257 | 2265 | Up a Tree | Médio | AD-HOC | Anatoly Cheng McDougal is a typical student in many ways. Whenever possible he tries to cut and paste code instead of writing it from scratch. Unavoidably this approach causes him problems. For example, when he first learned about preorder, inorder and postorder traversals of trees, and was given code for a preorder print of a tree (shown on the left below), he simply cut and pasted the code, then moved the print statement to the correct location and renamed the procedure. However, he forgot to rename the procedure calls inside the code, resulting in the defective inorder print and postorder print code shown below.
At this point, Anatoly did not behave like a typical student. He actually tested his code! Unfortunately, when the results were not correct, he reverted back to typical student behavior. He panicked and started randomly changing calls in all three procedures, hoping to get things right. Needless to say, the situation became even worse now than when he started.
Anatoly’s professor tested the code on a random tree of characters. When she looked at the output of his three print routines, she correctly guessed what had happened. However, instead of going directly to his code, she decided to try to reconstruct Anatoly’s code just by observing the output. In order to do this, she correctly made the following assumptions:
The output statement in each print routine is in the correct location (for example, between the two recursive calls in the inPrint routine).
Among the six recursive calls made by the three routines, exactly two calls are to prePrint, exactly two are to inPrint, and exactly two are to postPrint, though potentially in the wrong routines.
Soon the professor realized that reconstructing Anatoly’s code and the test tree from his output was not a simple task and that the result might be ambiguous. You will have to help her find all possible reconstructions of Anatoly’s code. In addition, for each such reconstruction, you are to find the alphabetically first tree (as described in the output section) giving the observed output.
Entrada
The input consists of a single test case. A test case consists of three strings on three separate lines: the observed output of Anatoly’s prePrint, inPrint and postPrint routines (in that order) on some test tree. Each of these strings consists of n uppercase letters (4 ≤ n ≤ 26), with no repeated letters in any string. The test case is guaranteed to have at least one solution.
Saída
Display all possible reconstructions for the test case, ordered as described in the last paragraph below. The output for each reconstruction consists of two parts. The first part is a single line and describes the six calls in Anatoly’s routines: first the two (recursive) calls in Anatoly’s prePrint routine, followed by the calls in his inPrint routine, and finally the calls in his postPrint routine. The calls are described by the words Pre, In, and Post, separated by spaces. For example, if Anatoly’s routines were correct, the resulting output of the first part of the reconstruction would be Pre Pre In In Post Post.
The second part consists of three lines and describes the first test tree that could have generated the observed outputs. The first line is the correct preorder print of the tree, and the second and third lines contain the correct inorder and postorder prints, respectively. The first tree is the one with the alphabetically first preorder print. If there are multiple such trees, the first of these is the one with the alphabetically first inorder print.
Every reconstruction is a sequence of 6 tokens chosen from Pre, In, and Post. The ordering of reconstructions is lexicographic with respect to the following ordering of tokens: Pre < In < Post.
Exemplos de Entrada Exemplos de Saída
HFBIGEDCJA
BIGEDCJFAH
BIGEDCJFAH
Pre Post In Post In Pre
HFBJCDEGIA
BIGEDCJFAH
IGEDCJBAFH
BNLFAGHPEDOCMJIK
NLBGAPHCODEIJMKF
NLFAGHPEDOCMJIKB
In Pre In Post Post Pre
BLNFKMEHAGPCODIJ
NLBAGHPEODCMIJKF
NLGAPHDOCEJIMKFB
Post Pre In In Post Pre
BLNFKICPGAHEODMJ
NLBGAPHCODEIJMKF
NLAGHPDOECJMIKFB
ICPC 2013 World Finals |
1,258 | 2266 | Baggage | Médio | AD-HOC | An airline has two flights leaving at about the same time from ICPCity, one to city B and one to city A. The airline also has n counters where passengers check their baggage. At each counter there is a pair of identical baggage bins, one for city B and one for city A.
Just before the flights depart, each pair of baggage bins is moved by a motorized cart to a sorting area. The cart always moves two bins at a time, one for city B and one for city A. After all the bins have been moved, they line up in the sorting area like this:
B A B A B A ... B A
That is, there are 2n baggage bins in a row, starting with a bin for city B, then one for city A, and so forth. The task now is to reorder them so all the baggage bins for city A precede the baggage bins for city B. Then the bins can be loaded on the appropriate aircraft.
The reordering is done by moving pairs of adjacent baggage bins (not necessarily B then A), again via the motorized cart. For proper balance, the cart must always carry two bins, never just one. A pair of bins must always be moved to an empty space that is at least two bins wide. On the left of the first bin are some empty spaces that can be used as needed during the reordering.
When the reordering process begins, the bin locations are numbered from 1 (initially containing the leftmost B baggage bin) to 2n (initially containing the rightmost A baggage bin). There are 2n initially empty spaces to the left of the bins, numbered from 0 to −2n + 1, as shown in Figure A.1 for the case n = 4.
Figure A.1: Initial configuration of bins and empty spaces for n = 4
Given n, find a shortest sequence of moves that will reorder the bins so that all the A bins are to the left of all the B bins. At the end of the process, it is possible that the leftmost A bin is at some location other than 1, but the bins must be adjacent in a sequence of 2n locations.
Entrada
The input consists of a single test case, which consists of the integer n (3 ≤ n ≤ 100).
Saída
Display a shortest sequence of moves that will correctly reorder the bins. Each move is of the form “f to t”, where f and t are integers representing the movement of the bins in locations f and f + 1 to locations t and t + 1. If multiple solutions are possible, display any one of them.
Exemplos de Entrada Exemplos de Saída
5
8 to -1
3 to 8
6 to 3
0 to 6
9 to 0
8
10 to -1
3 to 10
14 to 3
7 to 14
0 to 7
11 to 0
4 to 11
15 to 4
ICPC 2014 World Finals |
1,259 | 2268 | Crane Balancing | Médio | AD-HOC | Wherever there is large-scale construction, you will find cranes that do the lifting. One hardly ever thinks about what marvelous examples of engineering cranes are: a structure of (relatively) little weight that can lift much heavier loads. But even the best-built cranes may have a limit on how much weight they can lift.
The Association of Crane Manufacturers (ACM) needs a program to compute the range of weights that a crane can lift. Since cranes are symmetric, ACM engineers have decided to consider only a cross section of each crane, which can be viewed as a polygon resting on the x-axis.
Figure C.1: Crane cross section
Figure C.1 shows a cross section of the crane in the first sample input. Assume that every 1 × 1 unit of crane cross section weighs 1 kilogram and that the weight to be lifted will be attached at one of the polygon vertices (indicated by the arrow in Figure C.1). Write a program that determines the weight range for which the crane will not topple to the left or to the right.
Entrada
The input consists of a single test case. The test case starts with a single integer n (3 ≤ n ≤ 100), the number of points of the polygon used to describe the crane’s shape. The following n pairs of integers xi , yi (−2 000 ≤ xi ≤ 2 000, 0 ≤ yi ≤ 2 000) are the coordinates of the polygon points in order. The weight is attached at the first polygon point and at least two polygon points are lying on the x-axis.
Saída
Display the weight range (in kilograms) that can be attached to the crane without the crane toppling over. If the range is [a, b], display [a] .. [b]. For example, if the range is [1.5, 13.3], display 1 .. 14. If the range is [a, ∞), display [a] .. inf. If the crane cannot carry any weight, display unstable instead.
Exemplos de Entrada Exemplos de Saída
7
50 50
0 50
0 0
30 0
30 30
40 40
50 40
0 .. 1017
7
50 50
0 50
0 0
10 0
10 30
20 40
50 40
unstable
ICPC 2014 World Finals |
1,260 | 2270 | Maze Reduction | Médio | AD-HOC | Jay runs a small carnival that has various rides and attractions. Unfortunately, times are tough. A recent roller coaster accident, flooding in the restrooms, and an unfortunate clown incident have given Jay’s carnival a bad reputation with the public. With fewer paying customers and reduced revenue, he will need to cut some costs to stay in business.
One of the biggest carnival attractions is a large, confusing maze. It consists of a variety of circular rooms connected by narrow, twisting corridors. Visitors love getting lost in it and trying to map it out. It has come to Jay’s attention that some of the rooms might be effectively identical to each other. If that’s the case, he will be able to reduce its size without anyone noticing.
Two rooms A and B are effectively identical if, when you are dropped into either room A or B (and you know the map of the maze), you cannot tell whether you began in A or B just by exploring the maze. The corridor exits are evenly spaced around each room, and you cannot mark or leave anything in a room (in particular, you cannot tell whether you have previously visited it). The only identifying feature that rooms have is their number of exits. Corridors are also twisty enough to be indistinguishable from each other, but when you enter a room you know which corridor you came from, so you can navigate a little by using the order they appear around the room.
Jay has appealed to the Association for Carnival Mazery for help. That’s you! Write a program to determine all the sets of effectively identical rooms in the maze.
Entrada
The input consists of a single test case. The first line contains an integer n, the number of rooms in the maze (1 ≤ n ≤ 100). Rooms are numbered from 1 to n. Following this are n lines, describing each room in order. Each line consists of an integer k, indicating that this room has k corridors (0 ≤ k < 100), and then k distinct integers listing the rooms each corridor connects to (in clockwise order, from an arbitrary starting point). Rooms do not connect to themselves.
Saída
Display one line for each maximal set of effectively identical rooms (ignoring sets of size 1) containing the room numbers in the set in increasing order. Order the sets by their smallest room numbers. If there are no such sets, display 'none' instead.
Exemplos de Entrada Exemplos de Saída
13
2 2 4
3 1 3 5
2 2 4
3 1 3 6
2 2 6
2 4 5
2 8 9
2 7 9
2 7 8
2 11 13
2 10 12
2 11 13
2 10 12
2 4
5 6
7 8 9 10 11 12 13
6
3 3 4 5
0
1 1
1 1
2 1 6
1 5
none
ICPC 2014 World Finals |
1,261 | 2272 | Metal Processing Plant | Médio | AD-HOC | Yulia works for a metal processing plant in Ekaterinburg. This plant processes ores mined in the Ural mountains, extracting precious metals such as chalcopyrite, platinum and gold from the ores. Every month the plant receives n shipments of unprocessed ore. Yulia needs to partition these shipments into two groups based on their similarity. Then, each group is sent to one of two ore processing buildings of the plant.
To perform this partitioning, Yulia first calculates a numeric distance d(i, j) for each pair of shipments 1 ≤ i ≤ n and 1 ≤ j ≤ n, where the smaller the distance, the more similar the shipments i and j are. For a subset S ⊆ {1, . . . , n} of shipments, she then defines the disparity D of S as the maximum distance between a pair of shipments in the subset, that is,
$$D(S) = \ _{i,j\in S}^{max}d(i,j)$$
Yulia then partitions the shipments into two subsets A and B in such a way that the sum of their disparities D(A) + D(B) is minimized. Your task is to help her find this partitioning.
Entrada
The input consists of a single test case. The first line contains an integer n (1 ≤ n ≤ 200) indicating the number of shipments. The following n − 1 lines contain the distances d(i, j). The ith of these lines contains n − i integers and the jth integer of that line gives the value of d(i, i + j). The distances are symmetric, so d(j, i) = d(i, j), and the distance of a shipment to itself is 0. All distances are integers between 0 and 109 (inclusive).
Saída
Display the minimum possible sum of disparities for partitioning the shipments into two groups.
Exemplos de Entrada Exemplos de Saída
5
4 5 0 2
1 3 7
2 0
4
4
7
1 10 5 5 5 5
5 10 5 5 5
100 100 5 5
10 5 5
98 99
3
15
ICPC 2016 World Finals |
1,262 | 2275 | Skiing | Médio | AD-HOC | As you know, the ACM ICPC is not the only major sporting event taking place in Russia this year. Several months ago, the 2014 Winter Olympics were held in Sochi, which is about 3 000 km from Ekaterinburg.
In an increasing number of sports, it is not only the ability of the athletes that determines who wins a competition but also their equipment. For example in downhill skiing, having the latest ski technology enables athletes to increase their speeds and improve their turning ability.
You have been hired to determine the effect of the latest ski technology on the ability of skiers to navigate a downhill course. The course contains several target locations, and the skier wants to pass over as many of them as possible. Naturally, the better the ski technology, the easier it will be to do this.
For simplicity, use a two-dimensional coordinate system where the skier starts at position (0,0) and where “downhill” corresponds to the direction of the positive y-axis.
Assume the y-component of the athlete’s velocity is a constant vy. The athlete can change speed laterally (in the x-direction), but the skiing equipment limits this to a maximal lateral acceleration amax. The skier starts with a lateral velocity of 0.
Figure J.1: Downhill ski path passing over three targets
In Figure J.1 (which corresponds to the first sample input), the optimal path passes over three out of four possible targets. If amax were smaller, then the skier might be able to pass over only two or fewer of the targets.
Entrada
The input contains a single test case. The first line contains three integers n, vy, and amax (0 ≤ n ≤ 250, 0 ≤ vy ≤ 105 and 0 ≤ amax ≤ 107 ), where n is the number of targets, vy is the y-component of the skier’s velocity, and amax is the maximum lateral acceleration. Here vy is given in meters per hour and amax in meters per hour squared.
Following this are n lines, each containing two integers xi and yi (−105 ≤ xi , yi ≤ 105 ). These give the coordinates of each target to be visited on the course. All coordinates are given in meters. Targets are numbered 1, 2, ..., n in the order they are given.
Saída
Display the maximal-length sequence of targets that the athlete could pass over on the course in a single run. Display the targets in the order they are visited. If there are multiple maximal-length sequences, display only the lexicographically first one. (So the sequence 2 15 would come before the sequence 10 15.) If the athlete cannot pass over any targets, print 'Cannot visit any targets' instead.
To ensure floating-point stability, you may assume the answer will not change if amax is perturbed by up to 0.1.
Exemplos de Entrada Exemplos de Saída
4 100 400
-100 100
50 200
-100 300
150 300
1 2 4
1 100 100
1000 10
Cannot visit any targets
ICPC 2014 World Finals |
1,263 | 2276 | Surveillance | Médio | AD-HOC | The International Corporation for Protection and Control (ICPC) develops efficient technology for, well, protection and control. Naturally, they are keen to have their own headquarters protected and controlled. Viewed from above, the headquarters building has the shape of a convex polygon. There are several suitable places around it where cameras can be installed to monitor the building. Each camera covers a certain range of the polygon sides (building walls), depending on its position. ICPC wants to minimize the number of cameras needed to cover the whole building.
Entrada
The input consists of a single test case. Its first line contains two integers n and k (3 ≤ n ≤ 106 and 1 ≤ k ≤ 106 ), where n is the number of walls and k is the number of possible places for installing cameras. Each of the remaining k lines contains two integers ai and bi (1 ≤ ai , bi ≤ n). These integers specify which walls a camera at the ith place would cover. If ai ≤ bi then the camera covers each wall j such that ai ≤ j ≤ bi . If ai > bi then the camera covers each wall j such that ai ≤ j ≤ n or 1 ≤ j ≤ bi .
Saída
Display the minimal number of cameras that suffice to cover each wall of the building. The ranges covered by two cameras may overlap. If the building cannot be covered, display 'impossible' instead.
Exemplos de Entrada Exemplos de Saída
100 7
1 50
50 70
70 90
90 40
20 60
60 80
80 20
3
8 2
8 3
5 7
impossible
8 2
8 4
5 7
2
ICPC 2014 World Finals |
1,264 | 2278 | Amalgamated Artichokes | Médio | AD-HOC | Fatima Cynara is an analyst at Amalgamated Artichokes (AA). As with any company, AA has had some very good times as well as some bad ones. Fatima does trending analysis of the stock prices for AA, and she wants to determine the largest decline in stock prices over various time spans. For example, if over a span of time the stock prices were 19, 12, 13, 11, 20 and 14, then the largest decline would be 8 between the first and fourth price. If the last price had been 10 instead of 14, then the largest decline would have been 10 between the last two prices.
Fatima has done some previous analyses and has found that the stock price over any period of time can be modelled reasonably accurately with the following equation:
price(k) = p · (sin(a · k + b) + cos(c · k + d) + 2)
where p, a, b, c and d are constants. Fatima would like you to write a program to determine the largest price decline over a given sequence of prices. Figure A.1 illustrates the price function for Sample Input 1. You have to consider the prices only for integer values of k.
Figure A.1: Sample Input 1. The largest decline occurs from the fourth to the seventh price.
Input
The input consists of a single line containing 6 integers p (1 ≤ p ≤ 1 000), a, b, c, d (0 ≤ a, b, c, d ≤ 1 000) and n (1 ≤ n ≤ 106 ). The first 5 integers are described above. The sequence of stock prices to consider is price(1), price(2), . . . , price(n).
Output
Display the maximum decline in the stock prices. If there is no decline, display the number 0. Your output should have an absolute or relative error of at most 10−6.
Input Samples Output Samples
42 1 23 4 8 10
104.855110477
100 7 615 998 801 3
0.00
100 432 406 867 60 1000
399.303813
ICPC 2015 World Finals |
1,265 | 2279 | Asteroids | Médio | AD-HOC | The year is 2115. The asteroid communication relay system was set up a decade ago by the Asteroid Communication Ministry. It is running fine except for one small problem – there are too many asteroids! The smaller ones not only keep interfering with the signals from the relay stations but they are also a danger to all the maintenance aircrafts that fly between the stations. These small asteroids must be destroyed! The Interplanetary Coalition to Prevent Catastrophes (ICPC) has been charged with removing these dangerous asteroids and has hired an elite team of hot-shot pilots for the job. Han Duo is the captain of this team of asteroid destroyers. Armed with his missiles, Han flies through the asteroid belt blowing up any asteroid that the ICPC deems a nuisance.
The ICPC is having some unfortunate budgetary problems. One result of this is that Han and his team do not have as many missiles as they would like, so they cannot blow up all the troublesome asteroids. But the asteroids are small and the missiles are powerful. So if two asteroids are near each other and line up properly, it is possible to take out both with a single missile.
Han’s screen displays asteroids as non-rotating two-dimensional simple convex polygons, each of which moves at a fixed velocity. He has decided that the best time to hit two asteroids is when the overlap of the two polygons is at a maximum. For example, Figure B.1, which illustrates Sample Input 1, shows two asteroids and snapshots of their subsequent positions at 1-second intervals. The two asteroids start touching after 3 seconds and the maximum overlap area occurs between 4 and 5 seconds.
Figure B.1: Sample Input 1. Two asteroids with crossing paths.
Calculating when the maximum overlap occurs for two asteroids requires a bit of programming, but unfortunately Han slept through most of his coding classes at the flight academy. This is where you come in.
Input
The input consists of two asteroid specifications. Each has the form n x1 y1 x2 y2 . . . xn yn vx vy where n (3 ≤ n ≤ 10) is the number of vertices, each xi , yi (−10 000 ≤ xi , yi ≤ 10 000) are the coordinates of a vertex of the asteroid on Han’s screen given in clockwise order, and vx, vy (−100 ≤ vx, vy ≤ 100) are the x and y velocities (in units/second) of the asteroid. The xi , yi values specify the location of each asteroid at time t = 0, and the polygons do not intersect or touch at this time. The maximum length of any side of an asteroid is 500. All numbers in the input are integers.
Output
Display the time in seconds when the two polygons have maximum intersection, using the earliest such time if there is more than one. If the two polygons never overlap but touch each other, treat it as an intersection where the common area is zero and display the earliest such time. If the polygons never overlap or touch, display never instead. You should consider positive times only. Your output should have an absolute or relative error of at most 10−3 .
Input Samples Output Samples
6 3 2 2 4 3 6 6 6 7 4 6 2 2 2
4 18 5 22 9 26 5 22 1 -2 1
4.193518
4 0 0 0 2 2 2 2 0 -1 1
4 10 0 10 2 12 2 12 0 1 1
never
ICPC 2015 World Finals |
1,266 | 2280 | Catering | Médio | AD-HOC | Paul owns a catering company and business is booming. The company has k catering teams, each in charge of one set of catering equipment. Every week, the company accepts n catering requests for various events. For every request, they send a catering team with their equipment to the event location. The team delivers the food, sets up the equipment, and instructs the host on how to use the equipment and serve the food. After the event, the host is responsible for returning the equipment back to Paul’s company.
Unfortunately, in some weeks the number of catering teams is less than the number of requests, so some teams may have to be used for more than one event. In these cases, the company cannot wait for the host to return the equipment and must keep the team on-site to move the equipment to another location. The company has an accurate estimate of the cost to move a set of equipment from any location to any other location. Given these costs, Paul wants to prepare an Advance Catering Map to service the requests while minimizing the total moving cost of equipment (including the cost of the first move), even if that means not using all the available teams. Paul needs your help to write a program to accomplish this task. The requests are sorted in ascending order of their event times and they are chosen in such a way that for any i < j, there is enough time to transport the equipment used in the ith request to the location of the jth request.
Input
The first line of input contains two integers n (1 ≤ n ≤ 100) and k (1 ≤ k ≤ 100) which are the number of requests and the number of catering teams, respectively. Following that are n lines, where the ith line contains n − i + 1 integers between 0 and 1 000 000 inclusive. The jth number in the ith line is the cost of moving a set of equipment from location i to location i + j. The company is at location 1 and the n requests are at locations 2 to n + 1.
Output
Display the minimum moving cost to service all requests. (This amount does not include the cost of moving the equipment back to the catering company.)
Input Samples Output Samples
3 2
40 30 40
50 10
50
80
3 2
10 10 10
20 21
21
40
ICPC 2015 World Finals |
1,267 | 2281 | Cutting Cheese | Médio | AD-HOC | Of course you have all heard of the International Cheese Processing Company. Their machine for cutting a piece of cheese into slices of exactly the same thickness is a classic. Recently they produced a machine able to cut a spherical cheese (such as Edam) into slices – no, not all of the same thickness, but all of the same weight! But new challenges lie ahead: cutting Swiss cheese.
Swiss cheese such as Emmentaler has holes in it, and the holes may have different sizes. A slice with holes contains less cheese and has a lower weight than a slice without holes. So here is the challenge: cut a cheese with holes in it into slices of equal weight.
By smart sonar techniques (the same techniques used to scan unborn babies and oil fields), it is possible to locate the holes in the cheese up to micrometer precision. For the present problem you may assume that the holes are perfect spheres.
Each uncut block has size 100×100×100 where each dimension is measured in millimeters. Your task is to cut it into s slices of equal weight. The slices will be 100 mm wide and 100 mm high, and your job is to determine the thickness of each slice.
Input
The first line of the input contains two integers n and s, where 0 ≤ n ≤ 10 000 is the number of holes in the cheese, and 1 ≤ s ≤ 100 is the number of slices to cut. The next n lines each contain four positive integers r, x, y, and z that describe a hole, where r is the radius and x, y, and z are the coordinates of the center, all in micrometers.
The cheese block occupies the points (x, y, z) where 0 ≤ x, y, z ≤ 100 000, except for the points that are part of some hole. The cuts are made perpendicular to the z axis.
You may assume that holes do not overlap but may touch, and that the holes are fully contained in the cheese but may touch its boundary.
Output
Display the s slice thicknesses in millimeters, starting from the end of the cheese with z = 0. Your output should have an absolute or relative error of at most 10−6.
Input Samples Output Samples
0 4
25.000000000
25.000000000
25.000000000
25.000000000
2 5
10000 10000 20000 20000
40000 40000 50000 60000
14.611103142
16.269801734
24.092457788
27.002992272
18.023645064
ICPC 2015 World Finals |
1,268 | 2282 | Evolution in Parallel | Médio | AD-HOC | It is 2178, and alien life has been discovered on a distant planet. There seems to be only one species on the planet and they do not reproduce as animals on Earth do. Even more amazing, the genetic makeup of every single organism is identical!
The genetic makeup of each organism is a single sequence of nucleotides. The nucleotides come in three types, denoted by ‘A’ (Adenine), ‘C’ (Cytosine), and ‘M’ (Muamine). According to one hypothesis, evolution on this planet occurs when a new nucleotide is inserted somewhere into the genetic sequence of an existing organism. If this change is evolutionarily advantageous, then organisms with the new sequence quickly replace ones with the old sequence.
It was originally thought that the current species evolved this way from a single, very simple organism with a single-nucleotide genetic sequence, by way of mutations as described above. However, fossil evidence suggests that this might not have been the case. Right now, the research team you are working with is trying to validate the concept of “parallel evolution” – that there might actually have been two evolutionary paths evolving in the fashion described above, and eventually both paths evolved to the single species present on the planet today. Your task is to verify whether the parallel evolution hypothesis is consistent with the genetic material found in the fossil samples gathered by your team.
Input
The input begins with a number n (1 ≤ n ≤ 4 000) denoting the number of nucleotide sequences found in the fossils. The second line describes the nucleotide sequence of the species currently living on the planet. Each of the next n lines describes one nucleotide sequence found in the fossils.
Each nucleotide sequence consists of a string of at least one but no more than 4 000 letters. The strings contain only upper-case letters A, C, and M. All the nucleotide sequences, including that of the currently live species, are distinct.
Output
Display an example of how the nucleotide sequences in the fossil record participate in two evolutionary paths. The example should begin with one line containing two integers s1 and s2, the number of nucleotide sequences in the fossil record that participate in the first path and second path, respectively. This should be followed by s1 lines containing the sequences attributed to the first path, in chronological order (from the earliest), and then s2 lines containing the sequences attributed to the second path, also in chronological order. If there are multiple examples, display any one of them. If it is possible that a sequence could appear in the genetic history of both species, your example should assign it to exactly one of the evolutionary paths.
If it is impossible for all the fossil material to come from two evolutionary paths, display the word impossible.
Input Samples Output Samples
5
AACCMMAA
ACA
MM
ACMAA
AA
A
1 4
MM
A
AA
ACA
ACMAA
3
ACMA
ACM
ACA
AMA
impossible
1
AM
MA
impossible
4
AAAAAA
AA
AAA
A
AAAAA
0 4
A
AA
AAA
AAAAA
ICPC 2015 World Finals |
1,269 | 2283 | Keyboarding | Médio | AD-HOC | How many keystrokes are necessary to type a text message? You may think that it is equal to the number of characters in the text, but this is correct only if one keystroke generates one character. With pocketsize devices, the possibilities for typing text are often limited. Some devices provide only a few buttons, significantly fewer than the number of letters in the alphabet. For such devices, several strokes may be needed to type a single character. One mechanism to deal with these limitations is a virtual keyboard displayed on a screen, with a cursor that can be moved from key to key to select characters. Four arrow buttons control the movement of the cursor, and when the cursor is positioned over an appropriate key, pressing the fifth button selects the corresponding character and appends it to the end of the text. To terminate the text, the user must navigate to and select the Enter key. This provides users with an arbitrary set of characters and enables them to type text of any length with only five hardware buttons.
In this problem, you are given a virtual keyboard layout and your task is to determine the minimal number of strokes needed to type a given text, where pressing any of the five hardware buttons constitutes a stroke. The keys are arranged in a rectangular grid, such that each virtual key occupies one or more connected unit squares of the grid. The cursor starts in the upper left corner of the keyboard and moves in the four cardinal directions, in such a way that it always skips to the next unit square in that direction that belongs to a different key. If there is no such unit square, the cursor does not move.
Figure F.1: Sample Input 1. An example virtual keyboard and hardware buttons.
Figure F.1, illustrating Sample Input 1, shows a possible way to type CONTEST using 30 strokes on an example virtual keyboard. The red dots represent the virtual keys where the select button was pressed.
Input
The first line of the input contains two integers r and c (1 ≤ r, c ≤ 50), giving the number of rows and columns of the virtual keyboard grid. The virtual keyboard is specified in the next r lines, each of which contains c characters. The possible values of these characters are uppercase letters, digits, a dash, and an asterisk (representing Enter). There is only one key corresponding to any given character. Each key is made up of one or more grid squares, which will always form a connected region. The last line of the input contains the text to be typed. This text is a non-empty string of at most 10 000 of the available characters other than the asterisk.
Output
Display the minimal number of strokes necessary to type the whole text, including the Enter key at the end. It is guaranteed that the text can be typed.
Input Samples Output Samples
4 7
ABCDEFG
HIJKLMN
OPQRSTU
VWXYZ**
CONTEST
30
5 20
12233445566778899000
QQWWEERRTTYYUUIIOOPP
-AASSDDFFGGHHJJKKLL*
--ZZXXCCVVBBNNMM--**
--------------------
ACM-ICPC-WORLD-FINALS-2015
160
2 19
ABCDEFGHIJKLMNOPQZY
X*****************Y
AZAZ
19
6 4
AXYB
BBBB
-KLMB
OPQB
DEFB
GHI*
AB
7
ICPC 2015 World Finals |
1,270 | 2284 | Pipe Stream | Médio | AD-HOC | Your hometown has hired some contractors – including you! – to manage its municipal pipe network. They built the network, at great expense, to supply Flubber to every home in town. Unfortunately, nobody has found a use for Flubber yet, but never mind. It was a Flubber network or a fire department, and honestly, houses burn down so rarely, a fire department hardly seems necessary.
In the possible event that somebody somewhere decides they want some Flubber, they would like to know how quickly it will flow through the pipes. Measuring its rate of flow is your job.
You have access to one of the pipes connected to the network. The pipe is l meters long, and you can start the flow of Flubber through this pipe at a time of your choosing. You know that it flows with a constant real-valued speed, which is at least v1 meters/second and at most v2 meters/second. You want to estimate this speed with an absolute error of at most t/2 meters/second.
Unfortunately, the pipe is opaque, so the only thing you can do is to knock on the pipe at any point along its length, that is, in the closed real-valued range [0, l]. Listening to the sound of the knock will tell you whether or not the Flubber has reached that point. You are not infinitely fast. Your first knock must be at least s seconds after starting the flow, and there must be at least s seconds between knocks.
Determine a strategy that will require the fewest knocks, in the worst case, to estimate how fast the Flubber is flowing. Note that in some cases the desired estimation might be impossible (for example, if the Flubber reaches the end of the pipe too quickly).
Input
The input consists of multiple test cases. The first line of input contains an integer c (1 ≤ c ≤ 100), the number of test cases. Each of the next c lines describes one test case. Each test case contains the five integers l, v1, v2, t and s (1 ≤ l, v1, v2, t, s ≤ 109 and v1 < v2), which are described above.
Output
For each test case, display the minimal number of knocks required to estimate the flow speed in the worst case. If it might be impossible to measure the flow speed accurately enough, display impossible instead.
Input Sample Output Sample
3
1000 1 30 1 1
60 2 10 2 5
59 2 10 2 5
5
3
impossible
ICPC 2015 World Finals |
1,271 | 2285 | Palíndrome | Médio | AD-HOC | Uma cadeia de caracteres é chamada de palíndrome se seqüência de caracteres da esquerda para a direita é igual à seqüência de caracteres da direita para a esquerda (uma outra definição é que o primeiro caractere da cadeia deve ser igual ao último caractere, o segundo caractere seja igual ao penúltimo caractere, o terceiro caractere seja igual ao antepenúltimo caractere, e assim por diante). Por exemplo, as cadeias de caracteres ‘mim’, ‘axxa’ e ‘ananaganana’ são exemplos de palíndromes.
Se uma cadeia não é palíndrome, ela pode ser dividida em cadeias menores que são palíndromes. Por exemplo, a cadeia ‘aaxyx’ pode ser dividida de quatro maneiras distintas, todas elas contendo apenas cadeias palíndromes: {‘aa’, ‘xyx’}, {‘aa’, ‘x’, ‘y’, ‘x’}, {‘a’, ‘a’, ‘xyx’} e {‘a’, ‘a’, ‘x’, ‘y’, ‘x’}.
Escreva um programa que determine qual o menor número de partes em que uma cadeia deve ser dividida de forma que todas as partes sejam palíndromes.
Entrada
A entrada é constituída de vários conjuntos de teste. A primeira linha de um conjunto de testes contém um inteiro N (1 ≤ N ≤ 2000) que indica o número de caracteres da cadeia . A segunda linha contém a cadeia de caracteres, composta por letras minúsculas (de ‘a’ a ‘z’), sem espaços em branco. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter um inteiro indicando o menor número de partes que a cadeia de entrada deve ser dividida de forma que todas as partes sejam palíndromes. A terceira linha deve ser deixada em branco. O formato mostrado no exemplo de saída abaixo deve ser seguido rigorosamente.
Exemplo de Entrada Exemplo de Saída
3
axa
6
xyzyyx
10
bbabcbbaab
0
Teste 1
1
Teste 2
4
Teste 3
4
OBI - Olimpíada Brasileira de Informática 2004 |
1,272 | 2286 | Par ou Ímpar | Fácil | AD-HOC | Muitas crianças gostam de decidir todas as disputas através do famoso jogo de Par ou Ímpar. Nesse jogo, um dos participantes escolhe Par e o outro Ímpar. Após a escolha, os dois jogadores mostram, simultaneamente, uma certa quantidade de dedos de uma das mãos. Se a soma dos dedos das mãos dos dois jogadores for par, vence o jogador que escolheu Par inicialmente, caso contrário vence o que escolheu Ímpar.
Dada uma seqüência de informações sobre partidas de Par ou Ímpar (nomes dos jogadores e números que os jogadores escolheram), você deve escrever um programa para indicar o vencedor de cada uma das partidas.
Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um conjunto de testes contém um inteiro N (0 ≤ N ≤ 1000), que indica o número de partidas de Par ou Ímpar que aconteceram. As duas linhas seguintes contêm cada uma um nome de jogador. Um nome de jogador é uma cadeia de no mínimo um e no máximo dez letras (maiúsculas e minúsculas), sem espaços em branco. As N linhas seguintes contêm cada uma dois inteiros A e B que representam o número de dedos que cada jogador mostrou em cada partida (0 ≤ A ≤ 5 e 0 ≤ B ≤ 5). Em todas as partidas, o primeiro jogador sempre escolhe Par. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste da entrada, seu programa deve produzir a saída da seguinte forma. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. As próximas N linhas devem indicar o nome do vencedor de cada partida. A próxima linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
3
Pedro
Paulo
2 4
3 5
1 0
2
Claudio
Carlos
1 5
2 3
0
Teste 1
Pedro
Pedro
Paulo
Teste 2
Claudio
Carlos
OBI - Olimpíada Brasileira de Informática 2004 |
1,273 | 2287 | Proteja sua Senha | Médio | AD-HOC | Por questões de segurança, muitos bancos hoje em dia estão alterando a forma como seus clientes digitam as senhas nos caixas eletrônicos, pois alguém pode postar-se atrás do cliente e ver as teclas à medida em que ele as digita.
Uma alternativa bastante utilizada tem sido associar os dez dígitos a cinco letras, de forma que cada letra esteja associada a dois dígitos, conforme o exemplo abaixo:
As associações entre números e letras são mostradas como botões numa tela sensível ao toque, permitindo que o cliente selecione os botões correspondentes à senha. Considerando a disposição dos botões da figura acima, a senha 384729 seria digitada como BCEAEB (note que a mesma seqüência de letras seria digitada para outras senhas, como por exemplo 982123).
Cada vez que o cliente usa o caixa eletrônico, as letras utilizadas são as mesmas (de ‘A’ a ‘E’), com os botões nas mesmas posições, mas os dígitos são trocados de lugar. Assim, caso um intruso veja (mesmo que mais de uma vez) a seqüência de letras digitada, não é possível notar facilmente qual a senha do cliente do banco.
Dada uma seqüência de associações entre letras e números, e as letras digitadas pelo cliente do banco para cada uma dessas associações, você deve escrever um programa para determinar qual é a senha do cliente.
Entrada
A entrada é composta de vários conjuntos de testes. A primeira linha de um conjunto de testes contém um inteiro N, que indica o número de associações entre letras e números e as senhas digitadas (2 ≤ N ≤ 10). As N linhas seguintes contêm as entradas da seguinte forma: 10 dígitos, em ordem de associação, para as letras de ‘A’ a ‘E’ (2 dígitos para a letra A, 2 para a B e assim sucessivamente) e 6 letras que representam a senha codificada conforme os dígitos anteriores. As N associações fornecidas em um conjunto de testes serão sempre suficientes para definir univocamente a senha do cliente. O final da entrada é indicado por N = 0.
Saída
Para cada conjunto de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter a senha do cliente, com um espaço após cada dígito. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
2
1 7 3 9 0 8 5 6 2 4 B C E A E B
9 0 7 5 8 4 6 2 3 1 E C C B D A
3
0 1 2 3 4 5 6 7 8 9 B C D D E E
1 3 5 4 6 8 7 9 0 2 E B C D C D
3 2 0 4 5 9 7 6 8 1 A C D D E C
0
Teste 1
3 8 4 7 2 9
Teste 2
2 5 6 7 8 9
OBI - Olimpíada Brasileira de Informática 2004 |
1,274 | 2288 | TV da Vovó | Médio | AD-HOC | A vovó tem um televisor muito antigo, que ultimamente está exibindo um defeito incômodo: a imagem aparece ‘deslocada’ (para cima ou para baixo, para o lado direito ou para o lado esquerdo). Quando a imagem está deslocada para cima, a parte da imagem que deixa de ser vista na parte superior reaparece na parte de baixo da tela. Da mesma forma, quando a imagem está deslocada a direita, a parte da imagem que deixa de ser vista à direita reaparece na tela do lado esquerdo.
A imagem do televisor pode ser vista como uma matriz de pontos organizados em linhas e colunas. Para consertar o televisor da vovó, você pode ajustar a imagem introduzindo uma série de ‘comandos de correção’ em um painel de ajuste. Cada comando de correção desloca a imagem de um certo número de linhas (para cima ou para baixo) e um certo número de colunas (para a direita ou para a esquerda).
Entrada
A entrada possui vários conjuntos de teste. Cada conjunto de teste inicia com a descrição da matriz que representa a imagem do televisor. A primeira linha contém dois inteiros M e N representando o número de linhas e o número de colunas da matriz (1 ≤ N,M ≤ 1000). As M linhas seguintes da entrada contém cada uma N inteiros, descrevendo o valor de cada ponto da imagem. Após a descrição da imagem, segue-se a descrição dos comandos de correção. Cada comando de correção é descrito em uma linha contendo dois inteiros X e Y(0 ≤ X,Y ≤ 1000). O valor de X representa o deslocamento na direção horizontal (valor positivo representa deslocamento para a direita, valor negativo para a esquerda), e o valor de Y representa o deslocamento da direção vertical (valor positivo para cima, valor negativo para baixo). O final da lista de comandos é indicado por X = Y = 0, e o final da entrada é indicado por M = N = 0.
Saída
Para cada conjunto de teste, o seu programa deve produzir uma imagem na saída. A primeira linha da saída deve conter um identificador do conjunto de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A seguir deve aparecer a matriz que representa a imagem resultante, no mesmo formato da imagem de entrada. Ou seja, as M linhas seguintes devem conter cada uma N inteiros que representam os pixels da imagem. Após a imagem deixe uma linha em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
3 3
1 2 3
4 5 6
7 8 9
1 0
1 -1
0 0
3 4
6 7 8 5
10 11 12 9
2 3 4 1
-3 2
0 0
0 0
Teste 1
8 9 7
2 3 1
5 6 4
Teste 2
1 2 3 4
5 6 7 8
9 10 11 12
OBI - Olimpíada Brasileira de Informática 2004 |
1,275 | 2289 | Distância Hamming | Médio | AD-HOC | Na teoria da informação, a distância de Hamming entre duas strings de mesmo comprimento é o número de posições nas quais elas diferem entre si. Vista de outra forma, ela corresponde ao menor número de substituições necessárias para transformar uma string na outra, ou o número de erros que transformaram uma na outra.
A distância de Hamming é assim chamada em homenagem a Richard Hamming, que introduziu o conceito em um artigo fundamental sobre códigos de Hamming Error detecting and error correcting codes em 1950.
Nas telecomunicações, ela é utilizada para sinalizar erros na transmissão de palavras binárias de comprimento fixo entre um emissor e um receptor, e por isso é algumas vezes chamada de "distância do sinal". Esta forma de análise de bits é usada em várias disciplinas incluindo a teoria da informação, a teoria de códigos e a criptografia.
Por exemplo, a representação binária de 910 é 10012 e do 1010 é 10102 logo a distância Hamming entre eles é 2 porque só é preciso alternar os dois últimos bits de 10012 para transformar em 10102.
Sua tarefa consiste em, dados dois números inteiros positivos, calcular a distância Hamming entre eles.
Entrada
A entrada consiste de vários casos de teste. Cada caso de teste é composto por dois números inteiros positivos na base decimal X e Y (0 ≤ X, Y < 264) fornecidos em uma única linha. A entrada termina quando X=Y=0.
Saída
A saída possui uma linha por caso de teste contendo a Distância Hamming das representações binárias de X e Y.
Exemplo de Entrada Exemplo de Saída
9 10
6 9
7 15
0 0
2
4
1 |
1,276 | 2290 | Números Apaixornados | Muito Difícil | ESTRUTURAS E BIBLIOTECAS | Será dado a você um vetor com N números, onde todos estarão em pares. Porém somente dois desses números acabaram ficando sem par, esses números são ditos números apaixornados, você consegue identificar quais são esses números?
Por exemplo, A = {1, 1, 3, 3, 5, 5, 5, 7}, os números apaixornados são 5 e 7.
Entrada
A entrada é composta por vários casos de teste. Cada caso de teste é composto por uma linha contendo um inteiro N (1 ≤ N ≤ 105), seguida por N números ( -1012 < A < 1012). A entrada termina quando N = 0 e não deve ser processada.
Saída
Para cada caso de teste imprima apenas os números apaixornados em ordem crescente. É garantido que apenas dois números estão sozinhos.
Exemplo de Entrada Exemplo de Saída
6
1 3 4 7 3 1
4
1 1 5 1
8
1 1 3 3 5 5 5 7
0
4 7
1 5
5 7
Agradecimentos à Wesley Rocha UEA-Brasil pelo nome do problema |
1,277 | 2291 | Números Divinos | Difícil | MATEMÁTICA | Números perfeitos são números que são iguais à soma dos seus divisores, desconsiderando-se eles mesmos. Baseando-se nesse conceito, números divinos são números que são iguais ao somatório da soma de cada divisor de 1 a N.
Por exemplo, 15 é o quarto número divino porque
1 é soma dos divisores de 1,
3 é a soma dos divisores do 2,
4 é a soma dos divisores do 3,
7 é a soma dos divisores do 4,
e 15=1+3+4+7.
Dado um número N encontre o N-ésimo número Divino.
Entrada
A entrada é composta por vários casos de teste. Cada caso de teste contém um único número inteiro (1 ≤ N ≤ 106) que corresponde a ordem do número Divino como especificado. A entrada termina quando N=0.
Saída
A saída consiste em uma única linha por caso de teste contendo o N-ésimo número Divino.
Exemplo de Entrada Exemplo de Saída
1
2
3
4
100
0
1
4
8
15
8299 |
1,278 | 2292 | Painel LED | Médio | STRINGS | Na Nlogonia são fabricados painéis de lâmpadas LED para o natal que funcionam como pisca-piscas. Esses painéis são compostos de N lâmpadas dispostas horizontalmente lado a lado. Além disso, esses panéis tem um comportamento bem definido: logo ao ser conectado a uma tomada, algumas lâmpadas acendem instantaneamente. Depois disso a lâmpada mais à esquerda alterna seu estado de ligado para desligado a cada piscada do painel, exceto por ela, todas as outras lâmpadas só alternam seu estado se a lâmpada a sua esquerda apagar.
Curioso como é, Vitor, um garoto feliz habitante de Nlogonia, quer saber, dado o número de alternâncias da primeira lâmpada (mais à esquerda), qual é a configuração final do Painel.
Entrada
A primeira linha da entrada contém um número inteiro N que especifica a quantidade de casos de teste. Depois haverá N linhas cada uma contendo uma string P (1 ≤ |P| ≤ 60) que representa a configuração inicial do painel de lâmpadas. As lâmpadas inicialmente acesas são representadas pelo caracter 'O' e as apagadas por 'X'. Na mesma linha haverá também um número inteiro C (1 ≤ C ≤ 1018) que representa a quantidade de alternâncias da primeira lâmpada.
Saída
A saída consiste em uma linha por caso de teste contendo a configuração final do painel após as alternâncias da primeira lâmpada.
Exemplo de Entrada Exemplo de Saída
3
XOXXO 1
XOXXO 2
XOXXO 13
OOXXO
XXOXO
OOOOO |
1,279 | 2293 | Campo de Minhocas | Fácil | AD-HOC | Minhocas são muito importantes para a agricultura e como insumo para produção de ração animal. A Organização para Bioengenharia de Minhocas (OBM) é uma entidade não governamental que promove o aumento da produção, utilização e exportação de minhocas.
Uma das atividades promovidas pela OBM é a manutenção de uma fazenda experimental para pesquisa de novas tecnologias de criação de minhocas. Na fazenda, a área destinada às pesquisas é de formato retangular, dividida em células quadradas de mesmo tamanho. Em cada célula é criada apenas uma espécie de minhoca. As células são utilizadas para testar os efeitos, sobre a produção de minhocas, de variações de espécies de minhoca, de tipos de terra, de adubo, de umidade, etc. Os pesquisadores da OBM mantêm um acompanhamento constante do desenvolvimento das minhocas em cada célula, e têm uma estimativa extremamente precisa da produtividade de cada uma das células.
Um pesquisador da OBM inventou e construiu uma máquina colhedeira de minhocas, e quer testá- la na fazenda. A máquina tem a largura de uma célula, e em uma passada pelo terreno de uma célula colhe todas as minhocas dessa célula, separando-as, limpando-as e empacotando-as. Ou seja, a máquina eliminara uma das etapas mais intensivas de mão de obra no processo de produção de minhocas. A máquina, porém, ainda está em desenvolvimento e tem uma restrição: não faz curvas, podendo movimentar-se somente em linha reta.
Decidiu-se então que seria efetuado um teste com a máquina, de forma a colher o maior número possível de minhocas em uma unica passada, em linha reta, de lado a lado do campo de minhocas. Ou seja, a máquina deve colher todas as minhocas de uma ‘coluna’ ou de uma ‘linha’ de células do campo de minhocas (a linha ou coluna cuja soma das produtividades esperadas das células é a maior possível).
Escreva um programa que, fornecido o mapa do campo de minhocas, descrevendo a produtividade estimada em cada célula, calcule o número esperado total de minhocas a serem colhidas pela máquina durante o teste, conforme descrito acima.
Entrada
A primeira linha da entrada contém dois números inteiros N e M, representando respectivamente o número de linhas (1 ≤ N ≤ 100) e o número de colunas (1 ≤ M ≤ 100) de células existentes no campo experimental de minhocas. Cada uma das N linhas seguintes contém M inteiros, representando as produtividades estimadas das células correspondentes a uma linha do campo de minhocas.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
A saída deve ser composta por uma unica linha contendo um inteiro, indicando o número esperado total de minhocas a serem colhidas pela máquina durante o teste.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplos de Entrada Exemplos de Saída
3 4
81 28 240 10
40 10 100 240
20 180 110 35
450
4 1
100
110
0
100
310
OBI - Olimpíada Brasileira de Informática 2005 Nível 1 |
1,280 | 2294 | Duende Perdido | Fácil | AD-HOC | Gugo, o duende, ficou preso em uma caverna e precisa sair o mais rapidamente possível. A caverna é formada por salões interligados por túneis, na forma de uma grade retangular, com N linhas e M colunas. Alguns dos salões da caverna têm paredes de cristal. Duendes, como todos sabem, nâo gostam de ficar em ambientes com qualquer tipo de cristal, pois seus organismos entram em ressonância com a estrutura de cristais, e em casos extremos os duendes podem até mesmo explodir. Compreensivelmente, Gugo não quer entrar em nenhum salão com parede de cristal.
A figura abaixo mostra uma caverna com quatro linhas e cinco colunas de salões; os salões cinza têm paredes de cristal. posição inicial de Gugo é indicada com um caractere ‘*’.
Você deve escrever um programa que, dadas a configuração da caverna e a posição inicial de Gugo dentro da caverna, calcule qual o número mínimo de salões pelos quais o duende deve passar antes de sair da caverna (não contando o salão em que o duende está inicialmente), mas contando o salão que tem saída para o exterior).
Entrada
A caverna será modelada como uma matriz de duas dimensões, cujos elementos representam os salões. Um salão que não tem parede de cristal e que tem saída para o exterior da caverna é representado pelo valor 0; um salão que não tem parede de cristal e não tem saída para o exterior é representado pelo valor 1; um salão que tem parede de cristal é representado pelo valor 2; e o salão em que o duende está inicialmente (que não tem saída para o exterior e nem paredes de cristal) é representado pelo valor 3. A figura abaixo mostra a representação da caverna apresentada acima.
A primeira linha da entrada contém dois números inteiros N e M que indicam respectivamente o número de linhas (1 ≤ N ≤ 10) e o número de colunas (1 ≤ M ≤ 10) da representação da caverna. Cada uma das N linhas seguintes contém M números inteiros Ci , descrevendo os salões da caverna e a posição inicial do duende (0 ≤ Ci ≤ 3). Você pode supor que sempre há um trajeto que leva Gugo à saída da caverna.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
Seu programa deve produzir uma única linha na saída, contendo um número inteiro representando a quantidade mínima de salões pelos quais Gugo deve passar antes de conseguir sair da caverna (não contando o salão em que ele está inicialmente, mas contando o salão que tem saída para o exterior).
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplos de Entrada Exemplos de Saída
4 5
0 1 1 1 1
0 2 2 2 1
2 1 1 1 1
1 1 1 3 1
8
1 10
2 0 1 1 3 1 1 1 0 1
3
OBI - Olimpíada Brasileira de Informática 2005 Nível 1 |
1,281 | 2295 | Frota de Táxi | Fácil | AD-HOC | A Companhia de Táxi Tabajara (CTT) é uma das maiores empresas de transporte do país. Possui uma vasta frota de carros e opera em todas as grandes cidades. Recentemente a CTT modernizou a sua frota, adquirindo um lote de 500 carros bi-combustíveis (carros que podem utilizar como combustível tanto álcool quanto gasolina). Além do maior conforto para os passageiros e o menor gasto com manutenção, com os novos carros é possível uma redução adicional de custo: como o preço da gasolina está sujeito a variações muito bruscas e pode ser vantagem, em certos momentos, utilizar álcool como combustível. Entretanto, os carros possuem um melhor desempenho utilizando gasolina, ou seja, em geral, um carro percorre mais quilômetros por litro de gasolina do que por litro de álcool.
Você deve escrever um programa que, dados o preço do litro de álcool, o preço do litro de gasolina e os quilômetros por litro que um carro bi-combustível realiza com cada um desses combustíveis, determine se é mais econômico abastecer os carros da CTT com álcool ou com gasolina. No caso de não haver diferença de custo entre abastecer com álcool ou gasolina a CTT prefere utilizar gasolina.
Entrada
A entrada é composta por uma linha contendo quatro números reais com precisão de duas casas decimais A e G (0.01 ≤ A, G ≤ 10.00) Ra e Rg (0.01 ≤ Ra , Rg ≤ 20.00) representando respectivamente o preço por litro do álcool, o preço por litro da gasolina, o rendimento (km/l) do carro utilizando álcool e o rendimento (km/l) do carro utilizando gasolina.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
A saída deve ser composta por uma única linha contendo o caractere ‘A’ se é mais econômico abastecer a frota com álcool ou o caractere ‘G’ se é mais econômico ou indiferente abastecer a frota com gasolina.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplos de Entrada Exemplos de Saída
1.20 2.30 10.00 15.00
A
1.00 1.00 9.00 9.01
G
1.00 1.00 11.00 11.00
G
OBI - Olimpíada Brasileira de Informática 2005 Nível 1 |
1,282 | 2296 | Trilhas | Médio | AD-HOC | Nos finais de semana Paulo faz longas caminhadas pelas bonitas trilhas que atravessam as matas vizinhas à sua cidade. Recentemente Paulo adquiriu um aparelho de GPS (siglas do inglês Sistema de Posicionamento Global) e com ele mapeou as mais belas trilhas da região. Paulo programou o GPS para armazenar, a intervalos regulares, a altitude do ponto corrente durante o trajeto. Assim, após percorrer as trilhas com o seu GPS, Paulo tem informações que permitem por exemplo produzir gráficos como os abaixo:
Paulo tem uma nova namorada, e quer convencê-la a passear junto com ele pelas trilhas. Para o primeiro passeio juntos, Paulo quer escolher uma trilha “fácil”. Segundo o seu critério, a trilha mais fácil é a que, em um dos sentidos do percurso, exige o menor esforço de subida. O esforço exigido em um trecho de subida é proporcional ao desnível do trecho.
Dadas as informações colhidas por Paulo sobre distâncias e altitudes de um conjunto de trilhas, você deve escrever um programa que determine qual é a trilha que exige o menor esforço de subida.
Entrada
A primeira linha da entrada contém um número inteiro N que indica o número de trilhas. Cada uma das N linhas seguintes contém a descrição de uma trilha (1 ≤ N ≤ 100). As trilhas são identificadas por números de 1 a N. A ordem em que as trilhas aparecem na entrada determina os seus identificadores (a primeira trilha é a de número 1, a segunda a de número 2, a última a de número N). A descrição de uma trilha inicia com um número inteiro M que indica a quantidade de pontos de medição da trilha (2 ≤ M ≤ 1000), seguido de M números inteiros Hi (0 ≤ Hi ≤ 1000) representando a altura dos pontos da trilha (medidos a intervalos regulares e iguais para todas as linhas). Paulo pode percorrer a trilha em qualquer sentido (ou seja, partindo do ponto de altitude H1 em direção ao ponto de altitude HM, ou partindo do ponto de altitude HM em direção ao ponto de altitude H1).
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
Seu programa deve produzir uma única linha na saída, contendo um número inteiro representando o identificador da melhor trilha, conforme determinado pelo seu programa. Em caso de empate entre duas ou mais trilhas, imprima a de menor identificador.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplos de Entrada Exemplos de Saída
5
4 498 500 498 498
10 60 60 70 70 70 70 80 90 90 100
5 200 190 180 170 160
2 1000 900
4 20 20 20 20
2
3
5 600 601 600 601 600
4 500 499 500 499
4 300 300 302 300
2
OBI - Olimpíada Brasileira de Informática 2005 Nível 1 |
1,283 | 2297 | Bafo | Muito Fácil | AD-HOC | Álbuns de figurinhas – sejam de times de futebol, princesas ou super-heróis – têm marcado gerações de crianças e adolescentes. Conseguir completar um álbum é uma tarefa muitas vezes árdua, envolvendo negociações com colegas para a troca de figurinhas. Mas a existência das figurinhas propicia uma outra brincadeira, que foi muito popular entre crianças no século passado: o jogo de bater figurinhas (o famoso “Bafo”). O jogo é muito simples, mas divertido (e muito competitivo). No início de uma partida, cada criança coloca em uma pilha um certo número de figurinhas. Uma partida é composta de rodadas; a cada rodada as crianças batem com a mão sobre a pilha de figurinhas, tentando virá-las com o vácuo formado pelo movimento da mão. As crianças jogam em turnos, até que a pilha de figurinhas esteja vazia. Ganha a partida a criança que conseguir virar mais figurinhas.
Aldo e Beto estão jogando bafo com todas as suas figurinhas e pediram sua ajuda para calcular quem é o vencedor.
Você deve escrever um programa que, dada a quantidade de figurinhas que Aldo e Beto viraram em cada rodada, determine qual dos dois é o vencedor.
Entrada
A entrada é composta de vários casos de teste, cada um correspondendo a uma partida entre Aldo e Beto. A primeira linha de um caso de teste contém um número inteiro R (1 ≤ R ≤ 1000) que indica quantas rodadas ocorreram na partida. Cada uma das R linhas seguintes contém dois inteiros, A e B (0 ≤ A, B ≤ 100), que correspondem, respectivamente, ao número de figurinhas que Aldo e Beto conseguiram virar naquela rodada. Em todos os casos de teste há um único vencedor (ou seja, não ocorre empate). O final da entrada é indicado por R = 0.
Saída
Para cada caso de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do caso de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter o nome do vencedor (Aldo ou Beto). A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
Exemplo de Entrada Exemplo de Saída
2
1 5
2 3
3
0 0
4 7
10 0
0
Teste 1
Beto
Teste 2
Aldo
OBI - Olimpíada Brasileira de Informática 2005 Nível 2 |
1,284 | 2298 | Mini-Poker | Fácil | AD-HOC | Mini-Poker é o nome de um jogo de cartas que é uma simplificação de Poker, um dos mais famosos jogos de cartas do mundo. Mini-Poker é jogado com um baralho normal de 52 cartas, com quatro naipes (copas, paus, espadas e ouro), cada naipe compreendendo treze cartas (Ás, 2, 3, 4, 5, 6, 7, 8, 9, 10, Valete, Dama, Rei).
No início do jogo, cada jogador recebe cinco cartas. O conjunto de cinco cartas vale um certo número de pontos, de acordo com as regras descritas abaixo. Diferentemente do jogo de Poker normal, em Mini-Poker o naipe das cartas é desconsiderado. Assim, para simplificar a descrição do jogo, vamos utilizar os números de 1 a 13 para identificar as cartas do baralho, na ordem dada acima. Uma outra diferença é que pode ocorrer empate entre mais de um vencedor; nesse caso os vencedores dividem o prêmio.
As regras para pontuação em Mini-Poker são as seguintes:
Se as cinco cartas estão em seqüência a partir da carta x (ou seja, os valores das cartas são x, x+1, x+2, x+3 e x+4), a pontuação é x+200 pontos. Por exemplo, se as cartas recebidas são 10, 9, 8, 11 e 12, a pontuação é 208 pontos.
Se há quatro cartas iguais x (uma quadra, ou seja, os valores das cartas são x, x, x, x e y), a pontuação é x+180 pontos. Por exemplo, se as cartas recebidas são 1, 1, 1, 10 e 1, a pontuação é 181 pontos.
Se há três cartas iguais x e duas outras cartas iguais y (uma trinca e um par, ou seja, os valores das cartas são x, x, x, y e y), a pontuação é x + 160 pontos. Por exemplo, se as cartas recebidas são 10, 4, 4, 10 e 4, a pontuação é 164 pontos.
Se há três cartas iguais x e duas outras cartas diferentes y e z (uma trinca, ou seja, os valores das cartas são x, x, x, y e z), a pontuação é x + 140 pontos. Por exemplo, se as cartas recebidas são 2, 3, 2, 2 e 13, a pontuação é 142 pontos.
Se há duas cartas iguais x, duas outras cartas iguais y (x != y) e uma outra carta distinta z (dois pares, ou seja, os valores das cartas são x, x, y, y e z), a pontuação é 3 × x + 2 × y + 20 pontos, em que x > y. Por exemplo, se as cartas recebidas são 12, 7, 12, 8 e 7, a pontuação é 70 pontos.
Se há apenas duas cartas iguais x e as outras são todas distintas (um par, ou seja, os valores das cartas são x, x, y, z e t), a pontuação é x pontos. Por exemplo, se as cartas recebidas são 12, 13, 5, 8 e 13, a pontuação é 13 pontos.
Se todas as cartas são distintas, não há pontuação.
Escreva um programa que, fornecidas as cartas dadas a um jogador, calcule pontuação do jogador naquela jogada.
Entrada
A entrada é composta por vários casos de teste, cada um correspondendo a uma jogada. A primeira linha da entrada contém um inteiro N que indica o número de casos de teste (1 ≤ N ≤ 100). Cada uma das N linhas seguintes contém cinco números inteiros C1,C2,C3,C4 e C5, representando as cinco cartas recebidas por um jogador (1 ≤ C1,C2,C3,C4,C5 ≤ 13).
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado)
Saída
Para cada caso de teste da entrada, seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do caso de teste, no formato “Teste n”, onde n é numerado seqüencialmente a partir de 1. A segunda linha deve conter a pontuação do jogador considerando as cinco cartas recebidas. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplo de Entrada Exemplo de Saída
2
12 3 10 3 12
1 2 3 5 4
Teste 1
62
Teste 2
201
OBI - Olimpíada Brasileira de Informática 2005 Nível 2 |
1,285 | 2299 | Pedido de Desculpas | Médio | PARADIGMAS | Cuca saiu para jogar futebol com os amigos e esqueceu do encontro que tinha com a namorada. Ciente da mancada, Cuca deseja elaborar um pedido especial de desculpas. Resolveu então enviar flores e usar o cartão da floricultura para escrever um pedido especial de desculpas.
Cuca buscou na internet um conjunto de frases bonitas contendo a palavra ‘desculpe’ (que pode ocorrer mais de uma vez na mesma frase). No entanto, o cartão da floricultura é pequeno, e nem todas as frases que Cuca colecionou poderão ser aproveitadas.
Cuca quer aproveitar o espaço do cartão, onde cabe um número limitado de caracteres, para escrever um sub-conjunto das frases coletadas de modo que apareça o máximo de vezes possível a palavra ‘desculpe’.
Escreva um programa que, dados o número de caracteres que cabem no cartão e a quantidade de frases coletadas (com os respectivos comprimentos e os números de ocorrências da palavra ‘desculpe’), determine o número máximo de vezes que a palavra aparece, utilizando apenas as frases colecionadas, sem repetí-las.
Entrada
A entrada é constituída de vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros C e F indicando respectivamente o comprimento do cartão em caracteres (8 ≤ C ≤ 1000) e o número de frases coletadas (1 ≤ F ≤50). Cada uma das F linhas seguintes descreve uma frase coletada. A descrição é composta por dois inteiros N e D que indicam respectivamente o número de caracteres na frase (8 <= N <= 200) e quantas vezes a palavra ‘desculpe’ ocorre na frase (1 ≤ D ≤ 25). O final da entrada é indicado por C = F = 0.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
Para cada caso de teste seu programa deve produzir três linhas na saída. A primeira identifica o conjunto de teste no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o máximo número de vezes que a palavra ‘desculpe’ pode aparecer no cartão, considerando que apenas frases coletadas podem ser utilizadas, e cada frase não é utilizada mais de uma vez. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplo de Entrada Exemplo de Saída
200 4
100 4
100 1
120 2
80 5
40 3
10 1
10 1
20 2
0 0
Teste 1
9
Teste 2
4
OBI - Olimpíada Brasileira de Informática 2005 Nível 2 |
1,286 | 2300 | Transmissão de Energia | Médio | GRAFOS | A distribuição de energia para as diversas regiões do país exige um investimento muito grande em linhas de transmissão e estações transformadoras. Uma linha de transmissão interliga duas estações transformadoras. Uma estação transformadora pode estar interligada a uma ou mais outras estações transformadoras, mas devido ao alto custo não pode haver mais de uma linha de transmissão interligando duas estações.
As estações transformadoras são interconectadas de forma a garantir que a energia possa ser distribuída entre qualquer par de estações. Uma rota de energia entre duas estações e1 e ek é definida como uma sequência (e1 , l1 , e2 , l2 , ...ek−1 , lk−1 , ek ) onde cada ei é uma estação transformadora e cada li é uma linha de transmissão que conecta ei ei+1.
Os engenheiros de manutenção do sistema de transmissão de energia consideram que o sistema está em estado normal se há pelo menos uma rota entre qualquer par de estações, e em estado de falha caso contrário.
Figura 1: Dois exemplos de sistemas de transmissão: (a) sistema em estado normal; (b) sistema em estado de falha.
Um grande tornado passou pelo país danificando algumas das linhas de transmissão, e os engenheiros de manutenção do sistema de transmissão de energia necessitam de sua ajuda.
Dada a configuração atual do sistema de transmissão de energia, descrevendo as interconexões existentes entre as estações, escreva um programa que determine o estado do sistema.
Entrada
A entrada é composta de vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros E e L indicando respectivamente o número de estações (3 ≤ E ≤ 100) e o número de linhas de transmissão do sistema (E − 1 ≤ L ≤ E × (E − 1)/2)que continuam em funcionamento após o tornado. As estações são identificadas por números de 1 a E. Cada uma das L linhas seguintes contém dois inteiros X e Y que indicam que existe uma linha de transmissão interligando a estação X à estação Y. O final da entrada é indicado por E = L = 0.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
Para cada caso de teste seu programa deve produzir três linhas na saída. A primeira identifica o conjunto de teste no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter a palavra “normal”, se, para cada par de estações, houver uma rota que as conecte, e a palavra “falha” caso não haja uma rota entre algum par de estações. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplo de Entrada Exemplo de Saída
6 7
1 2
2 3
3 4
4 5
5 6
6 2
1 5
4 3
1 2
4 2
1 4
0 0
Teste 1
normal
Teste 2
falha
OBI - Olimpíada Brasileira de Informática 2005 Nível 2 |
1,287 | 2301 | Vivo ou Morto | Médio | AD-HOC | Toda criança certamente já brincou de “vivo ou morto”. A brincadeira é dirigida por um “chefe” (um adulto), que comanda dois ou mais participantes (crianças). A brincadeira é composta de rodadas. No início, os participantes são organizados pelo chefe em fila única. A cada rodada o chefe grita “vivo” ou “morto” e todos os participantes tentam seguir sua ordem, levantando-se ao ouvir a palavra “vivo” ou abaixando-se ao ouvir a palavra “morto”. Um participante que não segue a ordem do chefe é eliminado, deixando o seu lugar na fila. Os participantes remanescentes agrupam-se novamente em fila única, preenchendo as posições dos participantes eliminados, mas mantendo suas posições relativas. O jogo continua até que uma rodada seja composta por exatamente um participante. Tal participante é dito o vencedor do jogo.
Por exemplo, considere que a brincadeira inicie com cinco participantes, identificados por números inteiros de 1 a 5, e que o chefe organize a fila na ordem m 3 → 2 → 1 → 4 → 5. Se na primeira rodada forem eliminados os participantes 2 e 4, a fila da segunda rodada será formada por 3 → 1 → 5; se na segunda rodada for eliminado o participante 1, a fila da terceira rodada será formada por 3 → 5. Se na terceira rodada o participante 3 for eliminado, o vencedor da brincadeira será o participante 5.
Sua tarefa é escrever um programa que determine o vencedor de uma partida de “vivo ou morto”, a partir da informação das ordens dadas pelo chefe e das ações executadas pelos participantes em cada rodada.
Entrada
A entrada é constituída de vários casos de teste, cada um representando uma partida. A primeira linha de um caso de teste contém dois números inteiros P e R indicando respectivamente a quantidade inicial de participantes (2 ≤ P ≤ 100) e quantidade de rodadas da partida (1 ≤ R ≤ 100). Os participantes são identificados por números de 1 a P. A segunda linha de um caso de teste descreve a fila organizada pelo chefe, contendo P números inteiros distintos x1, x2, . . . xP , onde x1 representa o identificador do participante no primeiro lugar na fila, x2 representa o identificador do participante no segundo lugar na fila, e assim por diante (1 ≤ xi ≤ P). Cada uma das R linhas seguintes representa uma rodada, contendo um número inteiro inteiro N indicando o número de participantes da rodada (2 ≤ N ≤ P), um número inteiro inteiro J representando a ordem dada pelo chefe (0 ≤ J ≤ 1) e N números inteiros Ai representando a ação do participante colocado na i-ésima posição na fila (0 ≤ Ai ≤ 1). Ordens e ações “vivo” são representadas pelo valor 1, ordens e ações “morto” pelo valor zero. Cada partida tem exatamente um vencedor, determinado somente na última rodada fornecida no caso de teste correspondente. O final da entrada é indicado por P = R = 0.
A entrada deve ser lida do dispositivo de entrada padrão (normalmente o teclado).
Saída
Para cada caso de teste seu programa deve produzir três linhas. A primeira identifica o conjunto de teste no formato “Teste n”, onde n é numerado a partir de 1. A segunda linha deve conter o identificador do vencedor. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
A saída deve ser escrita no dispositivo de saída padrão (normalmente a tela).
Exemplo de Entrada Exemplo de Saída
2 2
2 1
2 1 1 1
2 1 1 0
5 4
3 2 1 4 5
5 1 1 1 1 1 1
5 0 0 1 0 1 0
3 0 0 1 0
2 1 0 1
0 0
Teste 1
2
Teste 2
5
OBI - Olimpíada Brasileira de Informática 2005 Nível 2 |
1,288 | 2302 | Conversa não tão Secreta | Muito Difícil | AD-HOC | A polícia desconfia que dois homens que passeiam todos os dias pelo parque são na verdade criminosos. O parque é plano, de formato retangular, e estreitas faixas de grama o dividem em quadrados de mesmo tamanho, formando uma grade de N por M quadrados.
Os dois homens têm um comportamento curioso e suspeito em seu passeio: após encontrarem-se, conversam durante um minuto, andam mudando rapidamente de lugar, passando a ocupar um novo quadrado do parque, conversam mais um minuto, andam novamente (mudando de quadrado), conversam mais um minuto, e assim sucessivamente. A cada minuto escolhem uma direção (Norte, Sul, Leste ou Oeste) e andam até o quadrado imediatamente vizinho na direção escolhida.
Tentando escutar trechos das conversas dos homens, a polícia instalou um pequeno microfone multi-direcional em um dos quadrados do parque. O microfone é capaz de captar conversas realizadas no quadrado onde está instalado e em todos os quadrados imediatamente vizinhos.
Os dois homens sempre iniciam o passeio no quadrado de coordenadas (0,0).
Dadas as coordenadas do microfone e a sequência de movimentos que os dois homens realizaram durante seu passeio no parque, seu programa deve determinar quantos minutos de conversa foram captados pelo microfone.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha contém dois inteiros N e M que indicam respectivamente o número de linhas e o número de colunas do parque (0 ≤ N ≤ 1000000 e 0 ≤ M ≤ 1000000). A segunda linha contém dois inteiros X e Y que indicam a coordenada do microfone em termos de linhas e colunas (0 ≤ X ≤ N e 0 ≤ Y ≤ M). A terceira linha contém um inteiro K, indicando o número de quadrados pelos quais os dois homens passearam. A quarta linha contém K inteiros, entre 1, 2, 34, que indicam a rota tomada pelos dois homens durante o passeio; cada inteiro indica a direção tomada ao final de um minuto de conversa, com 1 representando o Leste, 2 representando o Oeste, 3 representando o Norte e 4 representando o Sul.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha contendo um inteiro: o número de minutos de conversação captados pelo microfone.
Exemplos de Entrada Exemplos de Saída
10 10
2 2
3
3 3 3
0
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 1 |
1,289 | 2303 | Margaridas | Fácil | AD-HOC | Leopoldo é gerente de uma plantação de flores da Associação de Cultivo de Margaridas (ACM), um grupo que cultiva margaridas em grandes propriedades para abastecer floriculturas em grandes cidades.
As margaridas são plantadas em vasos dispostos em linhas e colunas, formando uma espécie de grade. Na plantação administrada por Leopoldo existem L linhas de vasos de margaridas, cada uma formada por C vasos. Para facilitar o gerenciamento, os vasos são organizados em lotes de M linhas e N colunas de vasos, sendo que não existem sobreposições entre os lotes (não existe nenhuma linha ou coluna comum a mais de um lote) e todos os lotes têm exatamente M linhas e N colunas.
A colheita é sempre feita em um único lote, coletando-se todas as margaridas daquele lote que estejam prontas para a venda. Uma semana antes de fazer a colheita, os funcionários da plantação analisaram cada vaso e anotaram quantas margaridas estarão prontas para venda na semana seguinte. Leopoldo agora precisa da sua ajuda para determinar qual o número máximo de margaridas que poderá ser colhido em um único lote de M × N vasos.
Sua tarefa é escrever um programa que, dado um mapa da plantação contendo o número de margaridas prontas para venda em cada vaso, encontre qual o número máximo de margaridas que podem ser colhidos por Leopoldo.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém quatro números inteiros, L, C, M e N. L e C representam respectivamente o número de linhas (1 ≤ L ≤ 1000) e de colunas (1 ≤ C ≤ 1000) de vasos existentes na plantação. M e N representam respectivamente o número de linhas (1 ≤ M ≤ L) e de colunas (1 ≤ N ≤ C) dos lotes. As L linhas seguintes contêm C inteiros cada, representando número de margaridas prontas para colheita no vaso localizado naquela linha e coluna. Note que L M e C N são sempre inteiros, pois não há linha ou coluna de vasos que pertença a mais de um lote.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha que contém o número máximo de margaridas que podem ser colhidos em um lote de M × N. Esse número não pode ser superior a 1000000.
Exemplos de Entrada Exemplos de Saída
3 3 1 1
1 2 3
1 3 3
1 10 1
10
4 4 2 1
1 2 3 4
5 6 7 8
1 10 5 2
1 5 9 10
15
6 6 2 2
1 1 1 1 1 1
1 2 2 1 1 2
1 2 2 1 1 1
1 1 1 1 1 1
1 3 1 1 3 1
1 1 1 1 2 1
7
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 1 |
1,290 | 2304 | Banco Imobiliário | Muito Fácil | AD-HOC | Monopólio (conhecido no Brasil como Banco Imobiliário) é um dos jogos mais famosos do mundo, com 750 milhões de cópias vendidas. Durante o jogo, os jogadores podem comprar propriedades que estejam disponíveis, vendê-las para que elas voltem a ficar disponíveis, e cobrar aluguel pelo uso de uma determinada propriedade por outro jogador. O objetivo do jogo é acumular a maior quantidade de dinheiro possível.
O jogo é composto por um tabuleiro e um conjunto de cédulas de dinheiro. Três amigos, Dália, Elói e Félix, querem jogar uma partida de Monopólio, mas o irmãozinho menor de Dália escondeu as cédulas de dinheiro. Os três amigos decidiram jogar a partida assim mesmo, anotando em um papel todas as operações que ocorreram durante o jogo (compras, vendas e pagamentos de aluguéis). Assim que eles pararam de jogar, perceberam que levaria muito tempo para descobrir quanto dinheiro cada um acumulou. Eles então pediram sua ajuda para determinar esses valores.
Sua tarefa é escrever um programa que, a partir dos registros de jogadas realizados pelos três jogadores, determine a quantidade de dinheiro acumulada por cada um dos jogadores.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros, I e N que indicam respectivamente as quantias de dinheiro que Dália, Elói e Félix possuem no início do jogo (1 ≤ I ≤ 1000000) e o número de operações realizadas durante o jogo (1 ≤ N ≤ 10000). Note que os três jogadores iniciam a partida com a mesma quantidade de dinheiro. Os jogadores são representados na entrada sempre pela letra inicial de seu nome (‘D’, ‘E’ ou ‘F’). As N linhas contém as operações ocorridas durante o jogo. Cada linha pode ter um dos formatos abaixo:
Compra — a letra C, seguida da letra inicial de um jogador J e de um inteiro X que representa o valor gasto por J na compra (0 < X ≤ 1000000). Exemplo: ‘C D 1000’.
Venda — a letra V, seguida da letra inicial de um jogador J e de um inteiro X que representa o valor recebido por J na venda (0 < X ≤ 1000000). Exemplo: ‘V E 200’.
Aluguel — a letra A, seguida da letra inicial de um jogador J que recebe o aluguel, da letra inicial do jogador K que paga o aluguel e de um inteiro X que representa o valor do aluguel (J != K e 0 ≤ X ≤ 1000000). Exemplo: ‘A F D 500’.
Os valores intermediários e totais acumulados por cada jogador estão entre 0 e 1000000.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha composta de três inteiros que correspondem à quantidade de dinheiro acumulada por Dália, Elói e Félix, nesta ordem.
Exemplos de Entrada Exemplos de Saída
1000 1
C D 500
500 1000 1000
1000 3
C D 100
V E 200
A D F 1000
1900 1200 0
10000 5
C D 5000
C E 3000
A D F 1000
V E 4000
A F E 1000
6000 10000 10000
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 1 |
1,291 | 2305 | Colheita de Caju | Médio | AD-HOC | Conrado é gerente em uma das fazendas de plantação de caju da Sociedade de Beneficiamento de Caju (SBC), um grupo que cultiva caju em grandes propriedades para o mercado externo.
Os cajueiros são plantados dispostos em linhas e colunas, formando uma espécie de grade. Na fazenda administrada por Conrado existem L linhas de cajueiros, cada uma formada por C colunas. Nesta semana Conrado deve executar a colheita da produção de um subconjunto contínuo de cajueiros. Esse subconjunto é formado por M linhas e N colunas de cajueiros. Há uma semana, seus funcionários analisaram cada cajueiro da fazenda e estimaram a sua produtividade em número de cajus prontos para a colheita. Conrado agora precisa da sua ajuda para determinar qual a produtividade máxima estimada (em número de cajus) de uma área de M × N cajueiros.
Sua tarefa é escrever um programa que, dado um mapa da fazenda contendo o número de cajus prontos para colheita em cada cajueiro, encontre qual o número máximo de cajus que podem ser colhidos na fazenda em uma área de M × N cajueiros.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém quatro números inteiros, L, C, M e N. L e C representam, respectivamente, o número de linhas (1 ≤ L ≤ 1000) e de colunas (1 ≤ C ≤ 1000) de cajueiros existentes na fazenda. M e N representam, respectivamente, o número de linhas (1 ≤ M ≤ L) e de colunas (1 ≤ N ≤ C) de cajueiros a serem colhidos. As L linhas seguintes contêm C inteiros cada, representando número de cajus prontos para colheita no cajueiro localizado naquela linha e coluna.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha que contém o número máximo estimado de cajus que podem ser colhidos em uma área contínua de M × N. Esse número não será superior a 1000000.
Exemplos de Entrada Exemplos de Saída
3 3 1 1
1 2 3
1 3 3
1 10 1
10
4 4 2 1
1 2 3 4
5 6 7 8
1 10 5 2
1 5 9 10
16
5 5 2 2
1 1 1 3 1
1 2 1 1 1
1 1 1 2 1
1 1 2 1 1
1 3 1 1 3
7
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 2 |
1,292 | 2306 | Escada Perfeita | Fácil | AD-HOC | Uma construtora, durante a criação de um parque temático, encontrou no terreno um conjunto de vários pilhas de cubos de pedra. Ao invés de pagar pela remoção dos cubos de pedras, um dos arquitetos da empresa achou interessante utilizar as pedras para decoração do parque, determinando que as pedras fossem rearranjadas no formato de “escada”. Para isso, os funcionários deveriam mover alguns cubos para formar os degraus das escadas. Só que o arquiteto decidiu que, entre uma pilha e outra de pedras deveria haver exatamente uma pedra de diferença, formando o que ele chamou de escada perfeita. O exemplo abaixo mostra um conjunto de cinco pilhas de pedras encontradas e as cinco pilhas como ficaram ap´os a arrumação em escada perfeita.
Dada uma sequência de pilhas de cubos de pedras com suas respectivas alturas, você deve determinar o número mínimo de pedras que precisam ser movidas para formar uma escada perfeita com exatamente o mesmo número de pilhas de pedras encontrado inicialmente (ou seja, não devem ser criadas ou eliminadas pilhas de pedras). O degrau mais baixo da escada deve sempre estar do lado esquerdo.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha contém um inteiro N que indica o número de pilhas de pedras. A segunda linha contém N números inteiros que indicam a quantidade de cubos de pedras em cada uma das pilhas, da esquerda para a direita.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo um inteiro: o número mínimo de cubos de pedras que devem ser movidos para transformar o conjunto de pilhas em uma escada perfeita, conforme calculado pelo seu programa. Caso não seja possível efetuar a transformação em escada perfeita, imprima como resultado o valor -1.
Exemplos de Entrada Exemplos de Saída
5
5 4 5 4 2
5
6
9 8 7 6 5 4
9
2
1 5
-1
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 2 |
1,293 | 2307 | Jogo de Cartas | Difícil | AD-HOC | Marlene está jogando um passatempo de sua autoria. Ela possui um baralho com N cartas, numeradas de 1 a N, tal que não existem duas cartas com o mesmo número. O jogo consiste de várias rodadas, e são utilizadas três pilhas denominadas Compra, Descarte e Morto. Inicialmente, as cartas são embaralhadas e colocadas com a face para cima, constituindo a pilha Compra (as pilhas Descarte e Morto est˜ao inicialmente vazias). Marlene então tira as cartas da pilha Compra, uma a uma, e as coloca na pilha Descarte, com as faces para baixo, na mesma ordem, até encontrar a carta com o número 1. Quando a encontra, Marlene a coloca na pilha Morto e recomeça o processo de retirar cartas da pilha Compra, agora procurando a próxima carta na sequência (2), e o processo é repetido para as outras cartas na sequência (3, 4, ...).
Quando as cartas da pilha Compra terminam, encerra-se uma rodada. Nesse momento, Marlene vira a pilha Descarte de modo que as cartas fiquem com a face para cima (sem reembaralhar) e a coloca no lugar da pilha Compra. Inicia-se uma nova rodada, e processo recomeça, com Marlene procurando a próxima carta na sequência.
Repete-se esse processo até que a carta removida do baralho seja a de número N, quando o jogo acaba. O resultado do jogo é o número de rodadas.
Escreva um programa que, dada a ordem em que as cartas estÃo na pilha Compra no inÍcio do jogo, determine o resultado do jogo (ou seja, o número de rodadas).
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica quantas cartas existem no baralho (1 ≤ N ≤ 100000). A segunda linha contém N inteiros, representando as cartas do baralho, na sequência em que serão tiradas por Marlene da pilha Compras.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o número de vezes que Marlene terá que descartar as cartas durante o jogo.
Exemplos de Entrada Exemplos de Saída
3
2 1 3
2
5
3 5 1 4 2
3
7
3 6 7 1 5 4 2
4
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 2 |
1,294 | 2308 | Museu | Muito Difícil | AD-HOC | Desde que o arquiteto Frank Gehry projetou o Museu Guggenheim de Bilbao, os museus têm sido construídos com formas cada vez mais complexas, fugindo de padrões pré-estabelecidos e de simetrias. Um típico museu moderno é composto por um conjuto de salas ligadas por corredores e escadas, sem preocupação com a prédefinição de caminhos a serem seguidos pelas pessoas.
Henriqueta é uma professora do ensino fundamental que deseja visitar o museu da Ordem Brasileira de Medicina (OBM) para mostrar aos seus alunos de ciências como o corpo humano funciona e como as cirurgias eram feitas nos séculos XIX e XX. Henriqueta quer planejar uma visita pelas salas do museu, obedecento as seguintes restrições:
a visita deve começar e terminar em uma mesma sala;
exceto a sala de partida, nenhuma sala do museu pode ser visitada mais de uma vez;
a visita deve incluir pelo menos duas salas;
os corredores são unidirecionais, ou seja, as pessoas podem caminhar, em um corredor, apenas em uma direção.
a visita deve tomar o menor tempo possível.
Um estudo preliminar, realizado pelo próprio museu, indica o tempo médio que cada visitante fica em uma sala e quanto tempo leva-se para atravessar um corredor ou uma escada. Henriqueta quer a sua ajuda para calcular o tempo total da menor visita que ela pode efetuar, obedecendo as restrições dadas.
Escreva um programa que, dados um conjunto de salas, um conjunto de corredores e escadas que ligam essas salas e o tempo necessário para percorrer cada sala e cada corredor, determine qual é o menor tempo possível para uma visita. Note que o tempo de visita da sala onde a visita se inicia deve ser contado apenas uma vez.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém dois inteiros S e C, que indicam, respectivamente, o número de salas (1 ≤ S ≤ 1000) e o número de corredores e escadas (1 ≤ C ≤ 1000). As salas são numeradas de 1 a S. A segunda linha contém S inteiros representando o tempo gasto para percorrer cada sala. Cada uma das C linhas seguintes descreve um corredor ou escada. A descrição ´e composta por três inteiros, I, F e T , indicando que o corredor somente pode ser percorrido da sala I (1 ≤ I ≤ N) para a sala F (1 ≤ F ≤ N) no tempo T (1 ≤ T ≤ 1000). O tempo total máximo é sempre menor ou igual a 1000000.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha contendo o tempo gasto na visita de menor duração que Henriqueta pode realizar no museu. Existe pelo menos uma visita que atende as restrições impostas.
Exemplos de Entrada Exemplos de Saída
2 2
1 1
1 2 1
2 1 3
6
5 6
5 5 10 10 5
1 2 1
2 3 1
5 1 1
3 4 1
4 1 1
5 2 1
34
8 10
3 10 8 4 1 1 8 1
1 2 1
1 3 10
4 1 1
5 8 1
3 7 1
7 5 2
8 4 2
2 3 2
3 6 1
6 7 2
42
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 2 |
1,295 | 2309 | Truco | Fácil | AD-HOC | Truco é um jogo de cartas que pode ser jogado por duas ou mais pessoas. Existem diversas variações: o Truco Cego ou Truco Espanhol (popular no sul do Brasil, Argentina, Uruguai e outros países), o Truco Paulista, Capixaba ou Mineiro (variações populares no Brasil), o Truco Índio e o Truco Eteviano. Em geral, é uma disputa de três rodadas (“melhor de três”) para ver quem tem as cartas mais “fortes” (de valor simbólico mais alto).
Adalberto e Bernardete estão jogando uma variação de truco com 40 cartas (foram retirados do baralho todas as cartas de valor 8, 9 e 10, além dos coringas), e o valor simbólico independente do naipe da carta. A ordem de valor simbólico das cartas nessa variação de truco é mostrada abaixo, ordenada da mais “fraca” (mais à esquerda) para a mais “forte” (mais à direita)
4 5 6 7 Q J K A 2 3
Cada partida é disputada em três rodadas. A cada rodada, os jogadores escolhem uma das cartas para mostrar, e vence aquele que tiver a carta com o maior valor simbólico. Em caso de empate (ou seja, os dois apresentarem cartas com os mesmos valores simbólicos), Adalberto vence, pois é mais velho que Bernardete. Vence a partida aquele que vencer o maior número de rodadas.
Depois de algumas partidas, Adalberto e Bernardete estão com dificuldades para saber quem venceu mais partidas, e pediram a sua ajuda.
Sua tarefa é escrever um programa que calcule o número de partidas que cada um dos competidores (Adalberto e Bernardete) venceram.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da saída possui um inteiro N que indica o número de partidas disputadas entre Adalberto e Bernardete (1 ≤ N ≤ 1000000). As N linhas seguintes contêm cada uma seis inteiros, A1, A2, A3, B1, B2 e B3 , que correspondem às três cartas apresentadas por Adalberto nas rodadas 1, 2 e 3 daquela partida (A1, A2, A3 ∈ {1, 2, 3, 4, 5, 6, 7, 11, 12, 13}), seguidas pelas três cartas apresentadas por Bernardete nas rodadas 1, 2 e 3 da mesma partida (B1, B2, B3 ∈ {1, 2, 3, 4, 5, 6, 7, 11, 12, 13}). Na entrada, o número 1 representa o Ás (A), 11 representa o Valete (J), 12 representa a Dama (Q) e 13 representa o Rei (K).
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, que contém os números de partidas vencidas por Adalberto e por Bernadete, nessa ordem, separados por espaços.
Exemplos de Entrada Exemplos de Saída
1
1 2 3 1 3 2
1 0
2
1 5 6 6 3 4
5 6 2 11 13 12
1 1
5
1 2 11 12 7 6
3 5 1 13 1 4
4 5 7 11 12 13
1 5 6 3 5 2
5 6 7 4 5 2
3 2
OBI - Olimpíada Brasileira de Informática 2006 Fase 1 Nível 2 |
1,296 | 2310 | Voleibol | Muito Fácil | INICIANTE | Um treinador de voleibol gostaria de manter estatísticas sobre sua equipe. A cada jogo, seu auxiliar anota quantas tentativas de saques, bloqueios e ataques cada um de seus jogadores fez, bem como quantos desses saques, bloqueios e ataques tiveram sucesso (resultaram em pontos). Seu programa deve mostrar qual o percentual de saques, bloqueios e ataques do time todo tiveram sucesso.
Entrada
A entrada é dada pelo número de jogadores N (1 ≤ N ≤ 100), seguido pelo nome de cada um dos jogadores. Abaixo do nome de cada jogador, seguem duas linhas com três inteiros cada. Na primeira linha S, B e A (0 ≤ S,B,A ≤ 10000) representam a quantidade de tentativas de saques, bloqueios e ataques e na segunda linha, S1, B1 e A1 (0 ≤ S1 ≤ S; 0 ≤ B1 ≤ B; 0 ≤ A1 ≤ A) com o número de saques, bloqueios e ataques deste jogador que tiveram sucesso.
Saída
A saída deve conter o percentual total de saques, bloqueios e ataques do time todo que resultaram em pontos, conforme mostrado no exemplo.
Exemplo de Entrada Exemplo de Saída
3
Renan
10 20 12
1 10 9
Jonas
8 7 1
2 7 0
Edson
3 3 3
1 2 3
Pontos de Saque: 19.05 %.
Pontos de Bloqueio: 63.33 %.
Pontos de Ataque: 75.00 %. |
1,297 | 2311 | Saltos Ornamentais | Muito Fácil | INICIANTE | Em uma determinada competição de saltos ornamentais, cada salto recebe um grau de dificuldade e é avaliado por sete juízes. Após cada salto, os juízes, que não se comunicam uns com os outros, mostram suas notas. Um salto é cotado entre zero e dez pontos. Depois de apresentadas as notas, a mais alta e a mais baixa são descartadas. O restante é somado e multiplicado pelo grau de dificuldade do salto, que gira entre 1,2 e 3,8, definido sempre antes do início da apresentação do atleta. O julgamento então é feito da seguinte forma: supondo que um saltador tenha sua nota de partida (seu grau de dificuldade de movimento) avaliada em 2,0 e tire notas 6,0, 5,0, 5,0, 5,0, 5,0, 5,0, 4,0 em sua execução. Disso, retira-se a nota mais baixa e a mais alta, o que gera um resultado parcial de 25,0. Então, pega-se a nota de execução e multiplica-a pela nota de partida para se chegar ao resultado final, que neste exemplo é de 50,0. Seu programa deve apresentar o resultado de uma competição de acordo com estas regras.
Entrada
A primeira linha de entrada contém o número de competidoresN (0 ≤ N ≤ 100). A seguir são mostrados os nomes de cada um dos competidores seguidos pelo grau de dificuldade dos seus saltos GD (1.2 ≤ GD ≤ 3.8) e, a seguir, na linha seguinte, as 7 notas recebidas N1 a N7 (0 ≤ N1 a N7 ≤ 10).
Saída
A saída deve apresentar o resultado da competição, com o nome dos competidores seguido de seu resultado, na ordem em que os dados foram lidos.
Exemplo de Entrada Exemplo de Saída
3
Gabriela
2.0
6.0 5.0 5.0 5.0 5.0 5.0 4.0
Marina
1.5
8.5 7.0 8.0 8.0 8.4 7.5 7.7
Mafalda
3.0
6.0 7.0 6.5 6.8 7.9 6.2 6.6
Gabriela 50.00
Marina 59.40
Mafalda 99.30 |
1,298 | 2312 | Quadro De Medalhas | Fácil | AD-HOC | Alguém deixou o quadro de medalhas das olimpíadas fora de ordem. Seu programa deve colocá-lo na ordem correta. A ordem dos países no quadro de medalhas é dada pelo número de medalhas de ouro. Se há empate em medalhas de ouro, a nação que tiver mais medalhas de prata fica a frente. Havendo empate em medalhas de ouro e prata, fica mais bem colocado o país com mais medalhas de bronze. Se dois ou mais países empatarem nos três tipos de medalhas, seu programa deve mostrá-los em ordem alfabética.
Entrada
A entrada é dada pelo número de países participantes N (0 ≤ N ≤ 500) seguido pela lista dos países, com suas medalhas de ouro O (0 ≤ O ≤ 10000), prata P (0 ≤ P ≤ 10000) e bronze B (0 ≤ B ≤ 10000).
Saída
A saída deve ser a lista de países, com suas medalhas de ouro, prata e bronze, na ordem correta do quadro de medalhas, com as nações mais premiadas aparecendo primeiro.
Exemplo de Entrada Exemplo de Saída
8
Belgica 2 2 2
Brasil 7 6 6
Franca 10 18 14
Italia 8 12 8
Australia 8 11 10
Colombia 3 2 3
Suica 3 2 2
Tailandia 2 2 2
Franca 10 18 14
Italia 8 12 8
Australia 8 11 10
Brasil 7 6 6
Colombia 3 2 3
Suica 3 2 2
Belgica 2 2 2
Tailandia 2 2 2 |
1,299 | 2313 | Qual Triângulo | Fácil | INICIANTE | Dados três valores, verifique se os três podem formar um triângulo. Em caso afirmativo, verifique se ele é escaleno, isóceles ou equilátero e se trata-se de um triângulo retângulo ou não.
Entrada
A entrada consiste em três números inteiros A,B e C (0 < A,B,C < 105).
Saída
A saída deve conter a string "Invalido" se os valores lidos não formarem um triângulo. Se os valores formarem um triângulo a saída deve ser "Valido-Equilatero", "Valido-Escaleno" ou "Valido-Isoceles" de acordo com a característica do triângulo seguido de "Retangulo: S" se o triângulo for retângulo ou "Retangulo: N" se não for, conforme os exemplos.
Exemplos de Entrada Exemplos de Saída
4 6 2
Invalido
4 3 3
Valido-Isoceles
Retangulo: N
3 4 5
Valido-Escaleno
Retangulo: S |
Subsets and Splits
Random Sample Across Categories
Selects a random sample of up to 4 questions from each category and difficulty level, providing a basic overview without deep insight.