[BZOJ 2500] 幸福的道路

照例先贴题面（汪汪汪）

2500: 幸福的道路

Time Limit: 20 Sec  Memory Limit: 256 MB
Submit: 368  Solved: 145
[Submit][Status][Discuss]

Description

小T与小L终于决定走在一起,他们不想浪费在一起的每一分每一秒,所以他们决定每天早上一同晨练来享受在一起的时光.

他们画出了晨练路线的草图,眼尖的小T发现可以用树来描绘这个草图.

他们不愿枯燥的每天从同一个地方开始他们的锻炼,所以他们准备给起点标号后顺序地从每个起点开始(第一天从起点一开始,第二天从起点二开始……). 而且他们给每条道路定上一个幸福的值.很显然他们每次出发都想走幸福值和最长的路线(即从起点到树上的某一点路径中最长的一条).

他们不愿再经历之前的大起大落,所以决定连续几天的幸福值波动不能超过M(即一段连续的区间并且区间的最大值最小值之差不超过M).他们想知道要是这样的话他们最多能连续锻炼多少天(hint:不一定从第一天一直开始连续锻炼)?

现在，他们把这个艰巨的任务交给你了!

Input

第一行包含两个整数N, M(M<=10^9).

第二至第N行,每行两个数字Fi , Di, 第i行表示第i个节点的父亲是Fi,且道路的幸福值是Di.

Output

最长的连续锻炼天数

Sample Input

3 2
1 1
1 3

Sample Output

3
数据范围：
50%的数据N<=1000
80%的数据N<=100 000
100%的数据N<=1000 000

对于这道题来说我们可以考虑预处理出每个结点的最长路径长然后乱搞

对于预处理我在考场上写了个对于每个结点DFS一遍求最长，然后$std::set$维护最大最小值，总时间复杂度瓶颈为预处理$O(n^2)$

实际上我们可以先求这个树的直径结点，然后从分别从两个直径结点进行DFS并取最大值来预处理出最长路径长。直径为树中最长的一条路径。这一过程需要固定的4遍DFS所以时间复杂度$O(n)$

考场上鬼使神差地脑抽认为求直径会有反例

然后就是求最长连续区间的问题，我的策略是建立左右两个哨兵，采用一直让右哨兵前进并更新最大值直至最大最小值超过限制条件，超限之后采用不断删除左哨兵的值并前进直至符合条件的贪心策略。因为$std::set$的插入与查询是$O(logn)$，每个点肯定要插入/删除一次所以贪心过程时间复杂度$O(nlogn)$，总时间复杂度$O(nlogn)$

这里其实还可以使用单调队列，但是因为单调队列要固定区间长度所以只能采取二分长度策略，总时间复杂度也是$O(nlogn)$。

然后袋马时间：

GitHub

 #include <set>
 #include <cstdio>
 #include <algorithm>

 const int MAXE=;
 const int MAXV=;

 struct Edge{
     int from;
     int to;
     int dis;
     Edge* next;
 };
 Edge E[MAXE];
 Edge* head[MAXV];
 Edge* top=E;

 int n;
 int m;
 int lg1;
 int lg2;
 int dis[MAXV];

 void Initialize();
 std::pair<int,int> DFS(int,int,int);
 void DFSA(int,int,int);
 void Insert(int,int,int);
 int Sweep();

 int main(){
     Initialize();
     lg1=DFS(,,).second;
     lg2=DFS(lg1,,).second;
     DFSA(lg1,,);
     DFSA(lg2,,);
     printf("%d\n",Sweep());
     // printf("%d %d\n",lg1,lg2);
     return ;
 }

 std::pair<int,int> DFS(int root,int prt,int dis){
     std::pair<int,int> ans(dis,root);
     for(Edge* i=head[root];i!=NULL;i=i->next){
         if(i->to==prt)
             continue;
         ans=std::max(ans,DFS(i->to,root,dis+i->dis));
     }
     return ans;
 }

 void DFSA(int root,int prt,int dis){
     ::dis[root]=std::max(::dis[root],dis);
     for(Edge* i=head[root];i!=NULL;i=i->next){
         if(i->to==prt)
             continue;
         DFSA(i->to,root,dis+i->dis);
     }
 }

 int Sweep(){
     int l=,r=,ans=;
     // std::priority_queue<int,std::vector<int>,std::less<int>> qmax;
     // std::priority_queue<int,std::vector<int>,std::greater<int>> qmin;
     std::multiset<int> s;
     while(r<=n){
         // printf("%d\n",r);
         s.insert(dis[r]);
         while(*(--s.end())-*s.begin()>m){
             s.erase(s.find(dis[l]));
             ++l;
         }
         ans=std::max(ans,int(s.size()));
         ++r;
     }
     return ans;
 }

 void Initialize(){
     int a,b;
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++){
         scanf("%d%d",&a,&b);
         Insert(a,i,b);
         Insert(i,a,b);
     }
 }

 inline void Insert(int from,int to,int dis){
     top->to=to;
     top->dis=dis;
     top->from=from;
     top->next=head[from];
     head[from]=top;
     top++;
 }

Backup

以及图包时间