题意 ： 构造尽可能少的一种结构，父节点的值小于等于子节点，而且子节点在序列中出现在父节点后面。而且每个父节点至多有两个子节点。
开始理解错题意了，卡了好半天啊，这道题不是简单的一个节点可以有两个子节点那么简单，而是递归的，也就是说子节点还可以递归存在子节点，也就是可以是树，坑了好半天啊。。。弱鸡。。。
已知每个树上的节点 set 来维护，保证其根据点对应的 set.upper_bound() 在O(n)准确来说是O(set.size())复杂度内查找
需要注意的是，每个节点最多只能有两个子节点，故当某节点已经连接了两个子节点后，应将其从 set 中删除。
#include<bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
vector<int> v[N];
int n,tmpval, cnt, dig[N];
struct Node {
int paridx, index, val; ///存储父亲节点 当前节点 对应的值
Node(){}
Node(int a ,int b ,int c){paridx=a,index=b,val=c;}
}tmp;
bool operator<(Node x, Node y)
{
if(x.val == y.val)
return x.index < y.index; ///按照顺序排列
return x.val < y.val;
}
set<Node > st;
set<Node >::iterator it;
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
st.clear();
cnt = 0;
scanf("%d",&n);
memset(dig, 0, 4*n+4);
for(int i=1;i<=n;i++)
{
scanf("%d",&tmpval);
tmp.index=i,tmp.val=tmpval;
it = st.upper_bound(tmp);
if(it==st.begin()) ///没有符合条件的父节点，新开一个
{
v[cnt].push_back(i);
st.insert(Node(cnt,i,tmpval));
cnt++;
}
else
{
it--;
tmp = *it;
dig[tmp.index]++;
if(dig[tmp.index] == 2)
st.erase(it);
st.insert(Node((*it).paridx,i,tmpval)); ///注意插入的是满足节点的父节点，并查集思想
v[tmp.paridx].push_back(i);
}
}
printf("%d\n", cnt);
for(int i=0;i<cnt;i++)
{
printf("%d", v[i].size());
for(int j=0;j<v[i].size();j++)
printf(" %d", v[i][j]);
printf("\n");
v[i].clear();
}
}
}
下面这个代码看着也挺漂亮的并查集思想在代码里显式表现出来了：
借鉴网友：here
分析 ： 贪心即可，首先，我们先对这个序列排个序，得知每个数的rank 然后对原序列从左到右遍历，维护一个set，存的是这个数的rank， 对于每个数，如果set空，那么直接insert，如果不空，用lower_bound 找出这个数之前的最大的小于等于他的数，如果这个数不存在，也是直接insert ，存在，用一个并查集连边，因为每个节点最多连两条边，那么我们用一个cnt数组记录每个点连了几个子节点，当大于等于2的时候直接从set中删掉。最后答案，个数就是并查集跟自己连边的个数。最后输出即可。
赛后听说被卡时间了，，大概运气比较好，，没有体会到，，回来仔细看了下，题目说n的总和不会大于2e6,那么用memset会超时，直接for1~n清空能过。
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cstring>
#include<string>
#include<vector>
#include<iomanip>
//#include<unordered_set>
//#include<unordered_map>
#include<cmath>
#include<list>
#include<bitset>
using namespace std;
#define _____ ios::sync_with_stdio(false); cin.tie(0);
#define ull unsigned long long
#define ll long long
#define lson l,mid,id<<1
#define rson mid+1,r,id<<1|1
typedef pair<int, int>pii;
typedef pair<ll, ll>pll;
typedef pair<ll, int>pli;
typedef pair<double, double>pdd;
const double eps = 1e-6;
const int MAXM = 5005;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const double FINF = 1e18;
const ll MOD = 1000000007;
const double PI = acos(-1);
struct lx {
int id, v;
}a[100005], b[100005];
int cmp(lx a, lx b)
{
if (a.v == b.v)return a.id < b.id;
else return a.v < b.v;
}
int pre[100005];
int rk[100005];// rk 记录第 i 大的数 原id 是多少
int rk2[100005];// rk2 记录 原序列 下标为 id 的 排序后是第几位
int cnt[100005];
vector<int>ans[100005];
vector<int>v;
set<int>st;
int find(int x) { return pre[x] == x ? x : pre[x] = find(pre[x]); }
int main()
{
int T, n;
scanf("%d", &T);
while (T--)
{
st.clear();
scanf("%d", &n);
for (int i = 1; i <= n; ++i)scanf("%d", &a[i].v), a[i].id = i, b[i].id = a[i].id, b[i].v = a[i].v;
sort(b + 1, b + 1 + n, cmp);
for (int i = 1; i <= n; ++i)rk[i] = b[i].id, rk2[b[i].id] = i, pre[i] = i, cnt[i] = 0;
for (int i = 1; i <= n; ++i)
{
if (st.size() == 0)
{
st.insert(rk2[i]);
continue;
}
auto pos = st.lower_bound(rk2[i]);
if (pos == st.begin() && *st.begin() > rk2[i])
{
st.insert(rk2[i]);
continue;
}
else
{
int tmp = *(--pos);
pre[i] = rk[tmp];
cnt[tmp]++;
if (cnt[tmp] >= 2)st.erase(tmp);
st.insert(rk2[i]);
}
}
for (int i = 1; i <= n; ++i)ans[i].clear();
v.clear();
for (int i = 1; i <= n; ++i)
{
if (pre[i] == i)v.push_back(i);
ans[find(i)].push_back(i);
}
printf("%d\n", v.size());
for (int i = 0; i < v.size(); ++i)
{
sort(ans[v[i]].begin(), ans[v[i]].end());
printf("%d ", ans[v[i]].size());
for (int j = 0; j < ans[v[i]].size(); ++j)
{
if (j == ans[v[i]].size() - 1)printf("%d\n", ans[v[i]][j]);
else printf("%d ", ans[v[i]][j]);
}
}
}
}
