zoj (单点更新区间查询：线段树)

题意：有n天，每天都可以买西瓜，每个西瓜的价格是ai，每个西瓜能吃bi天。问这n天每天都有西瓜吃的最小的代价是多少？如果你在第i天买了一个西瓜，那么之前买的西瓜就要全部扔掉，才能开始吃新的西瓜。

定义dp[i]为到i天为止，每天都有西瓜吃的最小代价，那么状态转移方程就是：dp[i]=min(dp[i],dp[i-k-1]+a[i-k])。这样时间复杂度会达到O(n^2)，所以要优化。在递推的过程中，我们达到第i-k天之后，去更新第i-k+1天到第i天的代价。如果我们能一次性更新这些范围，就可以将复杂度降下来，优化的方法就是线段树。

转化的方法还是挺巧妙的。对于第i-k天，我们只去更新第i天这个点，然后在查询的时候，我们查询的是第i天到第n天里的最小值，因为如果我们得到的是在第i天到 第n天的某一个最小值，那么这个最小值一定是在第i天或第i-1天前更新到的。可以仔细想想。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define N 50005
using namespace std;
const long long Max=pow(10,10);
int n;
long long  a[N];
long long  b[N];
long long  dp[N];
long long  tree[N*4];
void built(int L,int R,int fa)
{
    tree[fa]=Max;
    if(L==R)
    return ;
    int mid=(L+R)/2;
    built(L,mid,fa*2);
    built(mid+1,R,fa*2+1);
}
int idex;
long long  val;
void uptate(int L,int R,int fa)
{
    if(L==R)
    {
        tree[fa]=min(val,tree[fa]);
        return;
    }
    int mid=(L+R)/2;
    if(idex<=mid)
      uptate(L,mid,fa*2);
    else
      uptate(mid+1,R,fa*2+1);
    tree[fa]=min(tree[fa*2],tree[2*fa+1]);
}

int LL,RR;
long long query(int L,int R,int fa)
{
    if(LL<=L&&RR>=R)
    return tree[fa];
    int mid=(R+L)/2;
    long long t1=Max;
    long long t2=Max;
    if(LL<=mid)
    t1=query(L,mid,fa*2);
    if(RR>mid)
    t2=query(mid+1,R,fa*2+1);
    return min(t1,t2);
}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
         scanf("%lld",&a[i]);
        for(int j=1;j<=n;j++)
         scanf("%lld",&b[j]);
        built(1,n,1);
        dp[0]=0;
        for(int i=1;i<=n;i++)
        {
            int last=i+b[i]-1;
            last=min(n,last);
            idex=last;
            val=dp[i-1]+a[i];
            uptate(1,n,1);
            LL=i;
            RR=n;
            dp[i]=query(1,n,1);
        }
      printf("%lld\n",dp[n]);
    }
    return 0;
}