hdu--5124--5125-bc

这2题放一起吧 反正都是同一场的.

B题 虽然是被自己想复杂了 用了树状数组。。

当时自己还没离散化出来 还是用了超神的离散化 ‘

不知道自己的哪边错了 ffffffk

<区间更新  单点查询>

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int res;
const int size = 100010*3;
struct data
{
    int L;
    int R;
}node[size];
int lisan[size] , a[size] , tree[size];

int lowBit( int x )
{
    return x & -x;
}

void update( int index , int var )
{
    while( index<=res )
    {
        tree[index] += var;
        index += lowBit( index );
    }
}

int getSum( int index )
{
    int sum = 0;
    while( index )
    {
        sum += tree[index];
        index -=lowBit( index );
    }
    return sum;
}

int main()
{
    cin.sync_with_stdio(false);
    int t , n , ans , cnt;
    cin >> t;
    while( t-- )
    {
        cin >> n;
        memset( tree , 0 , sizeof(tree) );
        res = cnt = 1;
        for( int i = 1 ; i<=n ; i++ )
        {
            cin >> node[i].L >> node[i].R;
            a[cnt++] = node[i].L;
            a[cnt++] = node[i].R;
        }
        sort( a+1 , a+cnt );
        for( int i = 1 ; i<cnt ; i++ )
        {
            if (i == 1)
            {
                lisan[a[i]] = ++res;
            }
            else if (a[i] == a[i - 1])
            {
                lisan[a[i]] = lisan[a[i - 1]];
            }
            else
            {
                lisan[a[i]] = ++res;
            }
        }
        for( int i = 1 ; i<=n ; i++ )
        {
            update(  lisan[ node[i].L ] , 1 );
            update( lisan[ node[i].R ]+1 , -1 );
        }
        ans = 0;
        for( int i = 1 ; i<=cnt ; i++ )
        {
            ans = max( ans , getSum(i) );
        }
        cout << ans << endl;
    }
    return 0;
}

这题最好的解决方法吧 应该是这个吧

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;

vector< pair<int,int> >ve;

int main( )
{
    cin.sync_with_stdio(false);
    int t , n , ans , sum , x , y , veSize;
    cin >> t;
    while( t-- )
    {
        cin >> n;
        ve.clear();
        for( int i = 0 ; i<n ; i++ )
        {
            cin >> x >> y;
            ve.push_back( make_pair(x,1) );
            ve.push_back( make_pair(y+1,-1) );
        }
        ans = sum = 0;
        veSize = ve.size();
        sort( ve.begin() , ve.end() );
        for( int i = 0 ; i<veSize ; i++ )
        {
            sum += ve[i].second;
            ans = max( ans , sum );
        }
        cout << ans << endl;
    }
    return 0;
}

另外一个dp还没出  明天再想吧 累。。。

/*

第一次碰到需要使用线段树或者树状数组来维护dp。。太渣 ...

参考了   传送

自己也写了遍自己代码风格的代码

dp[x,y]表示操作数还剩余x次以y结尾的最大子序列长度

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int tot;
const int size = 2010;
int tree[size][size];
int a[size] , b[size] , c[size];

int lowBit( int x )
{
    return x & -x ;
}

void update( int oper , int index , int var )
{
    while( index<=tot )
    {
        tree[oper][index] = max( tree[oper][index] , var );
        index += lowBit( index );
    }
}

int getSum( int oper , int index )
{
    int sum = 0;
    while( index )
    {
        sum = max( sum , tree[oper][index] );
        index -= lowBit( index );
    }
    return sum;
}

int main()
{
    cin.sync_with_stdio(false);
    int t , n , m , temp , ans;
    cin >> t;
    while( t-- )
    {
        cin >> n >> m;
        ans = tot = 1;
        for( int i = 0 ; i<n ; i++ )
        {
            cin >> a[i] >> b[i];
            c[ tot++ ] = a[i];
            c[ tot++ ] = b[i];
        }
        memset( tree , 0 , sizeof(tree) );
        sort( c+1 , c+tot );
        tot = unique( c+1 , c+tot ) - c;
        for( int i = 0 ; i<n ; i++ )
        {
            a[i] = lower_bound( c+1 , c+tot , a[i] ) - c;
            b[i] = lower_bound( c+1 , c+tot , b[i] ) - c;
        }
        for( int i = 0 ; i<n ; i++ )
        {
            for( int j = 0 ; j<=m ; j++ )
            {
                temp = getSum( j , a[i]-1 ) + 1;
                update( j , a[i] , temp );
                ans = max( temp , ans );
                if( j<m )
                {
                    temp = getSum( j+1 , b[i]-1 ) + 1;
                    update( j , b[i] , temp );
                    ans = max( temp , ans );
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}

 当然我也可以将dp[x,y]定义为操作了x次后以y结尾的最大子序列长度 只要这样修改一下

        for( int i = 0 ; i<n ; i++ )
        {
            for( int j = m ; j>=0 ; j-- )
            {
                temp = getSum( j , a[i]-1 ) + 1;
                update( j , a[i] , temp );
                ans = max( temp , ans );
                if( j )
                {
                    temp = getSum( j-1 , b[i]-1 ) + 1;
                    update( j , b[i] , temp );
                    ans = max( temp , ans );
                }
            }
        }

 这边有个地方一定要注意

就是对于次数m的遍历   当我们定义为剩余x次操作的时候 是顺序遍历的

当我定义为已经操作了已经操作了x次的时候 是要逆序遍历的

但我无法很好的解释 如果谁能给个清晰的解释 不妨留下评论 thx