HDU 5125 magic balls(线段树+DP)

magic balls

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 323    Accepted Submission(s): 90

Problem Description

The town of W has N people. Each person takes two magic balls A and B every day. Each ball has the volume ai and bi. People often stand together. The wizard will find the longest increasing subsequence in the ball A. The wizard has M energy. Each point of energy can change the two balls’ volume.(swap(ai,bi)).The wizard wants to know how to make the longest increasing subsequence and the energy is not negative in last. In order to simplify the problem, you only need to output how long the longest increasing subsequence is.

 

Input

The first line contains a single integer T(1≤T≤20)(the data for N>100 less than 6 cases), indicating the number of test cases.
Each test case begins with two integer N(1≤N≤1000) and M(0≤M≤1000),indicating the number of people and the number of the wizard’s energy. Next N lines contains two integer ai and bi(1≤ai,bi≤109),indicating the balls’ volume.

 

Output

For each case, output an integer means how long the longest increasing subsequence is.

 

Sample Input

2

 

 

5 3

5 1

4 2

3 1

2 4

3 1

 

5 4

5 1

4 2

3 1

2 4

3 1

 

Sample Output

4

4

 

 

题意是给两个序列 a , b ..

然后问最多用m次操作（ swap(ai,bi) ），使得序列a的最长上升子序列的长度最长

不难想出一个DP就是，dp[i][j][k] 表示最长子序列中最后一个元素是i ，用了j 次操作，k表示元素i有没进行交换(0表示无，1表示有)。

然后转移就是

 

   dp[i][j][0] = max { dp[i][j][0] , dp[k][j][0] }  (  i = 1~ n , j = 0~i , k = 1 ~ i -1 , a[k] < a[i] ) 

   dp[i][j][0] = max { dp[i][j][0] , dp[k][j][1] }  (  i = 1~ n , j = 0~i , k = 1 ~ i -1 , b[k] < a[i] ) 

   dp[i][j][1] = max { dp[i][j][1] , dp[k][j-1][0] }  (  i = 1~ n , j = 0~i-1 , k = 1 ~ i -1 , a[k] < b[i] ) 

   dp[i][j][1] = max { dp[i][j][1] , dp[k][j-1][1] }  (  i = 1~ n , j = 0~i , k = 1 ~ i -1 , b[k] < b[i] ) 

 

O（n）枚举状态第一维 ， O（n）枚举状态第二维。

再用线段树或者树状数组O（log n）来更新状态就行了。

用m棵线段树,每棵线段树表示用了j次操作( j = 0~m ) 。

每棵线段树的每个叶子结点的位置表示数值的大小，区间l~r维护的是l~r数值范围dp的最大值。

那么先将a,b序列离散后，数值范围是0~2000。

 

然后当我们要更新 dp[i][j][0] 的时候，就第j棵线段树找出1~a[i]-1的结点中，用dp的最大值+1 去更新。

dp[i][j][1]，就第j - 1 棵线段树找出1~b[i]-1的结点中，用dp的最大值+1 去更新。

 

注意。假设我们已经维护出dp[i][j][k] , 先不要把状态插入线段树，因为有可能影响到dp[i][j+1][k]的更新。

那么，在更新dp[i+1][][] 之前 ， 把dp[i][][]的所有状态插进线段树就不会影响到更新了。

 

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <algorithm>

using namespace std;

#define root 1,n<<1|1,1
#define lr rt<<1
#define rr rt<<1|1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define X first
#define Y second
typedef long long LL;
typedef pair<int,int> pii;
const int N =  ;
const int M =  ;
const int inf = 1e9+;

int n , m , a[N] , b[N] ;

//----------------------------
int date[N][M<<];

void Up( int id , int rt ) {
    date[id][rt] = max( date[id][lr] , date[id][rr] ) ;
}

void Build( int id , int l , int r , int rt ) {
    date[id][rt] =  ;
    if( l == r ) return ;
    int mid = (l+r)>>;
    Build(id,lson),Build(id,rson);
    Up(id,rt);
}

void Update( int id , int l , int r , int rt , int x , int val ) {
    if( l == r ) {
        date[id][rt] = max( date[id][rt] , val ) ;
        return ;
    }
    int mid = (l+r)>>;
    if( x <= mid ) Update(id,lson,x,val);
    else Update(id,rson,x,val);
    Up(id,rt);
}

int Query( int id , int l , int r , int rt , int L , int R ) {
    if( l == L && r == R ) {
        return date[id][rt];
    }
    int mid = (l+r)>>;
    if( R <= mid ) return Query(id,lson,L,R);
    else if( L > mid ) return Query(id,rson,L,R);
    else return max( Query(id,lson,L,mid) , Query(id,rson,mid+,R) );
}
//----------------------------------

struct node { int x , id , xx ; }e[N<<];
bool cmp1( const node &a , const node &b ) { return a.x < b.x ; }
bool cmp2( const node &a , const node &b ) { return a.id < b.id ; }

void Read() {
    cin >> n >> m ;
    for( int i =  ; i <  * n ; ++i ){
        cin >> e[i].x ; e[i].id = i ;
    }
    sort( e , e +  * n , cmp1 );
    e[].xx =  ;
    for( int i =  ; i <  * n ; ++i ){
        e[i].xx = ( e[i].x == e[i-].x ? e[i-].xx : e[i-].xx +  );
    }
    sort( e , e +  * n , cmp2 );
    int tot =  ;
    for( int i =  ; i <= n ; ++i ) a[i] = e[tot++].xx , b[i] = e[tot++].xx ;

}

vector<pii>A,B;

void Run() {
    int ans =  ;
    for( int i =  ; i <= m ; ++i ) Build( i , root );
    for( int i =  ; i <= n ; ++i ) {
        A.clear() , B.clear();
        for( int j =  ; j <= min( i , m ) ; ++j ) {
                int tmpa = Query( j , root ,  , a[i] -  ) +  ;
                ans = max( ans , tmpa ) ; A.push_back(pii(j,tmpa));
                if( !j ) continue ;
                int tmpb = Query( j -  , root ,  , b[i] -  ) +  ;
                ans = max( ans , tmpb ) ; B.push_back(pii(j,tmpb));
            }
        for( int j =  ; j < A.size() ; ++j ) Update( A[j].X ,root , a[i] , A[j].Y );
        for( int j =  ; j < B.size() ; ++j ) Update( B[j].X ,root , b[i] , B[j].Y );
    }
    cout << ans << endl ;
}

int main()
{
    #ifdef LOCAL
        freopen("in.txt","r",stdin);
    #endif // LOCAL
    ios::sync_with_stdio(false);
    int _ ; cin >> _ ;
    while( _-- )  Read() , Run() ;
}