LIS系列总结

此篇博客总结常见的LIS模型变形的解法。

-------------------------------------------------------------------

〇、LIS的$O(NlogN)$复杂度的dp和$O(N^2)$复杂度的dp就不写了。

一、最长不下降子序列

　　把$O(NlogN)$复杂度的dp中，查找$\ge a[i]$的函数lower_bound改为查找$> a[i]$的函数upper_bound即可。

#include<bits/stdc++.h>
using namespace std;
;

int n, a[MAXN], dp[MAXN];
int main(){
    freopen("input.txt", "r", stdin);
    freopen("output2.txt", "w", stdout);
    while(~scanf("%d", &n)){
        ;i < n;++i)scanf("%d", a + i);
        memset(dp, 0x3f, sizeof(dp));
        ;i < n;++i){
            int p = upper_bound(dp, dp + n, a[i]) - dp;
            dp[p] = a[i];
        }
        cout << (lower_bound(dp, dp + n, 0x3f3f3f3f) - dp) << endl;
    }
    ;
}

二、LIS输出方案

　　1、输出任意方案(以下方法其实是输出下标字典序最大的一个LIS)

#include<bits/stdc++.h>
using namespace std;
;

int n, a[MAXN], dp[MAXN], par[MAXN];
map<int, int> mp;

void print(int x){
    if(~par[x])print(par[x]);
    printf("%d ", a[x]);
}

int main(){
    freopen("input.txt", "r", stdin);
    freopen("output2.txt", "w", stdout);
    while(~scanf("%d", &n)){
        ;i < n;++i)scanf("%d", a + i);
        memset(dp, 0x3f, sizeof(dp));
        memset(par, -, sizeof(par));
        mp.clear();
        ;i < n;++i){
            int p = lower_bound(dp, dp + n, a[i]) - dp;
            dp[p] = a[i];
            mp[a[i]] = i;
            )par[i] = mp[dp[p - ]];
        }
        int len = lower_bound(dp, dp + n, 0x3f3f3f3f) - dp;
        printf("%d\n", len);
        print(mp[dp[len - ]]);
        printf("\n");
    }
    ;
}

　　2、输出LIS下标字典序最小的方案

#include<bits/stdc++.h>
using namespace std;
;

int n, a[MAXN], dp[MAXN], par[MAXN];
map<int, int> mp;
vector<int> v[MAXN];

void print(int x, int y) {
    ) {
        ; i < v[x - ].size(); ++i) {
            ][i]] < a[v[x][y]]){
                print(x - , i);
                break;
            }
        }
    }
    printf("%d ", a[v[x][y]]);
}

int main() {
    freopen("input.txt", "r", stdin);
    freopen("output2.txt", "w", stdout);
    while(~scanf("%d", &n)) {
        ; i < n; ++i)scanf("%d", a + i);
        ; i < n; ++i)v[i].clear();
        memset(dp, 0x3f, sizeof(dp));
        memset(par, -, sizeof(par));
        mp.clear();
        ; i < n; ++i) {
            int p = lower_bound(dp, dp + n, a[i]) - dp;
            dp[p] = a[i];
            mp[a[i]] = i;
            )par[i] = mp[dp[p - ]];
            v[p].push_back(i);
        }
        int len = lower_bound(dp, dp + n, 0x3f3f3f3f) - dp;
        printf("%d\n", len);
        print(len - , );
        printf("\n\n");
    }
    ;
}

　　3、输出数值字典序最小的方案

　　朴素的想法：在第2步的基础上，把所有方案找出来，然后比较数值字典序。

　　4、输出公差为$d$的LIS(此LIS不一定是最长上升子序列，但肯定是最长的上升的公差为$d$的等差数列)(任意一个即可)

　　例题：http://codeforces.com/contest/977/problem/F

/********************template head********************/
#include<bits/stdc++.h>
using namespace std;
#define pb(x) push_back(x)
#define mk(x, y) make_pair(x, y)
#define pln() putchar('\n')
#define cln() (cout << '\n')
#define fst first
#define snd second
#define MOD 1000000007LL
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
;
/********************template head********************/

int n, d, a[MAXN], dp[MAXN], par[MAXN], len;
map<int, int> mp;

void dfs(int x) {
    if(~par[x])dfs(par[x]);
    printf("%d ", a[x]);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    //freopen("output2.txt", "w", stdout);
#endif // ONLINE_JUDGE
    while(~scanf("%d%d", &n, &d)) {
        ; i < n; ++i)scanf("%d", a + i);
        memset(par, -, sizeof(par));
        mp.clear();
        ; i < n; ++i) {
            map<int, int>::iterator it = mp.find(a[i] - d);
            ;
            else {
                dp[i] = dp[it->snd] + ;
                par[i] = it->snd;
            }
            mp[a[i]] = i;
        }
        int p = max_element(dp, dp + n) - dp;
        printf("%d\n", dp[p]);
        dfs(p);
        printf("\n");
    }
    ;
}