最长递增子序列nlogn算法的一些脑补

最近因为要出去比赛，所以回顾了以往的题目，于是无聊的把递增子序列弄出来，自己尝试着推到了下O(nlogn)的算法，发现挺容易的，于是修改了下以往的博客，然后写了些自己的想法。

首先要懂nlogn算法的前提是要明白O(n^2)算法,最初始的dp十分暴力枚举每个结尾计算以i为结尾的最长递增序列长度，dp方程：dp[i] = max{ dp[j] + 1 }。我们分析下这个方程，状态转移返程可以转化为如下：

dp[i]=max{dp[j]}+1，其实就是要找到[1,i]区间上的最大值，但是这个最大值j要满足a[i]>a[j]，那么是否可以考虑将之前的a[i]存入一个队列，这个队列是按照递增的顺序，对于队列中某个位置p，那么q[p]就是到目前i位置为止长度为p的递增子序列结尾点的值。那么就可以根据二分，查找到满足a[i] > q[t]的一个上限，那么每次查询最大值的时间就从O(n)变成了O(logn)，于是算法总复杂度O(nlogn)。很美的时间复杂度。

以poj 2533为例

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<stack>
#define B(x) (1<<(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned ui;
const int oo = 0x3f3f3f3f;
//const ll OO = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
#define lson rt<<1
#define rson rt<<1|1
void cmax(int& a, int b){ if (b > a)a = b; }
void cmin(int& a, int b){ if (b < a)a = b; }
void cmax(ll& a, ll b){ if (b > a)a = b; }
void cmin(ll& a, ll b){ if (b < a)a = b; }
void cmax(double& a, double b){ if (a - b < eps) a = b; }
void cmin(double& a, double b){ if (b - a < eps) a = b; }
void add(int& a, int b, int mod){ a = (a + b) % mod; }
void add(ll& a, ll b, ll mod){ a = (a + b) % mod; }
const ll MOD = 1000000007;
const int maxn = 1100;
int q[maxn], a[maxn];

int main(){
	int n;
	while (scanf("%d", &n) != EOF){
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		memset(q, 0x3f, sizeof q);
		int ans = 0;
		q[0] = -oo;
		for (int i = 1; i <= n; i++){
			int l = 1, r = n;
			while (l < r){
				int mid = (l + r) >> 1;
				if (q[mid] >= a[i])
					r = mid;
				else
					l = mid + 1;
			}
			q[r] = a[i];
			cmax(ans, r);
		}
		printf("%d\n", ans);
	}
	return 0;
}

O(nlogn)算法时效性，所谓时效性就是无法马上根性队列里面的情况，当然之前的例子是无间隔的递曾子序列，如果变成间隔为t，那么就每次找到的最优解无法马上入队列。请看一下例子：

例子 hdu 4521

题目意思大概就是说找出间隔至少为d的子序列的最长长度。

这题如果用O(n^2)算法很容易处理，因为只要在枚举j的时候判断下是否满足间隔小于d就好了。但是这题数据比较大恰恰用n^2算法会超时，所以考虑用(nlogn)算法。

要实现间隔为d的确有点头疼（这里体现时效性不好），那么仔细思考会发现其实每次队列都是二分完就马上跟新，但是为了完成间隔d的任务这里就要稍微改变下。那么我们这样考虑，我们然某个二分完的数在d次二分之后再更新进入队列，那么这样通过时间的岔开就完成了间隔d的任务。

这里例子我们看出nlogn算法时效性不好，但是还是可以通过一些技巧来补救，总的来说O(nlogn)算法还是很美的。

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<stack>
#define B(x) (1<<(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned ui;
const int oo = 0x3f3f3f3f;
//const ll OO = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
#define lson rt<<1
#define rson rt<<1|1
void cmax(int& a, int b){ if (b > a)a = b; }
void cmin(int& a, int b){ if (b < a)a = b; }
void cmax(ll& a, ll b){ if (b > a)a = b; }
void cmin(ll& a, ll b){ if (b < a)a = b; }
void cmax(double& a, double b){ if (a - b < eps) a = b; }
void cmin(double& a, double b){ if (b - a < eps) a = b; }
void add(int& a, int b, int mod){ a = (a + b) % mod; }
void add(ll& a, ll b, ll mod){ a = (a + b) % mod; }
const ll MOD = 1000000007;
const int maxn = 110000;
int q[maxn], a[maxn], dp[maxn];

int main(){
	int n, d;
	while (scanf("%d %d", &n, &d) != EOF){
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		memset(q, 0x3f, sizeof q);
		q[0] = -oo;
		for (int i = 1; i <= n; i++){
			int l = 1, r = n;
			while (l < r){
				int mid = (l + r) >> 1;
				if (q[mid] >= a[i])
					r = mid;
				else
					l = mid + 1;
			}
			dp[i] = r;
			if (i - d > 0) cmin(q[dp[i - d]], a[i - d]);
		}
		int ans = 0;
		for (int i = 1; i <= n; i++)
			cmax(ans, dp[i]);
		printf("%d\n", ans);
	}
	return 0;
}