ZOJ 3650 Toy Blocks(线段树+DP)

转载请注明出处，谢谢http://blog.youkuaiyun.com/acm_cxlove/article/details/7854526       by---cxlove

题目：在一个数轴上，某些位置，有一些多米诺，问最少推动几个没有倒下的，可以把所有的都推倒

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4840 

这题主要参考CWJ的做法，太弱了，哎

感觉如果比赛这种题目，即使有想法，也写不出来，容易乱

http://edward-mj.com/?p=615

首先可能有的位置有多个，那么显然保留最大的，这是要注意的地方 。

对于每一个多米诺，先预处理出能推倒的最左边的位置，以及最右边的位置

这一步又分为两个步骤，首先可以通过二分求出，当前木块倒下能推倒的最左边的位置

第二步是，当前木块倒下，会产生连锁反应，通过线段树的区间最值得到间接能推倒的最左边的位置。

然后是DP过程，主要就是两个转移，往左推和往右推，详见代码

#include<iostream>
#include<cstdio>
#include<map>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<queue>
#define inf 1<<30
#define M 6000005
#define N 110005
#define maxn 300005
#define eps 1e-8
#define zero(a) fabs(a)<eps
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mem(a,b) memset(a,b,sizeof(a))
#define LL long long
#define lson step<<1
#define rson step<<1|1
using namespace std;
class Seg_Tree
{
public:
    struct Node
    {
        int left,right,mx,mn,cover;
    }L[N*4];
    //向上更新
    void Push_Up(int step)
    {
        if(L[step].left==L[step].right) return;
        L[step].mx=max(L[lson].mx,L[rson].mx);
        L[step].mn=min(L[lson].mn,L[rson].mn);
    }
    //向下更新延迟标记，以前更新最小值
    //向下更新操作主要用于最后一次的区间更新，所以最大值不需要管
    void Push_Down(int step)
    {
        if(L[step].cover!=inf)
        {
            L[step].mn=min(L[step].cover,L[step].mn);
            if(L[step].left!=L[step].right)
            {
                L[lson].cover=min(L[step].cover,L[lson].cover);
                L[rson].cover=min(L[step].cover,L[rson].cover);
            }
            L[step].cover=inf;
        }
    }
    void Bulid(int step,int l,int r,int val)
    {
        L[step].left=l;
        L[step].right=r;
        L[step].cover=inf;
        if(l==r)
        {
            L[step].mx=L[step].mn=val;
            return;
        }
        int m=(l+r)/2;
        Bulid(lson,l,m,val);
        Bulid(rson,m+1,r,val);
        Push_Up(step);
    }
    //点更新
    void Update(int step,int pos,int val)
    {
        if(L[step].left==pos&&L[step].right==pos)
        {
            L[step].mx=L[step].mn=val;
            return;
        }
        int m=(L[step].left+L[step].right)/2;
        if(pos<=m) Update(lson,pos,val);
        else if(pos>m) Update(rson,pos,val);
        Push_Up(step);
    }
    //段更新，用到懒惰标记
    void Update(int step,int l,int r,int val)
    {
        if(L[step].left==l&&L[step].right==r)
        {
            L[step].cover=min(L[step].cover,val);
            return;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) Update(lson,l,r,val);
        else if(l>m) Update(rson,l,r,val);
        else
        {
            Update(lson,l,m,val);
            Update(rson,m+1,r,val);
        }
        Push_Up(step);
    }
    int Query_Max(int step,int l,int r)
    {
        Push_Down(step);
        if(L[step].left==l&&L[step].right==r)
        {
            return L[step].mx;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) return Query_Max(lson,l,r);
        else if(l>m) return Query_Max(rson,l,r);
        else return max(Query_Max(lson,l,m),Query_Max(rson,m+1,r));
    }
    int Query_Min(int step,int l,int r)
    {

        Push_Down(step);
        if(L[step].left==l&&L[step].right==r)
        {
            return L[step].mn;
        }
        int m=(L[step].left+L[step].right)/2;
        if(r<=m) return Query_Min(lson,l,r);
        else if(l>m) return Query_Min(rson,l,r);
        else return min(Query_Min(lson,l,m),Query_Min(rson,m+1,r));
    }
}seg;
map<int,int>m;
int l[N],r[N],x[N],h[N],cnt;
int dp[N],n;
int DP()
{
    //注意这里的初始化为inf,然后每次更新最小值
    seg.Bulid(1,0,cnt-1,inf);
    for(int i=0;i<cnt;i++)
    {
        //推动这个木块，可以把左边的都推倒，则更新为1
        //更新往左推的
        if(l[i]==0) seg.Update(1,i,i,1);
        else seg.Update(1,i,i,seg.Query_Min(1,l[i]-1,i-1)+1);
        //dp[i-1]为0-(i-1)都处理掉的，然后更新第i个往右推
        int pre=i?(dp[i-1]+1):1;
        seg.Update(1,i,r[i],pre);
        dp[i]=seg.Query_Min(1,i,i);
    }
    return dp[cnt-1];
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        m.clear();
        for(int i=0;i<n;i++)
        {
            int x,h;
            scanf("%d%d",&x,&h);
            if(m.find(x)==m.end()) m[x]=h;
            else if(h>m[x]) m[x]=h;
        }
        map<int,int>::iterator it;
        cnt=0;
        //map离散化，由于每个位置的木块可能有多个，取个最高的
        for(it=m.begin();it!=m.end();it++)
        {
            x[cnt]=it->first;
            h[cnt++]=it->second;
        }
        l[0]=0;
        for(int i=1;i<cnt;i++)
        {
            int low=0,high=i,mid,ans;
            //二分查找，能直接推倒的最左边的
            while(low<=high)
            {
                mid=(low+high)>>1;
                if(x[i]-x[mid]<=h[i])
                {
                    ans=mid;
                    high=mid-1;
                }
                else low=mid+1;
            }
            l[i]=ans;

        }
        seg.Bulid(1,0,cnt-1,0);
        for(int i=0;i<cnt;i++)
        {
            seg.Update(1,i,l[i]);
            //查找他本身能直接推倒的区间内的最左边的，也就是间接能推倒的最左边的
            l[i]=seg.Query_Min(1,l[i],i);
            seg.Update(1,i,l[i]);
        }
        //以下处理能推倒的最右边的，同上
        r[cnt-1]=cnt-1;
        for(int i=cnt-2;i>=0;i--)
        {
            int low=i,high=cnt-1,mid,ans;
            while(low<=high)
            {
                mid=(low+high)>>1;
                if(x[mid]-x[i]<=h[i])
                {
                    ans=mid;
                    low=mid+1;
                }
                else high=mid-1;
            }
            r[i]=ans;
        }
        seg.Bulid(1,0,cnt-1,0);
        for(int i=cnt-1;i>=0;i--)
        {
            seg.Update(1,i,r[i]);
            r[i]=seg.Query_Max(1,i,r[i]);
            seg.Update(1,i,r[i]);
        }
        printf("%d\n",DP());
    }
    return 0;
}