hdu5125 dp+树状数组

最新推荐文章于 2024-10-12 14:52:57 发布

原创最新推荐文章于 2024-10-12 14:52:57 发布 · 1.2k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#树状数组

树状数组专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种使用树状数组优化动态规划（DP）的方法，以解决HDU5125问题。通过离散化球的值，并针对每个消耗值建立树状数组，可以将时间复杂度降低到nlogn。更新过程中，根据是否交换球，对树状数组进行查询和更新，从而得到以特定值结尾的最大长度。

最朴素的dp是n^3的，肯定会超时，那么借鉴nlogn的LIS算法，先对每个球的值离散化，对于每个消耗值建一棵树状数组，，第t棵树状数组的叶子v表示消耗为t且以v结尾的最大长度，那么每次更新的时候，如果不交换，对每个消耗值t，求消耗值为t以1~a[i]-1结尾的最大长度，如果交换，对每个消耗值t，求消耗值为t-1以1~b[i]-1的最大长度，更新树状数组即可。

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <string>
#define ll long long int
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define delf int m=(l+r)>>1

using namespace std;

int tree[1001][2002];       //消耗为i，以t结尾的最大长度
int a[1100];
int b[1100];
int v[2200];
int n,m,cnt,ans;

int min(int a,int b)
{
    return a<b?a:b;
}

int max(int a,int b)
{
    return a>b?a:b;
}

int id(int x)
{
    return lower_bound(v,v+cnt,x)-v+1;
}

inline int lowbit(int x)
{
    return x&-x;
}

void add(int x,int k,int v)
{
    while (x<=cnt)
    {
        tree[k][x]=max(tree[k][x],v);
        x+=lowbit(x);
    }
    return ;
}

int get_max(int x,int k)
{
    int res=0;
    while (x>0)
    {
        res=max(res,tree[k][x]);
        x-=lowbit(x);
    }
    return res;
}

int main()
{
    int T;
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d%d",&n,&m);
        m=min(n,m);
        for (int i=1;i<=n;i++)
            scanf("%d%d",&a[i],&b[i]);
        cnt=0;
        for (int i=1;i<=n;i++)
            v[cnt++]=a[i];
        for (int i=1;i<=n;i++)
            v[cnt++]=b[i];
        sort(v,v+cnt);
        cnt=unique(v,v+cnt)-v;
        for (int i=1;i<=n;i++)
        {
            a[i]=id(a[i]);
            b[i]=id(b[i]);
        }
        memset(tree,0,sizeof(tree));
        ans=0;
        for (int i=1;i<=n;i++)
        {
            for (int t=m;t>=0;t--)
            {
                int len=1;      //初始长度为1
                len+=get_max(a[i]-1,t);     //不交换
                add(a[i],t,len);            //更新
                ans=max(ans,len);
                if (t>0)        //消耗值大于0，可交换
                {
                    len=1;
                    len+=get_max(b[i]-1,t-1);       //交换之前，消耗值为t-1
                    add(b[i],t,len);        //更新
                    ans=max(ans,len);
                }
            }
        }
        printf("%d\n",ans);
    }
}