codeforces 488D Strip 线段树+dp+二分

最新推荐文章于 2020-11-25 21:50:01 发布

AC_vitasoy

最新推荐文章于 2020-11-25 21:50:01 发布

阅读量717

点赞数

分类专栏：动态规划——普通dp 数据结构——树状数组、线段树基本算法——二分 OJ——Codeforces 文章标签： codeforces 488D Strip

本文链接：https://blog.csdn.net/u011580493/article/details/41895259

版权

OJ——Codeforces 同时被 3 个专栏收录

49 篇文章 0 订阅

订阅专栏

动态规划——普通dp

33 篇文章 0 订阅

订阅专栏

基本算法——二分

25 篇文章 0 订阅

订阅专栏

博客介绍了如何使用线段树和动态规划求解codeforces 488D题目，要求将数列分割成满足特定条件的块，以达到最少的块数。通过建立两颗线段树，分别用于查询区间最大最小值和dp的最小值，利用二分查找优化复杂度到nlogn。

摘要由CSDN通过智能技术生成

题意：

给你n个数，把这n个数分了几块(piece)，问你最后分得的最少块数。

要求：1.每块长度>=L 2.每块的最大最小值的差值不得大于s

思路：

很容易想到了用dp，但O（n^2）明显会超时。查询区间最大最小值，自然想到线段树。

因此。可以这样来实现：

定义dp[i]:前i个数，分割的最小块数。

转移：dp[i] = min(dp[j]+1)；（i-j>=l)

建两颗线段树，一颗用来保存区间最大最小值，一颗用来保存区间dp的最小值。

二分查找线段树①中，从当前点i所能往前延伸的位置，记为idx；

然后查询线段树②，区间[idx-1， r-l]的最小值。

每次更新完dp[i]后，都去更新线段树②

这样复杂度就降到了nlogn

code：（代码很挫，直接写了两颗线段树出来= =）

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int MAXN = 1e5+5;
const int INF = 0x3f3f3f3f;

#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
#define start 1, n, 1

int n, s, l;
int a[MAXN], dp[MAXN];
int tmin, tmax;
int st2[MAXN<<2];

struct Node
{
    int maxval, minval;
}st[MAXN<<2];

void build(int l, int r, int rt)
{
    if(l == r)
    {
        cin>>st[rt].maxval;
        st[rt].minval = st[rt].maxval;
        return;
    }
    int mid = (l+r)/2;
    build(lson);
    build(rson);

    //pushUp
    st[rt].minval = min(st[rt<<1].minval, st[rt<<1|1].minval);
    st[rt].maxval = max(st[rt<<1].maxval, st[rt<<1|1].maxval);
}
void query(int l, int r, int rt, int x, int y)
{
    if(x <= l && y >= r)
    {
        tmin = min(tmin, st[rt].minval);
        tmax = max(tmax, st[rt].maxval);
        return ;
    }
    int mid = (l+r)/2;
    if(x <= mid)
        query(lson, x, y);
    if(y > mid)
        query(rson, x, y);
}

int bs(int i, int j)
{
    int l = j, r = i;
    int ret = -1;
    while(l <= r)
    {
        int mid = (l+r)/2;
        tmax = INT_MIN, tmin = INT_MAX;
        query(start, mid, i);
        if(tmax-tmin > s) l = mid+1;
        else
        {
            ret = mid;
            r = mid-1;
        }
    }
    return ret;
}
int query2(int l, int r, int rt, int x, int y)
{
    if(x <= l && y >= r)
        return st2[rt];
    int mid = (l+r)/2;
    int ret = INT_MAX;
    if(x <= mid) ret = min(ret, query2(lson, x, y));
    if(y > mid) ret = min(ret, query2(rson, x, y));
    return ret;
}
void update2(int l, int r, int rt, int x, int val)
{
    if(l == r)
    {
        st2[rt] = min(st2[rt], val);
        return ;
    }
    int mid = (l+r)/2;
    if(x <= mid) update2(lson, x, val);
    else update2(rson, x, val);

    //pushUp
    st2[rt] = min(st2[rt<<1], st2[rt<<1|1]);
}
void solve()
{
    memset(dp, INF, sizeof(dp));
    memset(st2, INF, sizeof(st2));
    for(int i = l; i <= n; i++)
    {
        tmax = INT_MIN, tmin = INT_MAX;
        query(start, 1, i);
        if(tmax - tmin <= s)
        {
            dp[i] = 1;
            update2(start, i, dp[i]);
            continue;
        }

        int idx = bs(i, l);     //binary search to find the left bound;
        //cout<<"i = "<<i<<endl;
        //cout<<"idx = "<<idx<<endl;
        //cout<<"i-l = "<<i-l<<endl;
        if(idx == -1 || i-l+1 < idx) continue;

        int tt = query2(start, idx-1, i-l);       //query the [idx~ i-l] to confirm the min val;
        dp[i] = min(dp[i], tt + 1);
        update2(start, i, dp[i]);
    }
    if(dp[n] == INF)
        cout<<"-1"<<endl;
    else
        cout<<dp[n]<<endl;
}

int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>s>>l;
    build(start);
    solve();
    return 0;
}