【Codeforces Round 274 (Div 2)B】【贪心】Towers 若干次移数后使得最大差值尽可能小

B. Towers

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

As you know, all the kids in Berland love playing with cubes. Little Petya has n towers consisting of cubes of the same size. Tower with number i consists of a_i cubes stacked one on top of the other. Petya defines the instability of a set of towers as a value equal to the difference between the heights of the highest and the lowest of the towers. For example, if Petya built five cube towers with heights (8, 3, 2, 6, 3), the instability of this set is equal to 6 (the highest tower has height 8, the lowest one has height 2).

The boy wants the instability of his set of towers to be as low as possible. All he can do is to perform the following operation several times: take the top cube from some tower and put it on top of some other tower of his set. Please note that Petya would never put the cube on the same tower from which it was removed because he thinks it's a waste of time.

Before going to school, the boy will have time to perform no more than k such operations. Petya does not want to be late for class, so you have to help him accomplish this task.

Input

The first line contains two space-separated positive integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1000) — the number of towers in the given set and the maximum number of operations Petya can perform. The second line contains n space-separated positive integers a_i(1 ≤ a_i ≤ 10⁴) — the towers' initial heights.

Output

In the first line print two space-separated non-negative integers s and m (m ≤ k). The first number is the value of the minimum possible instability that can be obtained after performing at most k operations, the second number is the number of operations needed for that.

In the next m lines print the description of each operation as two positive integers i and j, each of them lies within limits from 1 to n. They represent that Petya took the top cube from the i-th tower and put in on the j-th one (i ≠ j). Note that in the process of performing operations the heights of some towers can become equal to zero.

If there are multiple correct sequences at which the minimum possible instability is achieved, you are allowed to print any of them.

Sample test(s)

input

3 2
5 8 5

output

0 2
2 1
2 3

input

3 4
2 2 4

output

1 1
3 2

input

5 3
8 3 2 6 3

output

3 3
1 3
1 2
1 3

Note

In the first sample you need to move the cubes two times, from the second tower to the third one and from the second one to the first one. Then the heights of the towers are all the same and equal to 6.

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=100+5,M=1000+5,Z=1e9+7,ms63=1061109567;
int n,k;
int a[N];
pair<int,int>b[M];
int main()
{
	while(~scanf("%d%d",&n,&k))
	{
		for(int i=1;i<=n;++i)scanf("%d",&a[i]);
		int m;
		for(m=1;m<=k;++m)
		{
			int minv=1e9;
			int maxv=-1e9;
			int minp,maxp;
			for(int j=1;j<=n;++j)
			{
				if(a[j]<minv){minv=a[j];minp=j;}
				if(a[j]>maxv){maxv=a[j];maxp=j;}
			}
			if(maxv-minv>=2){++a[minp];--a[maxp];b[m]=MP(maxp,minp);}
			else break;
		}--m;
		sort(a+1,a+n+1);
		printf("%d %d\n",a[n]-a[1],m);
		for(int i=1;i<=m;++i)printf("%d %d\n",b[i].first,b[i].second);
	}
	return 0;
}
/*
【题意】
有n（100）个数。每个数的数值都在 [1,1e4]之间。
我们最多可以做k次操作。每次操作把一个数的数值减少1，并加到另外一个数上。
但是要有一个原则需要保证，就是——
一个数的数值如果减过，之后就一定不能再加了。
我们希望在若干次操作后，使得权值最大的数与权值最小的数的差值尽可能小，并输出这个差值。

【类型】
贪心。

【分析】
这题我们只要不断做贪心就好啦。
就是把当前最大的数，减少1，移动到当前最小的数上。

首先要保证次数不超过k。
而同时，为了保证不破打题目给定的原则。
我们发现，只有在最大数-最小数的差值>=2时才做操作。

于是这道题就做完啦！

【时间复杂度&&优化】
O（nk）

*/