POJ 3162 树形DP+单调队列

题目链接

题意：

给一颗树先求树上各点最远可到距离（HDU 2196），然后求最长区间长度，并且这个区间内最远距离的最值差<=m。

思路：

求最远可到距离，参考HDU 2196。求最值差，我们用单调队列进行计算。

q1将在当前区间的最小值保存在队列开头

q2将在当前区间的最大值保存在队列开头

当右端点向右移动时，为保证q1的队列开头为最小值，需要将q1内所有大于等于当前值的数全部扔出队列，同理为保证q2的队列开头为最大值，需要将q2内所有小于等于当前值的数全部扔出队列。

当左端点向右移动时，为保证q1，q2队列中的最值为有效的所以需要将不是区间内的数全部扔出队列。

C++代码：

#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<queue>
#include<vector>
#include<string>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1000010;

int n,m,tol,head[maxn];
struct edge
{
    int to,next,cost;
}es[maxn];

void addedge( int u , int v , int w )
{
    es[tol].to = v;
    es[tol].cost = w;
    es[tol].next = head[u];
    head[u]  = tol++;
}

int dp[maxn][5],son[maxn];

void dfs1( int u , int f )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to,w = es[i].cost;
        if ( v!=f )
        {
            dfs1( v , u );
            if ( son[u]==-1||dp[v][0]+w>dp[u][0] )
            {
                dp[u][1] = dp[u][0];
                dp[u][0] = dp[v][0]+w;
                son[u] = v;
            }
            else if ( dp[v][0]+w<=dp[u][0]&&dp[v][0]+w>dp[u][1] )
            {
                dp[u][1] = dp[v][0]+w;
            }
        }
    }
}

void dfs2( int u , int f )
{
    for ( int i=head[u] ; i!=-1 ; i=es[i].next )
    {
        int v = es[i].to,w = es[i].cost;
        if ( v!=f )
        {
            if ( v!=son[u] )
                dp[v][2] = w+max(dp[u][0],dp[u][2]);
            else
                dp[v][2] = w+max(dp[u][1],dp[u][2]);
            dfs2( v , u );
        }
    }
}

int q1[maxn],l1,r1;
int q2[maxn],l2,r2;

int slove()
{
    int ans = 0;
    l1 = r1 = 0;
    l2 = r2 = 0;
    for ( int i=1,j=1 ; j<=n ; j++ )
    {
        while( l1<r1&&dp[q1[r1-1]][3]>=dp[j][3] ) r1--;
        q1[r1++] = j;
        while( l2<r2&&dp[q2[r2-1]][3]<=dp[j][3] ) r2--;
        q2[r2++] = j;
        if ( dp[q2[l2]][3]-dp[q1[l1]][3]<=m )
        {
            ans = max( ans , j-i+1 );
        }
        else
        {
            i++;
            while( l1<r1&&q1[l1]<i ) l1++;
            while( l2<r2&&q2[l2]<i ) l2++;
        }
    }
    return ans;
}

int main()
{
    while( scanf( "%d%d" , &n , &m )==2 )
    {
        tol = 0; memset( head , -1 , sizeof(head) );
        for ( int i=2 ; i<=n ; i++ )
        {
            int f,w; scanf( "%d%d" , &f , &w );
            addedge( f , i , w );
        }
        memset ( dp , 0 , sizeof(dp) );
        memset ( son , -1 , sizeof(son) );
        dfs1( 1 , 0 );
        dfs2( 1 , 0 );
        for ( int i=1 ; i<=n ; i++ )
            dp[i][3] = max( dp[i][0] , dp[i][2] );
        printf ( "%d\n" , slove() );
    }
    return 0;
}