/*
問題:給n個整數，按從大到小的順序，輸出前m大的整數
0<m,n<1000000,每個整數[-500000,500000]
輸入:
5 3
3 -35 92 213 -644
輸出:
213 92 3 
思路:
先按從小到大用快排排好序，然後輸出排好序的陣列從最後開始輸出m個即可

關鍵:
1 已經達到千萬數量級，1秒不能解決，必須用雜湊,因為數字的範圍達到百萬級
2 雜湊針對的是輸入數值處於特定範圍的問題，建立一個範圍大小的陣列，建立hash[x] = x出現多少次的對映
3 對於定義較大容量的陣列，放在函式體外，這樣用全域性變數，記憶體會比較充足
4 對於區間為負的，需要設定下標補償值
*/

#include <stdio.h>
#include <stdlib.h>

#define POS 500000
int iHash[1000001] = {0};

int main(int argc,char* argv[])
{
	int n,m,i;
	while(EOF!=scanf("%d%d",&n,&m) && m <= n && m > 0 && m < 1000000 && n > 0 && n < 1000000 )
	{
		for(i = 0; i < n ;i++)
		{
			int iValue;
			scanf("%d",&iValue);
			if(iValue < -500000 || iValue > 500000)
			{
				return 0;
			}
			else
			{
				iHash[iValue + POS] = 1;//下標和值存在某種一元函式關係
			}
		}
		for(i = 500000 ; i >= -500000 ; i--)
		{
			if(iHash[i + POS]==1)
			{
				m--;
				printf("%d ",i);
			}
			//if(m)//應該是m=0列印空格
			if(0==m)
			{
				printf("\n");
				break;
			}
		}
		//printf("\n");
	}
	system("pause");
	getchar();
	return 0;
}

/*
#include <stdio.h>
#include <memory.h>
#include <stdlib.h>

int partition(int *A,int low,int high)
{
	int iPos = A[low];
	while(low < high)
	{
		while(low < high && A[high] > iPos)
		{
			high--;
		}
		A[low] = A[high];
		while(low < high && A[low] < iPos)
		{
			low++;
		}
		A[high] = A[low];
	}
	A[low] = iPos;
	return low;
}

void quickSort(int *A,int low,int high)
{
	if(low < high)
	{
		int iPos = partition(A,low,high);
		quickSort(A,low,iPos-1);
		quickSort(A,iPos+1,high);
	}
}




int main(int argc,char* argv[])
{
	int m,n,i;
	while(EOF!=scanf("%d %d",&n,&m) && n >= m && n > 0 && n < 1000000 && m > 0 && m < 1000000)
	{
		int *iArr = (int*)malloc(n*sizeof(int));
		for( i = 0 ;i < n ; i++ )
		{
			int iValue;
			scanf("%d",&iValue);
			if(iValue < -500000 || iValue > 500000)
			{
				free(iArr);
				return 0;;
			}
			else
			{
				*(iArr+i) = iValue;
			}
		}
		quickSort(iArr,0,n-1);//0~m-1,n-1 是1 ，n-2 是2 ， n-m是  m
		for(i = n-1;i >= (n-m); i--)
		{
			printf("%d ",iArr[i]);
		}
		free(iArr);
	}
	system("pause");
	getchar();
	return 0;
}

 */