[学习笔记] 关于 LIS/LDS 的一些奇奇怪怪的东西~

推销我的博客园~

球球大家了来看看我的博客园吧，阅读量 $0$ 是人干事？

最基础的方法

有用的信息无非是 “权值” 和 “长度”。于是可以固定权值，求最长长度（树状数组）；或者固定长度 $j$，求最小权值 $g_j$。

方案数？

延续上文的方法：可以用树状数组维护最值时同时维护方案数；或者，将 $g$ 开成一个 $\text{vector}$，放置所有 $\text{LIS}$ 为 $j$ 的数字及其方案数，显然这些数字是递减的。设位置 $i$ 的方案数为 $f_i$，它的 $\text{LIS}$ 为 $p$，显然有如下转移：

KaTeX parse error: Undefined control sequence: \and at position 23: …um_{j\in g(p-1)\̲a̲n̲d̲ ̲a_j<a_i} f_j

因为存储了历史值，所以显然不是所有属于 $g(p-1)$ 的数字都能转移到 $i$。所以需要做一个前缀和 $+$ 二分。

$\text{Dilworth}$ 定理

不下降子序列最小个数 $=$ $\text{LIS}$ 的长度。

树上 $\text{LIS}$

例 1. $\text{BZOJ }$大根堆

还是和 基础方法 一样：对于固定权值，此时发现儿子之间是互不影响的，于是可以使用线段树合并；对于固定长度，定长的数组无法处理，所以可以开一个 $\text{multiset}$。

例 2. $\text{CF490F Treeland Tour}$

对于固定权值，用线段树分别维护 $\text{LIS}$ 与 $\text{LDS}$。具体合并两棵线段树时，可以以 $\text{mid}$ 为界进行 $\text{LIS}$ 与 $\text{LDS}$ 的合并。

极长 $\text{LIS}$

例 1. $\text{BZOJ - 2957 }$楼房重建

将斜率作为权值，题目要求的就是 能选则选 的极长 $\text{LIS}$。

考虑用线段树维护，节点 $[l,r]$ 维护区间最大斜率 $k$ 和 从 $l$ 开始 的极长 $\text{LIS}$，令其为 $L$。定义 $\text{calc}(o,k)$ 为区间 $o$ 中，且起点大于 $k$ 的极长 $\text{LIS}$。

那么更新节点 $o$ 的答案时，就只用左儿子的答案加上 $\text{calc}(\text{rson},k_{\text{lson}})$ 即可。

关于 $\text{calc}()$ 的内部实现，当左儿子的最大斜率不大于 $k$ 时直接递归右儿子；反之递归左儿子，加上右半部分已经算好的值（因为左半部分的斜率不会变化）。注意右半部分算好的值不是 $L_{\text{rson}}$，这个没有考虑左半部分的斜率。

时间复杂度 $\mathcal{O}(n{\log }^{2}n)$。

#include <cstdio>
#define print(x,y) write(x),putchar(y)

template <class T>
inline T read(const T sample) {
	T x=0; char s; bool f=0;
	while((s=getchar())>'9' or s<'0')
		f |= (s=='-');
	while(s>='0' and s<='9')
		x = (x<<1)+(x<<3)+(s^48),
		s = getchar();
	return f?-x:x;
}

template <class T>
inline void write(T x) {
    static int writ[40],w_tp=0;
    if(x<0) putchar('-'),x=-x;
    do writ[++w_tp]=(x-x/10*10),x/=10; while(x);
    while(putchar(writ[w_tp--]^48),w_tp);
}

#include <iostream>
using namespace std;

const int maxn = 1e5+5;

int n,m;
struct node {
    double k; int ans;
} t[maxn<<2];

int calc(int o,int l,int r,const double k) {
    if(l==r) return t[o].k>k;
    int mid=l+r>>1;
    if(t[o<<1].k<=k) 
        return calc(o<<1|1,mid+1,r,k);
    return calc(o<<1,l,mid,k)+t[o].ans-t[o<<1].ans;
}

void ins(int o,int l,int r,int p,const double k) {
    if(l==r) return t[o].k=k,t[o].ans=1,void();
    int mid=l+r>>1;
    if(p<=mid) ins(o<<1,l,mid,p,k);
    else ins(o<<1|1,mid+1,r,p,k);
    t[o].k = max(t[o<<1].k,t[o<<1|1].k);
    t[o].ans = t[o<<1].ans+calc(o<<1|1,mid+1,r,t[o<<1].k);
}

int main() {
    n=read(9),m=read(9);
    for(int i=1;i<=m;++i) {
        int x=read(9),y=read(9);
        ins(1,1,n,x,1.0*y/x);
        print(t[1].ans,'\n');
    }
    return 0;
}

例 2. $\text{Nowcoder - 7615D}$ 牛半仙的妹子序列

**题目大意：**给定一个长度为 $n$ 的排列，求出包含极长上升子序列的个数。$n\le 2\cdot 10^5$。

首先想到 $\mathtt{d}\mathtt{p}$，发现 $j$ 能向 $i$ 转移的条件是：只考虑 $<a_i$ 的数，$a_j$ 是区间 $[j,i)$ 中最大的数，且 $a_j<a_i$。

其实这可以转化为 $\text{cdq}$ 分治，我们可以按照 $a$ 来分治，转移时用前半部分贡献后半部分即可。

问题是后面的条件如何满足？事实上它可以转化为双向的条件：在 $[l,\text{mid}]$ 之中求出第一个满足在 原序列 上下标大于 $j$ 且值大于 $a_j$ 的数字在原序列上的下标 $r_j$；在 $(\text{mid},r]$ 之中求出第一个满足在 原序列 上下标小于 $i$ 且值小于 $a_i$ 的数字在原序列上的下标 $l_i$。

由于 $r_j,l_i$ 均满足权值在 $(a_j,a_i)$ 之间，那么显然上面的条件可以这样被描述：

$$l_i<j<i<r_j$$

这个问题就很简单了 —— 将 $i$ 按照 $l_i$ 从大到小排序，依次在树状数组中添加 $j$ 的 $\mathtt{d}\mathtt{p}$ 值，拿 $r_i$ 来查询即可。

时间复杂度 $\mathcal{O}(n{\log }^{2}n)$。

---

其实这道题目也可以转化为上一道例题：我们发现，对于每个 $i$，合法的 $j$ 其实就是从 $i$ 开始能选则选的单增序列（当然从左往右就是单减的）！转移时从小到大枚举权值，这样就能丢掉 最大值小于 $a_i$ 的限制。维护时直接套板子，$\text{calc}(o,k)$ 的含义就是大于 $k$ 的方案数，所以需要维护最大值。时间复杂度仍然是 $\mathcal{O}(n{\log }^{2}n)$ 的。

看看代码吧：

#include <cstdio>
#define print(x,y) write(x),putchar(y)

template <class T>
inline T read(const T sample) {
	T x=0; char s; bool f=0;
	while((s=getchar())>'9' or s<'0')
		f |= (s=='-');
	while(s>='0' and s<='9')
		x = (x<<1)+(x<<3)+(s^48),
		s = getchar();
	return f?-x:x;
}

template <class T>
inline void write(T x) {
    static int writ[40],w_tp=0;
    if(x<0) putchar('-'),x=-x;
    do writ[++w_tp]=(x-x/10*10),x/=10; while(x);
    while(putchar(writ[w_tp--]^48),w_tp);
}

#include <iostream>
using namespace std;

const int maxn = 2e5+5;
const int mod = 998244353;

int n,pos[maxn],lim;
int a[maxn],dp[maxn];
struct node {
    int mx,lans;
} t[maxn<<2];

inline int inc(int x,int y) {
    return x+y>=mod?x+y-mod:x+y;
}

int calc(int o,int l,int r,int k) {
    if(l==r) return t[o].mx>k?dp[t[o].mx]:0;
    int mid=l+r>>1;
    if(t[o<<1|1].mx<=k) return calc(o<<1,l,mid,k);
    return inc(calc(o<<1|1,mid+1,r,k),t[o].lans);
}

int ask(int o,int l,int r,int L,int R) {
    if(l>=L && r<=R) {
        int v=lim; lim = max(lim,t[o].mx);
        return calc(o,l,r,v);
    }
    int mid=l+r>>1,ret=0;
    if(R>mid) ret=ask(o<<1|1,mid+1,r,L,R);
    if(L<=mid) ret=inc(ret,ask(o<<1,l,mid,L,R));
    return ret;
}

void ins(int o,int l,int r,int p,int k) {
    if(l==r) return t[o].mx=k,void();
    int mid=l+r>>1;
    if(p<=mid) ins(o<<1,l,mid,p,k);
    else ins(o<<1|1,mid+1,r,p,k);
    t[o].mx = max(t[o<<1].mx,t[o<<1|1].mx);
    t[o].lans = calc(o<<1,l,mid,t[o<<1|1].mx);
}

int main() {
    n=read(9);
    for(int i=1;i<=n;++i) 
		pos[a[i]=read(9)]=i;
    for(int i=1;i<=n;++i) {
        int wh = pos[i]; lim=0;
        dp[i] = ask(1,1,n,1,wh);
        if(!dp[i]) dp[i]=1;
        ins(1,1,n,wh,i);
    }
    int ans=0; lim=0;
    for(int i=n;i;--i)
    	if(lim<a[i]) {
    		ans = inc(ans,dp[a[i]]);
    		lim = a[i];
		}
	print(ans,'\n');
    return 0;
}