ZOJ3349——Special Subsequence

Special Subsequence

Now your task is to find the longest special subsequence of a certain sequence
S

Input

There are no more than 15 cases , process till the end-of-file

The first line of each case contains two integer n and d ( 1<=n<=100000 ,0<=d<=100000000) as in the description.

The second line contains exact n integers , which consist the sequnece
S .Eachinteger is in the range [0,100000000] .There is blank between each integer.

There is a blank line between two cases

Output

For each case , print the maximum length of special subsequence you can get.

Sample Input

5 2
1 4 3 6 5

5 0
1 2 3 4 5

Sample Output

3
1

水dp+水线段树

哈哈今天的第一个1Y

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int dp[N], xis[N], arr[N];
int n, d, cnt;

struct node
 {
 	int l, r;
 	int val;
 }tree[N << 2];

 int BinSearch(int x)
 {
 	int l = 1, r = cnt, mid;
 	while (l <= r)
 	{
 		mid = (l + r) >> 1;
 		if (xis[mid] > x)
 		{
 			r = mid - 1;
 		}
 		else if (xis[mid] < x)
 		{
 			l = mid + 1;
 		}
 		else
 		{
 			break;
 		}
 	}
 	return mid;
 } 

int left_binsearch(int x)
{
	int l = 1, r = cnt, mid, ans = -1;
	while (l <= r)
	{
		mid = (l + r) >>1;
		if (xis[mid] >= x)
		{
			ans = mid;
			r = mid - 1;
		}
		else
		{
			l = mid + 1;
		}
	}
	return ans;
}

int right_binsearch(int x)
{
	int l = 1, r = cnt, mid, ans = -1;
	while (l <= r)
	{
		mid = (l + r) >>1;
		if (xis[mid] <= x)
		{
			ans = mid;
			l = mid + 1;
		}
		else
		{
			r = mid - 1;
		}
	}
	return ans;
}

 void build(int p, int l, int r)
 {
 	tree[p].l = l;
 	tree[p].r = r;
 	tree[p].val = -1;
 	if (l == r)
 	{
 		return;
 	}
 	int mid = (l + r) >> 1;
 	build(p << 1, l, mid);
 	build(p << 1 | 1, mid + 1, r);
 }

 void update(int p, int pos, int val)
 {
 	if (tree[p].l == tree[p].r)
 	{
 		tree[p].val = max(tree[p].val, val);
 		return;
 	}
 	int mid = (tree[p].l + tree[p].r) >> 1;
 	if (pos <= mid)
 	{
 		update(p << 1, pos, val);
 	}
 	else
 	{
 		update(p << 1 | 1, pos, val);
 	}
 	tree[p].val = max(tree[p << 1].val, tree[p << 1 | 1].val);
 }

 int query(int p, int l, int r)
 {
 	if (l <= tree[p].l && r >= tree[p].r)
 	{
 		return tree[p].val;
 	}
 	int mid = (tree[p].l + tree[p].r) >> 1;
 	if (r <= mid)
 	{
 		return query(p << 1, l, r);
 	}
 	else if (l > mid)
 	{
 		return query(p << 1 | 1, l, r);
 	}
 	else
 	{
 		return max(query(p << 1, l, mid), query(p << 1 | 1, mid + 1, r));
 	}
 }

int main()
{
	while(~scanf("%d%d", &n, &d))
	{
		cnt = 0;
		int ans = 0;
		memset (dp, 0, sizeof(dp));
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &arr[i]);
			xis[++cnt] = arr[i];
		}
		sort (xis + 1, xis + cnt + 1);
		cnt = unique(xis + 1, xis + cnt + 1) - xis - 1;
		build(1, 1, cnt);
		for (int i = 1; i <= n; ++i)
		{
			int cur = BinSearch(arr[i]);
			int l = left_binsearch(arr[i] - d);
			int r = right_binsearch(arr[i] + d);
			if (l < 0)
			{
				l = 1;
			}
			if (r < 0)
			{
				r = cnt;
			}
			int tmp = query(1, l, r);
			if (tmp == -1)
			{
				dp[i] = 1;
			}
			else
			{
				dp[i] = tmp + 1;
			}
			update(1, cur, dp[i]);
			ans = max(ans, dp[i]);
		}
		printf("%d\n", ans);
	}
	return 0;
}