[uoj84]水题走四方

瞬移后无法区分两者，分开时不妨称下一次瞬移的为分身，即仅允许分身瞬移回本身

考虑本身，即从根节点出发向下移动的一条路径，并称路径上分身曾瞬移到的点为关键节点（包括根节点）

对关键节点dp，定义$f_{k}$表示当前两者均在$k$且$k$子树外所有点均被经过的最短时间

枚举上一个关键节点，分析两者的移动，不难得到转移即
$$
f_{k}=\min_{x为k的祖先}\big(f_{x}+(g_{x}-g_{k})-dep_{x}(h_{x}-h_{k})+\max(dep_{k}-\max(d_{\max},dep_{x}),0)\big)
$$
（其中$dep_{k}$表示$k$的深度$,h_{k}$表示$k$子树中叶子个数$,g_{k}$表示$k$子树中叶子深度和$,d_{\max}$表示$x$子树内除$k$子树外最深的叶子）

另外，初始状态即$f_{1}=1$，最终答案即$\min f_{k}+g_{k}-dep_{k}h_{k}$

若$d_{\max}\ne 0$且$dep_{k}>d_{\max}$，可以理解为其到达深度为$d_{\max}$的点后分身直接瞬移，显然这样不劣

同时，若$d_{\max}=0$，即$x$到$k$的这条链上（除$k$以外）没有其他儿子，直接从$x=fa_{k}$依次转移即可

进一步的，若$x$不是第一个满足$dep_{k}\le d_{\max}$的祖先，那么不妨先转移到该祖先再转移到$k$，代入可得不劣

综上，仅需考虑$x=fa_{k}$（在$fa_{k}$仅有$k$一个儿子时）和第一个满足$dep_{k}\le d_{\max}$的祖先

关于后者，对树长链剖分，注意到其所在长链顶端的父亲一定满足

换言之，每一条长链内是独立的，分别维护一个单调栈执行上述过程即可

需要注意空间限制，由于保证编号，可以使用遍历的方式代替dfs

时间复杂度为$o(n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 5000005
#define ll long long
vector<int>V[N];
int n,n0,st[N],vis[N],fa[N],dep[N],h[N],mx[N],cmx[N],son[N],top[N];
ll ans,g[N],f[N];
char s[N<<1];
void get_val(int k,int x,int mx){
    f[k]=min(f[k],f[x]+(g[x]-g[k])-(ll)dep[x]*(h[x]-h[k])+max(dep[k]-max(mx,dep[x]),0));
}
int main(){
    scanf("%d%s",&n,s+1);
    for(int i=1;i<=(n<<1);i++)
        if (s[i]==')')st[0]--;
        else{
            n0++;
            if (st[0]){
                fa[n0]=st[st[0]];
                vis[st[st[0]]]=1;
            }
            st[++st[0]]=n0;
        }
    for(int i=2;i<=n;i++)dep[i]=dep[fa[i]]+1;
    for(int i=n;i>1;i--){
        if (!vis[i])h[i]=1,mx[i]=g[i]=dep[i];
        h[fa[i]]+=h[i],g[fa[i]]+=g[i];
        int d=mx[i];
        if (mx[fa[i]]<d)son[fa[i]]=i,swap(mx[fa[i]],d);
        cmx[fa[i]]=max(cmx[fa[i]],d);
    }
    for(int i=1;i<=n;i++){
        if ((i==1)||(son[fa[i]]!=i))top[i]=i;
        else top[i]=top[fa[i]];
        V[top[i]].push_back(i);
    }
    memset(f,0x3f,sizeof(f));
    f[1]=0;
    for(int i=1;i<=n;i++)
        if (!V[i].empty()){
            if (i!=1){
                for(int j=0;j<V[i].size();j++)get_val(V[i][j],fa[i],mx[fa[i]]);
            }
            st[0]=0;
            for(int j=0;j<V[i].size();j++){
                if (j)get_val(V[i][j],V[i][j-1],cmx[V[i][j-1]]);
                while ((st[0])&&(cmx[st[st[0]]]<dep[V[i][j]]))st[0]--;
                if (st[0])get_val(V[i][j],st[st[0]],cmx[st[st[0]]]);
                while ((st[0])&&(cmx[st[st[0]]]<=cmx[V[i][j]]))st[0]--;
                st[++st[0]]=V[i][j];
            }
        }
    ans=1e18;
    for(int i=1;i<=n;i++)ans=min(ans,f[i]+g[i]-(ll)dep[i]*h[i]);
    printf("%lld\n",ans);
    return 0;
}