BZOJ1791 基环树直径

非递归版4S

 /**************************************************************
     Problem: 1791
     User: 18357
     Language: C++
     Result: Accepted
     Time:4556 ms
     Memory:120132 kb
 ****************************************************************/
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <stack>
 #include <cctype>
 #include <iostream>
 #define N 1050000
 using namespace std;
 inline int getc()
 {
         static const int L =  << ;
         static char buf[L], *S = buf, *T = buf;
         if (S == T)
         {
                 T = (S = buf) + fread(buf, , L, stdin);
                 if (S == T)
                 {
                         return EOF;
                 }
         }
         return *S++;
 }
 inline int getint()
 {
         int c;
         while (!isdigit(c = getc()));
         int tmp = c - '';
         while (isdigit(c = getc()))
         {
                 tmp = (tmp << ) + (tmp << ) + c - '';
         }
         return tmp;
 }
 struct Syndra
 {
         int u, v, len, next;
 } e[N];
 struct Fiona
 {
         int edge, flag1, flag2;
         long long temp, max1, max2;
 } s[N];
 int head[N], cnt, n;
 int visit[N], next[N], len[N];
 int i, j, k;
 long long sa[N], pre[N], ans;
 void add(int u, int v, int len)
 {
         cnt++;
         e[cnt].u = u;
         e[cnt].v = v;
         e[cnt].len = len;
         e[cnt].next = head[u];
         head[u] = cnt;
 }
 int que[N << ];
 long long sum[N << ], ret;
 long long dp(int num)
 {
         int top, tail;
         int u, b, star;
         int et;
         for (et = ; et < (num << ); et++)
         {
                 sum[et] = sum[et - ] + pre[(et - ) >= num ? (et -  - num) : (et - )];
         }
         top = tail = ;
         que[tail++] = ;
         for (et = ; et < (num << ); ++et)
         {
                 while (top < tail && et - que[top] >= num)
                 {
                         ++top;
                 }
                 u = que[top];
                 ret = max(ret, sa[et >= num ? et - num : et] + sa[u >= num ? u - num : u] + sum[et] - sum[u]);
                 while (top < tail && sa[et >= num ? et - num : et] >= sa[que[tail - ] >= num ? que[tail - ] - num : que[tail - ]] + sum[et] - sum[que[tail - ]])
                 {
                         --tail;
                 }
                 que[tail++] = et;
         }
         return ret;
 }
 void build()
 {
         cnt = ;
         memset(head, , sizeof(head));
         memset(visit, , sizeof(visit));
         n = getint();
         for (i = ; i <= n; i++)
         {
                 next[i] = getint();
                 len[i] = getint();
                 add(next[i], i, len[i]);
         }
 }
 stack<int>sk;
 int fa[N];
 void dfs(int x)
 {
         if (s[x].edge == )
         {
                 sk.pop();
                 if (s[x].flag2)
                 {
                         ret = max(ret, s[x].max1 + s[x].max2);
                 }
                 if (visit[x] == -)
                 {
                         return ;
                 }
                 x = sk.top();
                 {
                         int v, tt = s[x].edge;
                         v = e[tt].v;
                         visit[v] = i;
                         s[x].temp = s[v].max1 + e[tt].len;
                         if (s[x].max1 < s[x].temp)
                         {
                                 if (s[x].flag1)
                                 {
                                         s[x].max2 = s[x].max1, s[x].flag2 = ;
                                 }
                                 else
                                 {
                                         s[x].flag1 = ;
                                 }
                                 s[x].max1 = s[x].temp;
                         }
                         else if (s[x].max2 < s[x].temp)
                         {
                                 s[x].max2 = s[x].temp, s[x].flag2 = ;
                         }
                         s[x].edge = e[tt].next;
                 }
                 return ;
         }
         int v, tt = s[x].edge;
         v = e[tt].v;
         if (visit[v] == -)
         {
                 s[x].edge = e[tt].next;
                 return ;
         }
         fa[v] = x;
         s[v].edge = head[v];
         sk.push(v);
 }
 long long handle(int x)
 {
         s[x].edge = head[x];
         sk.push(x);
         while (!sk.empty())
         {
                 dfs(sk.top());
         }
         return s[x].max1;
 }
 int main()
 {
         int u, v;
         build();
         for (i = ; i <= n; i++)
         {
                 if (!visit[i])
                 {
                         for (u = i; !visit[u]; u = next[u])
                         {
                                 visit[u] = i;
                         }
                         if (visit[u] == i)
                         {
                                 ret = ;
                                 cnt = ;
                                 visit[u] = -;
                                 for (v = next[u]; v != u; v = next[v])
                                 {
                                         visit[v] = -;
                                 }
                                 v = u;
                                 do
                                 {
                                         pre[cnt] = len[v];
                                         sa[cnt++] = handle(v);
                                         v = next[v];
                                 }
                                 while (v != u);
                                 ans += dp(cnt);
                         }
                 }
         }
         cout << ans;
         return ;
 }

//BZOJ1791

自己写的递归RE待修改版

 /*Huyyt*/
 #include<bits/stdc++.h>
 #define mem(a,b) memset(a,b,sizeof(a))
 #define pb push_back
 using namespace std;
 typedef long long ll;
 typedef unsigned long long ull;
 using namespace std;
 const int MAXN = 1e6 + , MAXM = 1e6 + ;
 int to[MAXM << ], nxt[MAXM << ], Head[MAXN], ed = ;
 int value[MAXM << ];
 int i, v;
 inline void addedge(int u, int v, int val)
 {
         to[++ed] = v;
         nxt[ed] = Head[u];
         value[ed] = val;
         Head[u] = ed;
 }
 inline void read(int &v)
 {
         v = ;
         char c = ;
         int p = ;
         while (c < '' || c > '')
         {
                 if (c == '-')
                 {
                         p = -;
                 }
                 c = getchar();
         }
         while (c >= '' && c <= '')
         {
                 v = (v << ) + (v << ) + c - '';
                 c = getchar();
         }
         v *= p;
 }
 bool circle[MAXN];
 int vis[MAXN], cnt;
 int nnxt[MAXN], nxtcircle[MAXN];
 int que[MAXN << ];
 ll dpd[MAXN], sum[MAXN << ], pre[MAXN];
 ll sa[MAXN], ansnow, anser;
 stack<int> sk;
 void dfs(int x, int pre)
 {
         vis[x] = ;
         for (int v, i = Head[x]; i; i = nxt[i])
         {
                 v = to[i];
                 if (pre != - && i == (pre ^ ))
                 {
                         continue;
                 }
                 if (vis[v] == )
                 {
                         circle[x] = true;
                         nxtcircle[x] = nnxt[x] = i;
                         int cur;
                         cur = to[nxtcircle[x]];
                         while (cur != x)
                         {
                                 circle[cur] = true;
                                 nxtcircle[cur] = nnxt[cur];
                                 cur = to[nxtcircle[cur]];
                         }
                 }
                 else if (vis[v] == )
                 {
                         continue;
                 }
                 else
                 {
                         nnxt[x] = i;
                         dfs(v, i);
                 }
         }
         vis[x] = ;
 }
 void ZJdp(int x)
 {
         vis[x] = ;
         for (int v, i = Head[x]; i; i = nxt[i])
         {
                 v = to[i];
                 if (vis[v])
                 {
                         continue;
                 }
                 ZJdp(v);
                 if (!circle[v])
                 {
                         ansnow = max(ansnow, dpd[x] + dpd[v] + value[i]);
                         dpd[x] = max(dpd[x], dpd[v] + value[i]);
                 }

         }
 }
 int main()
 {
         int n;
         int u;
         read(n);
         for (i = ; i <= n; i++)
         {
                 read(u), read(v);
                 addedge(i, u, v), addedge(u, i, v);
         }
         for (i = ; i <= n; i++)
         {
                 if (!vis[i])
                 {
                         dfs(i, -);
                 }
         }
         mem(vis, );
         int top, tail, et, cur;
         for (i = ; i <= n; i++)
         {
                 if (circle[i])
                 {
                         if (!vis[i])
                         {
                                 ansnow = ;
                                 ZJdp(i);
                                 top = tail = cnt = ;
                                 que[tail++] = ;
                                 cur = to[nxtcircle[i]];
                                 sa[cnt] = dpd[i];
                                 pre[cnt++] = value[nxtcircle[i]];
                                 while (cur != i)
                                 {
                                         sa[cnt] = dpd[cur];
                                         pre[cnt++] = value[nxtcircle[cur]];
                                         cur = to[nxtcircle[cur]];
                                 }
                                 for (et = ; et < (cnt << ); et++)
                                 {
                                         sum[et] = sum[et - ] + pre[(et - ) >= cnt ? (et -  - cnt) : (et - )];
                                 }
                                 for (et = ; et < (cnt << ); ++et)
                                 {
                                         while (top < tail && et - que[top] >= cnt)
                                         {
                                                 ++top;
                                         }
                                         u = que[top];
                                         ansnow = max(ansnow, sa[et >= cnt ? et - cnt : et] + sa[u >= cnt ? u - cnt : u] + sum[et] - sum[u]);
                                         while (top < tail && sa[et >= cnt ? et - cnt : et] >= sa[que[tail - ] >= cnt ? que[tail - ] - cnt : que[tail - ]] + sum[et] - sum[que[tail - ]])
                                         {
                                                 --tail;
                                         }
                                         que[tail++] = et;
                                 }
                                 anser += ansnow;
                         }
                 }
         }
         printf("%lld", anser);
         return ;
 }