Description

Ivan has an array consisting of n different integers. He decided to reorder all elements in increasing order. Ivan loves merge sort so he decided to represent his array with one or several increasing sequences which he then plans to merge into one sorted array.

Ivan represent his array with increasing sequences with help of the following algorithm.

While there is at least one unused number in array Ivan repeats the following procedure:

iterate through array from the left to the right;

Ivan only looks at unused numbers on current iteration;

if current number is the first unused number on this iteration or this number is greater than previous unused number on current iteration, then Ivan marks the number as used and writes it down.

For example, if Ivan’s array looks like [1, 3, 2, 5, 4] then he will perform two iterations. On first iteration Ivan will use and write numbers [1, 3, 5], and on second one — [2, 4].

Write a program which helps Ivan and finds representation of the given array with one or several increasing sequences in accordance with algorithm described above.

Input

The first line contains a single integer n (1 ≤ n ≤ 2·10^5) — the number of elements in Ivan’s array.

The second line contains a sequence consisting of distinct integers a1, a2, …, an (1 ≤ ai ≤ 10^9) — Ivan’s array.

Output

Print representation of the given array in the form of one or more increasing sequences in accordance with the algorithm described above. Each sequence must be printed on a new line.

Examples input

5
1 3 2 5 4

Examples output

1 3 5
2 4

題意

找出所有不重疊不下降的子序列。

思路

有一種暴力的想法：我們可以在 O(n) 的時間複雜度找出當前陣列中的一個不下降子序列，然後從陣列中刪掉這部分繼續重複剛才的操作。

不過這佯的方法時間複雜度為 O(n2) ，顯然會超時。

考慮用佇列來儲存所有不重疊不下降的子序列，對於已拓展出的 len 個佇列，顯然其尾部數字的大小是按降序排列的。

比如我們有 5,4,3,2,1,6,8,7,5 這些數字，其在佇列中的儲存如下：

5,6,8
4,7
3,5
2
1

此時由所有佇列尾部組成的序列為 8,7,5,2,1 ，對於即將加入的新數字 x ，如果在已有佇列尾部可以找到一個編號最小且尾部小於等於 x 的索引，那麼我們可以將 x 加入到該佇列尾部，否則用它來拓展一個新佇列。

查詢採用二分總時間複雜度為 O(n×logn)

AC 程式碼

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
typedef __int64 LL;

LL a[maxn];
int n;
deque<LL> top[maxn];

int lower_update(int len,LL x)      // 找一個編號最小且佇列末尾元素小於 x 的索引
{
    int low = 0,high = len;
    while(low<high)
    {
        int mid = (low+high)>>1;
        if(*top[mid].rbegin()<=x)
            high = mid;
        else
            low = mid + 1;
    }
    if(high == len)return -1;
    return high;
}

void solve()
{
    int len = 0;
    for(int i=0; i<n; i++)
    {
        int res = lower_update(len,a[i]);   // 二分查詢
        if(res == -1)                       // 沒找到說明當前元素的值偏小
            top[len++].push_back(a[i]);
        else
            top[res].push_back(a[i]);
    }
    for(int i=0; i<len; i++)
    {
        cout<<top[i].front();
        top[i].pop_front();
        while(!top[i].empty())
        {
            cout<<" "<<top[i].front();
            top[i].pop_front();
        }
        cout<<endl;
    }
}

int main()
{
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    solve();
    return 0;
}