POJ 2374 Fence Obstacle Course

题目链接：http://poj.org/problem?id=2374

DP+线段树

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

using namespace std;

const int MAXN = 100000;
const int MAXSIZE = MAXN << 1;
const int INF = 2147483645;

struct Fence
{
    int st, ed;
};

int N, S;
Fence F[ MAXN + 10 ];
int up[ ( MAXSIZE << 2 ) + 10 ], flag[ ( MAXSIZE << 2 ) + 10 ];
int dp[50010][2];
int MinBound, MaxBound;

void PushDown( int rt )
{
    int lc = rt << 1;
    int rc = rt << 1 | 1;
    if ( flag[rt] != -1 )
    {
        flag[lc] = flag[rc] = flag[rt];
        up[lc] = up[rc] = flag[rt];
        flag[rt] = -1;
    }
    return;
}

void Update( int L, int R, int c, int l, int r, int rt )
{
    if ( L <= l && r <= R )
    {
        up[rt] = c;
        flag[rt] = c;
        return;
    }
    PushDown( rt );

    int m = ( l + r ) >> 1;
    if ( L <= m ) Update( L, R, c, lson );
    if ( R > m ) Update( L, R, c, rson );

    return;
}

int Query( int L, int l, int r, int rt )
{
    if ( L == l && L == r )
    {
        return up[rt];
    }
    PushDown(rt);

    int m = ( l + r ) >> 1;
    if ( L <= m ) return Query( L, lson );
    else return Query( L, rson );
}

void Solved()
{
    memset( dp[0], 0, sizeof(dp[0]) );

    for ( int i = 1; i <= N; ++i )
    {
        int left = Query( F[i].st, MinBound, MaxBound, 1 );
        int right = Query( F[i].ed, MinBound, MaxBound, 1 );
        //printf( "left=%d right=%d\n", left, right );

        dp[i][0] = min( dp[left][0] + abs( F[left].st - F[i].st ) , dp[left][1] + abs( F[left].ed - F[i].st ) );
        dp[i][1] = min( dp[right][0] + abs( F[right].st - F[i].ed ) , dp[right][1] + abs( F[right].ed - F[i].ed ) );

        Update( F[i].st, F[i].ed, i, MinBound, MaxBound, 1 );
    }

    int ans = min( dp[N][0] + abs( F[N].st - S - MAXN ), dp[N][1] + abs( F[N].ed - S - MAXN ) );
    printf( "%d\n", ans );

    return;
}

int main()
{
    while ( ~scanf( "%d%d", &N, &S ) )
    {
        MinBound = INF;
        MaxBound = -1;

        F[0].st = 0 + MAXN;
        F[0].ed = 0 + MAXN;

        for ( int i = 1; i <= N; ++i )
        {
            scanf( "%d%d", &F[i].st, &F[i].ed );
            F[i].st += MAXN;
            F[i].ed += MAXN;
            MinBound = min( MinBound, F[i].st );
            MaxBound = max( MaxBound, F[i].ed );
        }

        memset( up, 0, sizeof(up) );
        memset( flag, -1, sizeof(flag) );

        Solved();
    }
    return 0;
}