Codeforces Round #322 (Div. 2)

比赛结果过后才开始做，要是比赛当时估计还做不出这么多。。。

A. Vasya the Hipster

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

One day Vasya the Hipster decided to count how many socks he had. It turned out that he had ared socks and b blue socks.

According to the latest fashion, hipsters should wear the socks of different colors: a red one on the left foot, a blue one on the right foot.

Every day Vasya puts on new socks in the morning and throws them away before going to bed as he doesn't want to wash them.

Vasya wonders, what is the maximum number of days when he can dress fashionable and wear different socks, and after that, for how many days he can then wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.

Can you help him?

Input

The single line of the input contains two positive integers a and b (1 ≤ a, b ≤ 100) — the number of red and blue socks that Vasya's got.

Output

Print two space-separated integers — the maximum number of days when Vasya can wear different socks and the number of days when he can wear the same socks until he either runs out of socks or cannot make a single pair from the socks he's got.

Keep in mind that at the end of the day Vasya throws away the socks that he's been wearing on that day.

Sample test(s)

input

3 1

output

1 1

input

2 3

output

2 0

input

7 3

output

3 2

Note

In the first sample Vasya can first put on one pair of different socks, after that he has two red socks left to wear on the second day.

题意：有a双红袜子，b双蓝袜子，开始每一个都是穿相反颜色的袜子，
穿完一天后就把袜子扔掉，之后没有相反颜色的袜子时候，开始穿相同
颜色的袜子，问这些袜子最多能穿几天？
思路：纯水题，直接模拟。
代码：

Time:31 ms Memory:0 KB
#include<iostream>
using namespace std;
int main()
{
	int a, b;
	cin >> a >> b;
	if (a > b)
	{
		cout << b << ' ' << (a - b) / 2 << endl;
	}
	else if (a == b)
	{
		cout << a << ' '<<0 << endl;
	}
	else
	{
		cout << a << ' ' << (b - a) / 2 << endl;
	}
	return 0;
}

B. Luxurious Houses

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

The capital of Berland has n multifloor buildings. The architect who built up the capital was very creative, so all the houses were built in one row.

Let's enumerate all the houses from left to right, starting with one. A house is considered to beluxurious if the number of floors in it is strictly greater than in all the houses with larger numbers. In other words, a house is luxurious if the number of floors in it is strictly greater than in all the houses, which are located to the right from it. In this task it is assumed that the heights of floors in the houses are the same.

The new architect is interested in n questions, i-th of them is about the following: "how many floors should be added to the i-th house to make it luxurious?" (for all i from 1 to n, inclusive). You need to help him cope with this task.

Note that all these questions are independent from each other — the answer to the question for house i does not affect other answers (i.e., the floors to the houses are not actually added).

Input

The first line of the input contains a single number n (1 ≤ n ≤ 105) — the number of houses in the capital of Berland.

The second line contains n space-separated positive integers hi (1 ≤ hi ≤ 109), where hi equals the number of floors in the i-th house.

Output

Print n integers a1, a2, ..., an, where number ai is the number of floors that need to be added to the house number i to make it luxurious. If the house is already luxurious and nothing needs to be added to it, then ai should be equal to zero.

All houses are numbered from left to right, starting from one.

Sample test(s)

input

5
1 2 3 1 2

output

3 2 0 2 0 

input

4
3 2 1 4

output

2 3 4 0 

题意：有n个楼房，每个楼房都要比它后面的楼房要高。
问每个楼房最少要增加的层数（大于等于0）
思路：一开始死活没读懂。以为是要比加了之后的楼层高，
看了题解发现并不是，只要不没加之前的高就行。
就是在原数组中操作，找比第i个位置之后的最高的楼层+1即可。

Time:156 ms  Memory:800 KB
#include<iostream>
using namespace std;
const int MAXN = 100005;
int h[MAXN], add[MAXN];
int main()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> h[i];
	}
	int MAXH = 0;
	for (int i = n; i > 0; i--)
	{
		if (h[i] > MAXH)//出现新的最高楼层
		{
			add[i] = 0;//因为本身是当前的最高楼层，所以不需要增加楼层
			MAXH = h[i];//更新最高楼层
		}
		else//否则
		{
			add[i] = MAXH - h[i] + 1;//要比当前最高楼层高
		}
	}
	for (int i = 1; i <= n; i++)
	{
		cout << add[i];
		if (i != n)
		{
			cout << ' ';
		}
	}
	return 0;
}

C. Developing Skills

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Petya loves computer games. Finally a game that he's been waiting for so long came out!

The main character of this game has n different skills, each of which is characterized by an integer ai from 0 to 100. The higher the number ai is, the higher is the i-th skill of the character. The total rating of the character is calculated as the sum of the values ​​of  for all i from 1 ton. The expression ⌊ x⌋ denotes the result of rounding the number x down to the nearest integer.

At the beginning of the game Petya got k improvement units as a bonus that he can use to increase the skills of his character and his total rating. One improvement unit can increase any skill of Petya's character by exactly one. For example, if a4 = 46, after using one imporvement unit to this skill, it becomes equal to 47. A hero's skill cannot rise higher more than 100. Thus, it is permissible that some of the units will remain unused.

Your task is to determine the optimal way of using the improvement units so as to maximize the overall rating of the character. It is not necessary to use all the improvement units.

Input

The first line of the input contains two positive integers n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 107) — the number of skills of the character and the number of units of improvements at Petya's disposal.

The second line of the input contains a sequence of n integers ai (0 ≤ ai ≤ 100), where aicharacterizes the level of the i-th skill of the character.

Output

The first line of the output should contain a single non-negative integer — the maximum total rating of the character that Petya can get using k or less improvement units.

Sample test(s)

input

2 4
7 9

output

2

input

3 8
17 15 19

output

5

input

2 2
99 100

output

20

Note

In the first test case the optimal strategy is as follows. Petya has to improve the first skill to 10 by spending 3 improvement units, and the second skill to 10, by spending one improvement unit. Thus, Petya spends all his improvement units and the total rating of the character becomes equal to lfloor frac{100}{10} rfloor +  lfloor frac{100}{10} rfloor = 10 + 10 =  20.

In the second test the optimal strategy for Petya is to improve the first skill to 20 (by spending 3 improvement units) and to improve the third skill to 20 (in this case by spending 1 improvement units). Thus, Petya is left with 4 improvement units and he will be able to increase the second skill to 19 (which does not change the overall rating, so Petya does not necessarily have to do it). Therefore, the highest possible total rating in this example is .

In the third test case the optimal strategy for Petya is to increase the first skill to 100 by spending 1 improvement unit. Thereafter, both skills of the character will be equal to 100, so Petya will not be able to spend the remaining improvement unit. So the answer is equal to .

C-C:
题意：有n个技能，和k个技能点。k个技能点可以随机分配到n个技能中
但是每个技能不能超过100，每个技能能获得的收益为=技能值/10，取整
问最后能获得的最大收益。
思路：对于k个技能点要怎么分配，优先分配到能凑成整数的技能，即技能
值的个位数越大越优先。然后还有注意下是否超出总上限(每个技能的上限)
贪心(优先队列)或者数组模拟都行。

Time:78 ms  Memory:1400 KB
#include<iostream>
#include<queue>
using namespace std;
const int MAXN = 100005;
priority_queue<int>Q;
int Min(int a, int b)
{
	return a > b ? b : a;
}
int main()
{
	int n, k, a, sum = 0;
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
	{
		cin >> a;
		sum += a / 10;//预先计算原技能能的收益
		Q.push(a % 10);//取技能值的个位数，加入优先队列
	}
	while (!Q.empty())
	{
		a = Q.top();
		Q.pop();
		if (k >= 10 - a)//够让技能凑成10
		{
			k -= (10 - a);//减去消耗的技能点
			sum++;//收益+1
		}
		else//否则退出，因为后面的元素比当前的更小,无需再判断
		{
			k = 0;
			break;
		}
	}
	//循环结束，可能k还没用完，那么就可以随机分配了，因为各个技能都是10的倍数了
	//无论给哪个技能加都一样，主要判断是否超出上限即可。
	sum += Min((k / 10), ((10 * n) - sum));
	//判断是否超过了总上限，总上限为:当n个都是100时，即n*100/10.
	cout << sum << endl;
	return 0;
}