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[N],tot;
LL f1[N],f2[N];
int g1[N],g2[N];

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[N],tot,n,m;
int dx[N],dy[N],d[N];
int qmin[N],qmax[N];

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;
}