POJ 3162 Walking Race（树形dp+单调队列 or 线段树）

http://poj.org/problem?id=3162

题意：
一棵n个节点的树。有一个屌丝爱跑步，跑n天，第i天从第i个节点开始跑步，每次跑到距第i个节点最远的那个节点（产生了n个距离），现在要在这n个距离里取连续的若干天，使得这些天里最大距离和最小距离的差小于M，问怎么取使得天数最多？

思路：
这道题目求最远距离和HDU 2196是一模一样的，这个不是很难。关键是要怎么处理得到的数据。

可以用单调队列做也可以用线段树来做，先介绍一下单调队列。

因为有最大值和最小值，所以我们需要两个单调队列，一个维护最大值，另一个维护最小值。

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<sstream>
 #include<vector>
 #include<stack>
 #include<queue>
 #include<cmath>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long ll;
 typedef pair<int,ll> pll;
 const int INF = 0x3f3f3f3f;
 const int maxn=1e6+;

 int n, m;
 int tot;
 ll d[maxn][];
 int path[maxn];
 int head[*maxn];
 int q_max[maxn];
 int q_min[maxn];

 struct node
 {
     int v,w,next;
 }e[*maxn];

 void addEdge(int u,int v,int w)
 {
     e[tot].v=v;
     e[tot].w=w;
     e[tot].next=head[u];
     head[u]=tot++;
 }

 void dfs1(int u,int fa)
 {
     d[u][]=d[u][]=;
     path[u]=-;
     for(int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         if(v==fa)  continue;
         dfs1(v,u);
         if(d[u][]<d[v][]+e[i].w)
         {
             path[u]=v;
             d[u][]=d[u][];
             d[u][]=d[v][]+e[i].w;
         }
         else if(d[u][]<d[v][]+e[i].w)
             d[u][]=d[v][]+e[i].w;
     }
 }

 void dfs2(int u,int fa)
 {
     for(int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         if(v==fa)  continue;
         if(path[u]==v)  d[v][]=max(d[u][],d[u][])+e[i].w;
         else  d[v][]=max(d[u][],d[u][])+e[i].w;
         dfs2(v,u);
     }
 }

 int main()
 {
     //freopen("in.txt","r",stdin);
     while(~scanf("%d%d",&n,&m))
     {
         tot=;
         memset(head,-,sizeof(head));
         for(int i=;i<=n;i++)
         {
             int v,w;
             scanf("%d%d",&v,&w);
             addEdge(i,v,w);
             addEdge(v,i,w);
         }
         dfs1(,-);
         dfs2(,-);
         int ans=-;
         int frt_max=,rear_max=;
         int frt_min=,rear_min=;
         for(int i=,j=;i<=n;i++)
         {
             d[i][]=max(d[i][],d[i][]);
             while(frt_max<rear_max && d[q_max[rear_max-]][]<d[i][])  rear_max--;
             q_max[rear_max++]=i;
             while(frt_min<rear_min && d[q_min[rear_min-]][]>d[i][])  rear_min--;
             q_min[rear_min++]=i;

             while(frt_max<rear_max && frt_min<rear_min && d[q_max[frt_max]][]-d[q_min[frt_min]][]>m)
             {
                 if(q_max[frt_max]>q_min[frt_min])   {j=q_min[frt_min]+;frt_min++;}
                 else {j=q_max[frt_max]+;frt_max++;}
             }
             ans=max(ans,i-j+);
         }
         printf("%d\n",ans);
     }
     return ;
 }

单调队列

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<sstream>
 #include<vector>
 #include<stack>
 #include<queue>
 #include<cmath>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long ll;
 typedef pair<int,ll> pll;
 const int INF = 0x3f3f3f3f;
 const int maxn=1e6+;

 int n, m;
 int tot;
 ll d[maxn][];
 int path[maxn];
 int head[*maxn];

 int MAX[maxn<<];
 int MIN[maxn<<];
 int query_max,query_min;

 struct node
 {
     int v,w,next;
 }e[*maxn];

 void addEdge(int u,int v,int w)
 {
     e[tot].v=v;
     e[tot].w=w;
     e[tot].next=head[u];
     head[u]=tot++;
 }

 /**********************************************
 dfs
 **********************************************/

 void dfs1(int u,int fa)
 {
     d[u][]=d[u][]=;
     path[u]=-;
     for(int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         if(v==fa)  continue;
         dfs1(v,u);
         if(d[u][]<d[v][]+e[i].w)
         {
             path[u]=v;
             d[u][]=d[u][];
             d[u][]=d[v][]+e[i].w;
         }
         else if(d[u][]<d[v][]+e[i].w)
             d[u][]=d[v][]+e[i].w;
     }
 }

 void dfs2(int u,int fa)
 {
     for(int i=head[u];i!=-;i=e[i].next)
     {
         int v=e[i].v;
         if(v==fa)  continue;
         if(path[u]==v)  d[v][]=max(d[u][],d[u][])+e[i].w;
         else  d[v][]=max(d[u][],d[u][])+e[i].w;
         dfs2(v,u);
     }
 }

 /**********************************************
 线段树
 **********************************************/

 void PushUp(int o)
 {
     MAX[o]=max(MAX[o<<],MAX[o<<|]);
     MIN[o]=min(MIN[o<<],MIN[o<<|]);
 }

 void build(int l, int r, int o)
 {
     if(l==r)
     {
         MAX[o]=MIN[o]=max(d[l][],d[l][]);
         return;
     }
     int mid=(l+r)/;
     build(l,mid,o<<);
     build(mid+,r,o<<|);
     PushUp(o);
 }

 void query(int ql, int qr, int l, int r, int o)
 {
     if(ql<=l && qr>=r)
     {
         query_max=max(query_max,MAX[o]);
         query_min=min(query_min,MIN[o]);
         return;
     }
     int mid=(l+r)/;
     if(ql<=mid)  query(ql,qr,l,mid,o<<);
     if(mid<qr)   query(ql,qr,mid+,r,o<<|);
 }

 int main()
 {
     //freopen("in.txt","r",stdin);
     while(~scanf("%d%d",&n,&m))
     {
         tot=;
         memset(head,-,sizeof(head));
         for(int i=;i<=n;i++)
         {
             int v,w;
             scanf("%d%d",&v,&w);
             addEdge(i,v,w);
             addEdge(v,i,w);
         }
         dfs1(,-);
         dfs2(,-);
         build(,n,);
         int ans=;

         int l=,r=;
         while(r<=n)
         {
             query_max=; query_min=INF;
             query(l,r,,n,);
             if(query_max-query_min<=m)  {ans=max(ans,r-l+);r++;}
             while(query_max-query_min>m)
             {
                 l++;
                 query_max=; query_min=INF;
                 query(l,r,,n,);
             }
         }
         printf("%d\n",ans);
     }
     return ;
 }

线段树