2016-2017 ACM-ICPC, NEERC, Southern Subregional Contest A. Toda 2

A. Toda 2

time limit per test

2 seconds

memory limit per test

512 megabytes

input

standard input

output

standard output

A group of n friends enjoys playing popular video game Toda 2. There is a rating system describing skill level of each player, initially the rating of the i-th friend is r_i.

The friends decided to take part in the championship as a team. But they should have equal ratings to be allowed to compose a single team consisting of all n friends. So the friends are faced with the problem: how to make all their ratings equal.

One way to change ratings is to willingly lose in some matches. Friends can form a party consisting of two to five (but not more than n) friends and play a match in the game. When the party loses, the rating of each of its members decreases by 1. A rating can't become negative, sor_i = 0 doesn't change after losing.

The friends can take part in multiple matches, each time making a party from any subset of friends (but remember about constraints on party size: from 2 to 5 members).

The friends want to make their ratings equal but as high as possible.

Help the friends develop a strategy of losing the matches so that all their ratings become equal and the resulting rating is maximum possible.

Input

The first line contains a single integer n (2 ≤ n ≤ 100) — the number of friends.

The second line contains n non-negative integers r₁, r₂, ..., r_n (0 ≤ r_i ≤ 100), where r_i is the initial rating of the i-th friend.

Output

In the first line, print a single integer R — the final rating of each of the friends.

In the second line, print integer t — the number of matches the friends have to play. Each of the following t lines should contain n characters '0' or '1', where the j-th character of the i-th line is equal to:

• '0', if friend j should not play in match i,
• '1', if friend j should play in match i.

Each line should contain between two and five characters '1', inclusive.

The value t should not exceed 10⁴, it is guaranteed that such solution exists.

Remember that you shouldn't minimize the value t, but you should maximize R. If there are multiple solutions, print any of them.

Examples

input

5
4 5 1 7 4

output

1
8
01010
00011
01010
10010
00011
11000
00011
11000

input

2
1 2

output

0
2
11
11

input

3
1 1 1

output

1
0

 

题目意思：有n个人，他们的分数分别是下面的数字，现在我们要把他们的分数降低为一样的，步骤是，选取2-5个人一起打比赛，被选出来打比赛的人都会掉一分，如果本身的分数已经为0则不会再降低。要求，最后大家的分数尽可能高。

思路：确实是一道贪心的题目，其实只需要两两配对最终肯定可以把全部人配成一样的分数，但是就保证不了最终的分数尽可能高了，比如1 4 4 4。所以我们需要把三个一起掉分的情况也要考虑进来。这道题其实分析起来，可以逆向来想的，比如1 4 4 4，我们假定最低分就是1，那么一共是要减去9分（三个4-1），这对2来说是做不到取整的，必须要用3，那么三次都把三个人放进来打比赛就变成1 1 1 1了。而且，除了1之外的任何一个正整数都是可以用2 3 凑出来的，如果这个数字是奇数，那么它减去3后剩下的就是偶数，后面就可以两两配对用常规贪心选两个最大就好，不用管了。

最后定型的方法为：判断是否全部相等，若不相等则找出最大值，找出最大值后再找出有多少个也是最大值的数字，记为cnt。如果cnt为1则再选取出第二大的数，两个都操作一次，如果cnt为奇数且不为1，那么就先取三个操作一次，剩下的也是最大值的数字则两两操作。如果cnt为偶数，那么就循环一下，两两操作。然后回到判定是否全部相等，循环下去。

代码如下：

#include<cstdio>
#include<algorithm>
using namespace std;
int s[10005][105] = {0};
int a[105];
int n, i, j, cnt, ppp;

bool cmp(int a, int b)
{
	return a > b;
}

void dfs()
{
	int Max = 0, i, cnt = 0, k = 0, pos;
	int tmp[105];
	for(i = 0; i < n; i++)
		Max = max(a[i], Max);
	for(i = 0; i < n; i++)
		if(a[i] == Max)
		{
			cnt++;
			tmp[k++] = i;
		}
	if(cnt == n)
		return;
	if(cnt == 1)
	{
		Max = 0;
		for(i = 0; i < n; i++)
			if(i != tmp[0] && a[i] > Max)
			{
				Max = a[i];
				pos = i;
			}
		s[ppp][tmp[0]] = s[ppp][pos] = 1;
		ppp++;
		if(a[tmp[0]])
			a[tmp[0]]--;
		if(a[pos])
			a[pos]--;
	}
	else if(cnt & 1)
	{
		s[ppp][tmp[0]] = s[ppp][tmp[1]] = s[ppp][tmp[2]] = 1;
		ppp++;
		for(i = 3; i < cnt; i += 2, ppp++)
		{
			s[ppp][tmp[i]] = s[ppp][tmp[i + 1]] = 1;
		}
		for(i = 0; i < cnt; i++)
			if(a[tmp[i]])
				a[tmp[i]]--;
	}
	else
	{
		for(i = 0; i < cnt; i += 2, ppp++)
		{
			s[ppp][tmp[i]] = s[ppp][tmp[i + 1]] = 1;
		}
		for(i = 0; i < cnt; i++)
			if(a[tmp[i]])
				a[tmp[i]]--;
	}
	dfs();
}

int main()
{
	scanf("%d", &n);
	for(i = 0; i < n; i++)
		scanf("%d", &a[i]);
	ppp = 0;
	dfs(); 
	printf("%d\n", a[0]);
	printf("%d\n", ppp);
	for(i = 0; i < ppp; i++)
	{
		for(j = 0; j < n; j++)
			printf("%d", s[i][j]);
		printf("\n");
	}
	return 0;
}

这道题也不需要用sort了，因为快排n*logn还不如线性遍历一次快呢。