【Codeforces Round 269 (Div 2)B】【简单构造】MUH and Sticks 数值升序输出三种可能编号序

B. MUH and Important Things

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

It's time polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev got down to business. In total, there are n tasks for the day and each animal should do each of these tasks. For each task, they have evaluated its difficulty. Also animals decided to do the tasks in order of their difficulty. Unfortunately, some tasks can have the same difficulty, so the order in which one can perform the tasks may vary.

Menshykov, Uslada and Horace ask you to deal with this nuisance and come up with individual plans for each of them. The plan is a sequence describing the order in which an animal should do all the n tasks. Besides, each of them wants to have its own unique plan. Therefore three plans must form three different sequences. You are to find the required plans, or otherwise deliver the sad news to them by stating that it is impossible to come up with three distinct plans for the given tasks.

Input

The first line contains integer n (1 ≤ n ≤ 2000) — the number of tasks. The second line contains n integers h₁, h₂, ..., h_n(1 ≤ h_i ≤ 2000), where h_i is the difficulty of the i-th task. The larger number h_i is, the more difficult the i-th task is.

Output

In the first line print "YES" (without the quotes), if it is possible to come up with three distinct plans of doing the tasks. Otherwise print in the first line "NO" (without the quotes). If three desired plans do exist, print in the second line n distinct integers that represent the numbers of the tasks in the order they are done according to the first plan. In the third and fourth line print two remaining plans in the same form.

If there are multiple possible answers, you can print any of them.

Sample test(s)

input

4
1 3 3 1

output

YES
1 4 2 3 
4 1 2 3 
4 1 3 2 

input

5
2 4 1 4 8

output

NO

Note

In the first sample the difficulty of the tasks sets one limit: tasks 1 and 4 must be done before tasks 2 and 3. That gives the total of four possible sequences of doing tasks : [1, 4, 2, 3], [4, 1, 2, 3], [1, 4, 3, 2], [4, 1, 3, 2]. You can print any three of them in the answer.

In the second sample there are only two sequences of tasks that meet the conditions — [3, 1, 2, 4, 5] and [3, 1, 4, 2, 5]. Consequently, it is impossible to make three distinct sequences of tasks.

#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=2000+10,M=0,Z=1e9+7,ms63=1061109567;
int n;
struct A
{
	int v,o;
}a[N];
int st[N],ed[N];
int num[N];
bool cmp(A a,A b)
{
	return a.v<b.v;
}
void print()
{
	for(int i=1;i<=n;++i)printf("%d ",a[i].o);
	puts("");
}
void solve()
{
	sort(a+1,a+n+1,cmp);
	int two1=0;
	int two2=0;
	int three=0;
	for(int i=1;i<=2000;++i)
	{
		if(num[i]>=3&&three==0)three=i;
		else if(num[i]==2&&two1==0)two1=i;
		else if(num[i]==2&&two2==0)two2=i;
	}
	if(three==0&&two2==0)
	{
		puts("NO");
		return;
	}
	puts("YES");
	print();
	if(three)
	{
		for(int i=1;i<=n;++i)if(a[i].v==three)
		{
			swap(a[i],a[i+1]);print();
			swap(a[i+1],a[i+2]);print();
			break;
		}
	}
	else
	{
		for(int i=1;i<=n;++i)if(a[i].v==two1)
		{
			swap(a[i],a[i+1]);print();
			break;
		}
		for(int i=1;i<=n;++i)if(a[i].v==two2)
		{
			swap(a[i],a[i+1]);print();
			break;
		}
	}
}
int main()
{
	while(~scanf("%d",&n))
	{
		MS(num,0);
		for(int i=1;i<=n;++i)
		{
			scanf("%d",&a[i].v);
			a[i].o=i;
			++num[a[i].v];
		}
		solve();
	}
	return 0;
}
/*
【trick&&吐槽】
差点把成功编号的情况忘记掉输出YES，我好蠢！

【题意】
给你n（2000）个数，每个数的数值都在[1,2000]之间。
我们需要把这些数，按照数值从小到大排序。
然而，因为数值可能有重复，所以最终排序顺序所对应的原始编号可能是不同的。
让你判断是否至少有三种编号情况，没有输出NO
有则输出YES和三种数列。

【类型】
简单 构造

【分析】
这题可以说是比较简单的构造。

我们发现，如果没有重复的数值，显然答案是NO
如果有一个数值至少重复了3次，那这3者位置交换就可以构成6种排列，肯定YES
如果有两个数值至少重复了4次，那00 01 10 11四种排列就可以构成，答案也肯定YES

于是，只要考虑1*3和2*2，这道题就可以做完啦！

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

*/