hdu 5125 magic balls

看着实验室的小伙伴们写博客 记录学习的点点滴滴，好吧 ，我也心动了。

这是某场BC的第三题，题意大概是 有个N个 人，N<=1000， 每个人有  2个球，球的属性分别是A和B，然后你可以用不超过M次魔法，M<=1000，每次魔法可以使A 和 B 的值互换。 最后问你 A的最长上升子系列是多长。

首先这题 可以想到 最直接明了的转移方式， 用 dp[i][j][0,1], 其中 表示 第i个结尾，用了j 次魔法，最后结束是A还是B。

那么转移方程就是

    if(a[k]<a[i])
                        dp[i][j][0]=max(dp[k][j][0]+1,dp[i][j][0]);
                    if(b[k]<a[i])
                        dp[i][j][0]=max(dp[k][j][1]+1,dp[i][j][0]);
                    if(j>=1)
                    {
                        if(a[k]<b[i])
                            dp[i][j][1]=max(dp[k][j-1][0]+1,dp[i][j][1]);
                        if(b[k]<b[i])
                            dp[i][j][1]=max(dp[k][j-1][1]+1,dp[i][j][1]);
                    }

然后这是N^2*M算法。然后发现其实离散化后，每次转移可以用线段树或者树状数组来维护和查询 做到log级别

所以就可以做了。

下面是AC代码

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;
#define NN 1010
int dp[NN][NN][2];
int a[NN],b[NN];
int c[2*NN];
int mx[NN][2][2*NN];
int lowbit(int x)
{
    return x&(-x);
}
int cnt;
void update(int x,int val,int fg,int d)
{
    while(x<=cnt)
    {
        mx[fg][d][x]=max(mx[fg][d][x],val);
        x+=lowbit(x);
    }
}
int get_mx(int x,int fg,int d)
{
    int ans=0;
    while(x>0)
    {
        ans=max(mx[fg][d][x],ans);
        x-=lowbit(x);
    }
    return ans;
}
int main()
{
    int i,j,k;
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        cnt=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d %d",&a[i],&b[i]);
            c[cnt++]=a[i];
            c[cnt++]=b[i];
        }

        sort(c,c+2*n);
        cnt=unique(c,c+2*n)-c;
        for(i=1;i<=n;i++)
        {
            a[i]=lower_bound(c,c+cnt,a[i])-c+1;
            b[i]=lower_bound(c,c+cnt,b[i])-c+1;
        }
        a[0]=b[0]=0;
        memset(dp,0,sizeof(dp));
        memset(mx,0,sizeof(mx));
        for(i=1;i<=n;i++)
        {

            for(j=0;j<=i&&j<=m;j++)
            {
                dp[i][j][0]=max(get_mx(a[i]-1,j,0)+1,dp[i][j][0]);
                dp[i][j][0]=max(get_mx(a[i]-1,j,1)+1,dp[i][j][0]);
                if(j>=1)
                {
                    dp[i][j][1]=max(get_mx(b[i]-1,j-1,0)+1,dp[i][j][1]);
                    dp[i][j][1]=max(get_mx(b[i]-1,j-1,1)+1,dp[i][j][1]);
                }
            }
            for(j=0;j<=i&&j<=m;j++)
            {
                update(a[i],dp[i][j][0],j,0);
                update(b[i],dp[i][j][1],j,1);
            }
        }
        int ans=0;
        for(i=1;i<=n;i++)
            for(j=0;j<=m;j++)
                for(k=0;k<=1;k++)
                    ans=max(dp[i][j][k],ans);
        printf("%d\n",ans);
    }
    return 0;
}