poj1769(用线段树来维护dp)

解题思路：详见挑战p207。

dp[i][j]:表示到第i个sorter为止，最大值被移动到第j个位置所需要的最短子序列长度。inf表示不可达。

dp[0][1]=0(0代表没有sorter时，自然只能输出第一位的最大值，需要sorter个数为0）

dp[0][j]=INF(j>1)

dp[i+1][j]=dp[i][j](ti!=j)（如果说第i个sorter的结束位置不为ti，自然不会最大在j的地方）

dp[i+1][j]=min(dp[i][j],min{dp[i][j](si=<j<=ti)}+1)(ti==j)（如果说现在这个sorter在ti的位置停止,那么在目前sorter包括范围内的dp数再加上目前这个sorter就能达到ti了,所以要+1）

但是这样复杂度O(mn)，会超时。其实可以用线段树来维护dp,使得复杂度变为O(mlogn)

为了迎合线段树，dp形式也要改成一维的，但原理和上面是一样的

dp[1]=0,dp[j]=inf(j>1)

dp[ti]=min(dp[ti],min(dp[j])+1,si<t<ti)
 

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct node
{
	int l,r,w;
}s[50009<<2];
const int inf=0x3f3f3f3f;
int a[500009],b[500009];
int dp[50009];
int n,m;
void build(int t,int l,int r)
{
	s[t].l=l;
	s[t].r=r;
	if(l==r)
	{
		s[t].w=dp[l];
		return;
	}
	build(2*t,l,(l+r)/2);
	build(2*t+1,(l+r)/2+1,r);
	s[t].w=min(s[2*t].w,s[2*t+1].w);
}
void update(int t,int l,int r,int w)
{
	if(s[t].l==l&&s[t].r==r)
	{
		s[t].w=w;
		return;
	}
	int mid=(s[t].l+s[t].r)/2;
	if(r<=mid)
	{
		update(2*t,l,r,w);
	}else
	if(l>mid)
	{
		update(2*t+1,l,r,w);
	}else
	{
		update(2*t,l,mid,w);
		update(2*t+1,mid+1,r,w);
	}	
	s[t].w=min(s[2*t].w,s[2*t+1].w);
}
int query(int t,int l,int r)
{
	if(s[t].l==l&&s[t].r==r)
	{
		return s[t].w;
	}
	int mid=(s[t].l+s[t].r)/2;
	if(r<=mid)
	{
		return query(2*t,l,r);
	}else
	if(l>mid)
	{
		return query(2*t+1,l,r);
	}else
	{
		return min(query(2*t,l,mid),query(2*t+1,mid+1,r));
	}
}
void solve()
{
	for(int i=0;i<m;i++)
	{
		dp[b[i]]=min(dp[b[i]],query(1,a[i],b[i])+1);
		update(1,b[i],b[i],dp[b[i]]);
	}
	printf("%d\n",dp[n]);
}
int main()
{
	//freopen("t.txt","r",stdin);
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		for(int i=0;i<m;i++)
		{
			scanf("%d%d",&a[i],&b[i]);
		}
		fill(dp,dp+50009,inf);
		dp[1]=0;
		build(1,1,n);
		solve();
	}
	return 0;
}