POJ 3162 Walking Race（单调队列或线段树加树型DP）

题意：给你一棵有n个节点的树，树边为权值，要你求出树上每个点到其他点的距离中最大的那个值。对求出的从节点1到节点n最大值，找出最长的一段使得这一段中最大值减最小值的结点小于等于m。

对于第一个问题，有两种方法可以解决。第一种比较简单的方法是，每个点到其他点的距离中最大的那个值，一定是到树的直径的两个端点的距离之一（反证法易得）。那么我们找出树的直径的同时，处理出各个节点到树直径两个端点的距离就可以了。第二种方法是树型DP，两次DFS，第一次DFS求出以点i为根节点的子树里，到达点i的最大距离。但是我们所要求的最大距离也可能在父节点的分支中，所以用第二次DFS处理出，具体的细节参照代码。

对于第二个问题，同样有两种方法，一是线段树，扫一次就可以，二是单调队列，维护一个单调增的队列，一个单调减的队列，觉得很巧妙啊。

1.树型DP加线段树

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
#define LL(x) (x<<1)
#define RR(x) (x<<1|1)
#define INF ((LL)1<<60)
#define MID(a,b) (a+((b-a)>>1))
const int N=1e6+5;
struct Edge
{
int v,wei,pre;
Edge(){}
Edge(int a,int b,int c){v=a;pre=b;wei=c;}
}edge[N*2];
struct node
{
int lft,rht;
LL mi,mx;
int mid(){return MID(lft,rht);}
};

int head
,tot;
LL f1
,f2
;
int g1
,g2
;

void iswap(int u)
{
if(f1[u]<f2[u])
{
swap(f1[u],f2[u]);
swap(g1[u],g2[u]);
}
}
void addEdge(int u,int v,int wei)
{
edge[tot]=Edge(v,head[u],wei);
head[u]=tot++;
}
void dfs_1(int u,int fa)
{
f1[u]=f2[u]=0;
for(int i=head[u];i!=-1;i=edge[i].pre)
{
int v=edge[i].v,wei=edge[i].wei;
if(v==fa) continue;
dfs_1(v,u);
if(f2[u]<f1[v]+wei)
{
f2[u]=f1[v]+wei;
g2[u]=v;
iswap(u);
}
}
}
void dfs_2(int u,int fa)
{
for(int i=head[u];i!=-1;i=edge[i].pre)
{
int v=edge[i].v,wei=edge[i].wei;
if(v==fa) continue;
if(g1[u]==v)
{
if(f2[v]<f2[u]+wei)
{
f2[v]=f2[u]+wei;
g2[v]=u;
iswap(v);
}
}
else
{
if(f2[v]<f1[u]+wei);
{
f2[v]=f1[u]+wei;
g2[v]=u;
iswap(v);
}
}
dfs_2(v,u);
}
}

struct Segtree
{
node tree[N*4];
void build(int lft,int rht,int ind)
{
tree[ind].lft=lft;	tree[ind].rht=rht;
tree[ind].mi=INF;	tree[ind].mx=-INF;
if(lft==rht) tree[ind].mi=tree[ind].mx=f1[lft];
else
{
int mid=tree[ind].mid();
build(lft,mid,LL(ind));
build(mid+1,rht,RR(ind));
tree[ind].mi=min(tree[LL(ind)].mi,tree[RR(ind)].mi);
tree[ind].mx=max(tree[LL(ind)].mx,tree[RR(ind)].mx);
}
}
void query(int st,int ed,int ind,LL &mi,LL &mx)
{
int lft=tree[ind].lft,rht=tree[ind].rht;
if(st<=lft&&rht<=ed)
{
mi=tree[ind].mi,mx=tree[ind].mx;
return ;
}
else
{
int mid=tree[ind].mid();
LL mi1=INF,mi2=INF,mx1=-INF,mx2=-INF;
if(st<=mid) query(st,ed,LL(ind),mi1,mx1);
if(ed>mid) query(st,ed,RR(ind),mi2,mx2);
mi=min(mi1,mi2); mx=max(mx1,mx2);
return ;
}
}
}seg;

int main()
{
int n,m;
while(scanf("%d%d",&n,&m)!=EOF)
{
tot=0;
memset(head,-1,sizeof(head));
for(int i=2;i<=n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
addEdge(i,x,y);
addEdge(x,i,y);
}
dfs_1(1,-1); dfs_2(1,-1);

int st=1,ed=1,res=0;
LL mi,mx;
seg.build(1,n,1);
while(ed<=n)
{
seg.query(st,ed,1,mi,mx);
if(mx-mi<=m)
{
res=max(res,ed-st+1);
ed++;
}
while(mx-mi>m)
{
st++;
seg.query(st,ed,1,mi,mx);
}
}
printf("%d\n",res);
}
return 0;
}

2.DFS加单调队列

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=1e6+5;
struct Edge
{
int v,wei,pre;
Edge(){}
Edge(int a,int b,int c){v=a;pre=b;wei=c;}
}edge[N*2];

int head
,tot,n,m;
int dx
,dy
,d
;
int qmin
,qmax
;

void addEdge(int u,int v,int wei)
{
edge[tot]=Edge(v,head[u],wei);
head[u]=tot++;
}
void dfs(int u,int fa,int dis,int *d)
{
for(int i=head[u];i!=-1;i=edge[i].pre)
{
int v=edge[i].v,wei=edge[i].wei;
if(v!=fa) dfs(v,u,d[v]=dis+wei,d);
}
}
void solve()
{
int ans=0,i,j,front1,front2,rear1,rear2;
front1=rear1=0;
front2=rear2=0;

for(i=1,j=1;j<=n;j++)
{
while(rear1>front1&&d[qmax[rear1-1]]<=d[j]) rear1--;
qmax[rear1++]=j;

while(rear2>front2&&d[qmin[rear2-1]]>=d[j]) rear2--;
qmin[rear2++]=j;

if(d[qmax[front1]]-d[qmin[front2]]>m)
{
ans=max(ans,j-i);
while(d[qmax[front1]]-d[qmin[front2]]>m)
{
i=min(qmax[front1],qmin[front2])+1;
while(rear1>front1&&qmax[front1]<i) front1++;
while(rear2>front2&&qmin[front2]<i) front2++;
}
}
}
ans=max(ans,j-i);
printf("%d\n",ans);
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF)
{
tot=0;
memset(head,-1,sizeof(head));

int x,y,i;
for(int i=2;i<=n;i++)
{
scanf("%d%d",&x,&y);
addEdge(i,x,y);
addEdge(x,i,y);
}
dfs(1,0,d[1]=0,d);
for(x=1,i=2;i<=n;i++)
if(d[i]>d[x]) x=i;
dfs(x,0,dx[x]=0,dx);
for(y=1,i=2;i<=n;i++)
if(dx[i]>dx[y]) y=i;
dfs(y,0,dy[y]=0,dy);

for(int i=1;i<=n;i++) d[i]=max(dx[i],dy[i]);
solve();
}
return 0;
}