BZOJ5484（LIS性质+树状数组）

题目传送

学习的这篇题解。

结论：

1.直观感受一下会发现找到LIS，LIS里的东西相对位置是不会变的，其他的移一移总会排序成功的，所以其他的就是最小集合了，第一问的答案就是n-LIS；

2.寻找字典序第k小的集合，相当于是寻找字典序第k大的LIS，然后把这个LIS删去，就是第二问的答案集合。

前置技能：

树状数组，及树状数组求LIS。

解决方法（请先看代码）：

1.树状数组bit[i]求LIS的同时再维护一下“以比i大的数字为开头、这个LIS长度下的序列的数量”。数量超过maxk的时候min一下砍掉（是一种常见手法），因为多了也没有用它只会询问maxk以内的，否则有可能爆longlong。

2.用vector存下每个长度的LIS是以哪些位置为起点，然后按长度从大到小枚举，看看第k个是哪个LIS，标记这些数字。因为之前维护了数量，所以这时就不用从1开始一个一个枚举到k了，一下砍下去一段。

 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <ctime>
 #include <cctype>
 #include <climits>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
 #include <string>
 #include <sstream>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <vector>
 #include <list>
 #include <fstream>
 #include <bitset>
 #define init(a, b) memset(a, b, sizeof(a))
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define irep(i, a, b) for (int i = a; i >= b; i--)
 using namespace std;

 typedef double db;
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int, int> P;
 const int inf = 0x3f3f3f3f;
 const ll INF = 1e18;

 template <typename T> void read(T &x) {
     x = ;
     int s = , c = getchar();
     for (; !isdigit(c); c = getchar())
         if (c == '-')    s = -;
     for (; isdigit(c); c = getchar())
         x = x *  + c - ;
     x *= s;
 }

 template <typename T> void write(T x) {
     if (x < )    x = -x, putchar('-');
     if (x > )    write(x / );
     putchar(x %  + '');
 }

 template <typename T> void writeln(T x) {
     write(x);
     puts("");
 }

 const int maxn = 1e5 + ;
 const ll maxk = 1e18;

 int n, a[maxn];
 ll k;
 struct Arr {
     int len;
     ll cnt;
     Arr() {
         len = , cnt = ;
     }
     Arr(int a, ll b) {
         len = a, cnt = b;
     }
 }dp[maxn], bit[maxn];
 vector<int> v[maxn];
 bool mark[maxn];

 void Modify(Arr &a, Arr b) {
     if (a.len > b.len)    return;
     if (a.len < b.len) {
         a = b;
         return;
     }
     a.cnt = min(maxk, a.cnt + b.cnt);
 }

 void Update(int x, Arr val) {
     for (; x; x -= x&-x)
         Modify(bit[x], val);
 }

 Arr Query(int x) {
     Arr ret(, );
     for (; x <= n; x += x&-x)
         Modify(ret, bit[x]);
     return ret;
 }

 int main() {
     read(n), read(k);
     rep(i, , n)    read(a[i]);
     //树状数组维护一个后缀最大序列（的长度和此长度下的LIS个数），规则是：1.长度最大；2.如果长度相同，累加数量
     irep(i, n, ) {//比较字典序是从左往右，所以将此长度下的cnt集中在左端，故而倒序
         dp[i] = Query(a[i] + );
         v[++dp[i].len].push_back(i);
         Update(a[i], dp[i]);
     }

     int LIS = Query().len;
     for (int i = LIS, pos = ; i; --i) {
         for (int j = v[i].size() - ; ~j; --j) {
         //找字典序大的，所以倒着找。vector的插入导致其中的a[p]必然升序
             int p = v[i][j];
             if (dp[p].cnt < k) {//以当前数字为开头的所有LIS的数量都无法满足k的需求，则这个开头被pass
                 k -= dp[p].cnt;
             } else {//说明要找的LIS以当前这个数字为开头
                 mark[a[p]] = true;
                 while (pos < p)    dp[pos++].cnt = ;
                 //选定这个数以后，因为是找LIS，所以它之前的数不能再选中
                 break;
             }
         }
     }

     writeln(n - LIS);
     rep(i, , n) {
         if (!mark[i])
             writeln(i);
     }
     return ;
 }