Problem:
Score : 800 points

Problem Statement

You are given an integer sequence x of length N.
Determine if there exists an integer sequence a that satisfies all of the following conditions, and if it exists, construct an instance of a.

a is N^2 in length, containing N copies of each of the integers 1, 2, ..., N.

For each 1 ≤ i ≤ N, the i-th occurrence of the integer i from the left in a is the x_i-th element of a from the left.

Constraints

1 ≤ N ≤ 500

1 ≤ x_i ≤ N^2

All x_i are distinct.

Input

The input is given from Standard Input in the following format:

N
x_1 x_2 ... x_N

Output

If there does not exist an integer sequence a that satisfies all the conditions, print No.
If there does exist such an sequence a, print Yes in the first line, then print an instance of a in the second line, with spaces inbetween.

Sample Input 1

3
1 5 9

Sample Output 1

Yes
1 1 1 2 2 2 3 3 3

For example, the second occurrence of the integer 2 from the left in a in the output is the fifth element of a from the left.
Similarly, the condition is satisfied for the integers 1 and 3.

Sample Input 2

2
4 1

Sample Output 2

No

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.Diagnostics;
        using System.IO;
        using System.Linq;
        //using System.Numerics;  //comment out if AOJ
        using System.Text;
         
        using Problem = Tmp.Problem;
        using MyIO;
         
        #pragma warning disable   //for AOJ
         
        namespace Tmp
        {
            class Problem : IDisposable
            {
                bool IsGCJ;
                int Repeat;
                Scanner sc;
                Printer pr;
                public Problem(bool isGCJ, Scanner scanner, Printer printer)
                {
                    sc = scanner;
                    pr = printer;
                    IsGCJ = isGCJ;
                    if (isGCJ) Repeat = sc.nextInt();
                    else Read();
                }
                public Problem(bool isGCJ) : this(isGCJ, new Scanner(), new Printer()) { }
                public Problem(bool isGCJ, Scanner scanner) : this(isGCJ, scanner, new Printer()) { }
                public Problem(bool isGCJ, Printer printer) : this(isGCJ, new Scanner(), printer) { }
                public void Solve()
                {
                    if (IsGCJ) for (var i = 0; i < Repeat; i++) { Read(); pr.Write("Case #" + (i + 1) + ": "); SolveOne(); }
                    else SolveOne();
                }
                public void Dispose()
                {
                    sc.Dispose();
                    pr.Dispose();
                }
                public int Size { get { return 1; } }
                public const long Mod = 1000000007;
         
                // 使用する変数をここに書く
                // string S;
                // int a;
                /// <summary>
                /// 読み込み処理をここに書く
                /// </summary>
                void Read()
                {
         
                }
                /// <summary>
                /// メイン処理をここに書く
                /// </summary>
                void SolveOne()
                {
                    int n = sc.nextInt();
                    int[] x = sc.nextInt(n);
                    int[] ls = new int[n];
                    for (int i = 0; i < n; i++)
                    {
                        ls[i] = i + 1;
                    }
                    Array.Sort(ls, x);
                    bool ok = true;
                    int[] dest = new int[n * n + 1];    // kimatteiru tokoro
                    int[] ans = new int[n * n + 1];     // kotae
                    /*
                    Dictionary<int, int> dic = new Dictionary<int, int>();
                    int[] sorttmp = new int[n];
         
         
                    for (int i = 0; i < n; i++)
                    {
                        dic.Add(x[i], i + 1);
                        sorttmp[i] = x[i];
                    }
                    Array.Sort(sorttmp);
                    */
         
                    for (int i = 0; i < n; i++)
                    {
                        //ls[i] = dic[sorttmp[i]];
                        dest[x[i]] = i + 1;
                    }
         
                    int[] cnt = new int[n + 1]; // tukatta kaisuu
                    int next = 0;
                    bool nisyuume = false;
                    for (int i = 1; i <= n*n; i++)
                    {
                        if(dest[i]>0)
                        {
                            if (cnt[dest[i]]+ 1 != dest[i])
                            {
                                ok = false;
                                break;
                            }
                            else
                            {
                                ans[i] = dest[i];
                                cnt[dest[i]]++;
                            }
                        } 
                        else
                        {
                            if (nisyuume == false)
                            {
                                while (cnt[ls[next]] >= ls[next] - 1)
                                {
                                    next++;
                                    if(next >=n)
                                    {
                                        next = 0;
                                        nisyuume = true;
                                        break;
                                    }
                                }
                            }
                            if(nisyuume == true)
                            {
                                while(cnt[ls[next]] >=n)
                                {
                                    next++;
                                    if (next >= n - 1) break;
                                }
                            }
                            ans[i] = ls[next];
                            cnt[ls[next]]++;                    
                        }
         
                    }
                if (ok)
                {
                    //Console.WriteLine("Yes");
                    pr.WriteLine("Yes");
                    for (int i = 1; i <= n * n; i++)
                    {
                        if (i > 1)
                        {
                            //Console.Write(" ");
                            pr.Write(" ");
                        }
                        //Console.Write(ans[i]);
                        pr.Write(ans[i]);
                    }
                    //Console.WriteLine();
                    pr.WriteLine();
                }
                else
                {
                    Console.WriteLine("No");
                }
                    
                }
            }
        }
        class Program
        {
            //public static RandomSFMT rand = new RandomSFMT();
            public static bool IsJudgeMode = true;
            public static bool IsGCJMode = false;
            public static bool IsSolveCreated = true;
            static void Main()
            {
                if (IsJudgeMode)
                    if (IsGCJMode) using (var problem = new Problem(true, new Scanner("C-large-practice.in.txt"), new Printer("output.txt"))) problem.Solve();
                    else using (var problem = new Problem(false, new Printer())) problem.Solve();
                else
                {
                    var num = 1;
                    int size = 0;
                    decimal time = 0;
                    for (var tmp = 0; tmp < num; tmp++)
                    {
                        using (var P = IsSolveCreated ? new Problem(false, new Scanner("input.txt"), new Printer()) : new Problem(false))
                        {
                            size = P.Size;
                            //time += Func.MeasureTime(() => P.Solve());
                        }
                    }
                    Console.WriteLine("{0}, {1}ms", size, time / num);
                }
            }
        }
         
        /// <summary>
        /// カスタマイズしたIO
        /// </summary>
        namespace MyIO
        {
            class Printer : IDisposable
            {
                bool isConsole;
                TextWriter file;
                public Printer() { file = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false }; isConsole = true; }
                public Printer(string path) { file = new StreamWriter(path, false) { AutoFlush = false }; isConsole = false; }
                public void Write<T>(T value) { file.Write(value); }
                public void Write(bool b) { file.Write(b ? "YES" : "NO"); }
                public void Write(string str, params object[] args) { file.Write(str, args); }
                public void WriteLine() { file.WriteLine(); }
                public void WriteLine<T>(T value) { file.WriteLine(value); }
                public void WriteLine(bool b) { file.WriteLine(b ? "YES" : "NO"); }
                public void WriteLine<T>(IEnumerable<T> list) { foreach (var x in list) file.WriteLine(x); }
                public void WriteLine<T>(List<T> list) { foreach (var x in list) file.WriteLine(x); }
                public void WriteLine<T>(T[] list) { foreach (var x in list) file.WriteLine(x); }
                public void WriteLine(string str, params object[] args) { file.WriteLine(str, args); }
                public void Dispose() { file.Flush(); if (!isConsole) file.Dispose(); }
            }
            class Scanner : IDisposable
            {
                bool isConsole;
                TextReader file;
                public Scanner() { file = Console.In; }
                public Scanner(string path) { file = new StreamReader(path); isConsole = false; }
                public void Dispose() { if (!isConsole) file.Dispose(); }
         
                #region next読み込み
                string[] nextBuffer = new string[0];
                int BufferCnt = 0;
         
                char[] cs = new char[] { ' ' };
         
                public string next()
                {
                    while (BufferCnt >= nextBuffer.Length)
                    {
                        string st = file.ReadLine();
                        while (st == "") st = file.ReadLine();
                        nextBuffer = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
                        BufferCnt = 0;
                    }
                    return nextBuffer[BufferCnt++];
                }
         
                public int nextInt()
                {
                    return int.Parse(next());
                }
         
                public long nextLong()
                {
                    return long.Parse(next());
                }
         
                public double nextDouble()
                {
                    return double.Parse(next());
                }
         
                private T[] enumerate<T>(int n, Func<T> f)
                {
                    var a = new T[n];
                    for (int i = 0; i < n; ++i) a[i] = f();
                    return a;
                }
         
                public string[] next(int n) { return enumerate(n, next); }
                public double[] nextDouble(int n) { return enumerate(n, nextDouble); }
                public int[] nextInt(int n) { return enumerate(n, nextInt); }
                public long[] nextLong(int n) { return enumerate(n, nextLong); }
                #endregion
            }
        }