Codeforces 1495F 搞了一上午的心得

目录

• Codeforces 1495F 搞了一上午的心得
  • 约定
  • 思维过程
    • 早期探索
    • 标解
      • 分析性质
      • 简化原题

Codeforces 1495F 搞了一上午的心得

不愧是div1的压轴题，真jr爽

这可比whk得劲多了！

约定

我们令题目中的 $a_0=b_0=0$。

$i$ 的前驱：$max(j:j<i,p_j>p_i)$

$i$ 的后继：$min(j:j>i,p_j>p_i)$

如果 $i$ 不存在前驱，那么我们令 $i$ 的前驱为 $0$。

注意，我们对后继并没有这个定义。

主要是后继不怎么用，后面都换成前驱了

求前驱和后继都可以用单调栈 $O(n)$ 求所有的

题中每个点有两种方式：走到 $i+1$，花费 $a_i$；走到 $i$ 的后继，花费 $b_i$。我们分别称它们为 $a,b$ 转移。

题中的每个询问给定了一个点集，设这个集合是 $S$，其中的所有点被称作 “必经点”。

思维过程

早期探索

（可以跳过）

不带修改：那还用想，单调栈求出每个点的后继，直接做就好了。 但这和正解无关

那要带上修改，咋办呢？我们发现它一下就毒瘤了起来。

慢慢来，分析性质。

我们的主观想法肯定是把 $a$ 转移边看成一个基底，然后加上 $b$ 转移边，考虑它的影响。

那我们反过来，把 $b$ 转移边看成是基底，再来考虑 $a$ 转移边。

首先我们知道所有的 $b$ 转移边显然构成森林 （因为 $n$ 没有后继，所以后继最多 $n-1$ 个，所以就最多 $n-1$ 条边，而且显然不会有环，于是构成森林）。这样再加上一些非树边。

我们发现，$a$ 转移边在 $b$ 转移边树上，体现出来要么是连向父亲，要么是连向兄弟 （即父亲的另一个儿子）。

往上做是不太好做的，按照树形dp的习惯，应该要往下做才是好做的。

（这时候我就去翻题解了）

标解

根据官方题解的做法，我们按照 前驱边 建一颗树，作为基底，然后把 $a$ 和 $b$ 都加上。注意前驱会有 $0$，所以 $0$ 作为树根，使整棵树连通。这里不再是森林了。

这是反常理的：正常我们会让后期加入的东西越少越好，而这里却加了一堆东西

分析性质

$a$ 转移边相当于往儿子里走（如果是叶子就会换子树），$b$ 转移边是直接换子树，即上面说的“连向兄弟“。

有一个显然的性质，我们要走到 $x$，一定走过了 $x$ 的父亲，及其上面所有点。

你可能会想，我们可能换子树过来。但是我们往前逆推，显然得先到父亲，然后到一个兄弟节点，然后才能换子树换过来 —— 无论如何，都要经过一下父亲，以及所有祖先。

还有另一个性质，如果要走到 $x$ ，那我们还要把 $x$ 的兄弟给走个遍。

就好比这个图中，我们从 $...f_2,f$ 一路走到了 $x$，现在要换到 $y$，那就要走两次 $b$ 转移边，就要把 $x$ 右边的兄弟走掉；

由于一次 $a$ 转移边只能到最左边的兄弟，要找到 $x$ 还得走一堆 $b$ 转移，就要把 $x$ 左边的兄弟走掉；

简单来说就是：从前面到 $x$ 要走左兄弟，从 $x$ 到后面要走右兄弟

于是 $x$ 的所有兄弟都要被遍历一遍。

简化原题

由此，我们可以考虑实际要经过哪些点，是走 $a$ 还是走 $b$，加一下就可以了。

我们可以得到一个实际要经过的点集 $T$，$x\in T$ 当且仅当 $x$ 满足下列条件之一

1. $x$ 是必经点的祖先 （包括自己），这些点要用 $a$ 转移来走到下一个；
2. $x$ 是必经点的祖先的兄弟，这些点要用 $b$ 转移来走到下一个。

（注意 $0$ 也在 $T$ 里面，并且 $a_0=b_0=0$ ）

那么我们的答案就是

$$\sum\limits_{x\in T} a_x+\sum\limits_{y\in son(x),y\not\in T} b_y$$

然后sigma里面，$y\not\in T$ 的条件可以先忽视，然后把 $T$ 中所有元素的 $b$ 都减掉。

即，我们可以令 $c_i=a_i-b_i+\sum\limits_{j\in son(i)} b_j$

那么答案等于 $\sum\limits_{x\in T} c_x$

这就完了么？还没有

有一个小细节，就是，如果一个子树里可以走一遍负的再回来（不一定回到原来的点，回到主线上去下一个点就行），那肯定要去走。它一来对大方向不影响，二来还能让答案更小。

处理树上距离前缀和的时候，更新一下就行了。

然后我们只需要每次维护一下这玩意就行了。注意要特判一下节点 $0$。

关于维护的细节：

设 $Anc(x)$ 表示 $x$ 在树上到根的链，这一个子图。

设 $S_E(G)$ 表示图 $G$ 的点权和。

设 $dis(x,y)$ 表示 $x,y$ 在树上的路径的点权和。

对于 $x_1,x_2...x_n$，设 $x_0=x_{n+1}=0$

$$S_E(\bigcup\limits_{i=1}^{n} Anc(i))=\dfrac{1}{2}{\sum\limits_{i=0}^{n} dis(x_i,x_i+1)}$$

左边那个到根路径的并集，其实就是本题的 $T$。

换句话说我们可以把 $T$ 中所有元素 $c$ 的和，转化成右边那个式子。

然后每次插入/删除的时候，拿 set 处理一下相邻两个的关系就行了

因为要用 set，所以复杂度带一个 $\log$，是 $O((n+q)\log n)$ 的。

代码

#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet
{
    #define N 200005
    #define int long long
    #define F(i,l,r) for(int i=l;i<=r;++i)
    #define D(i,r,l) for(int i=r;i>=l;--i)
    #define Fs(i,l,r,c) for(int i=l;i<=r;c)
    #define Ds(i,r,l,c) for(int i=r;i>=l;c)
    #define MEM(x,a) memset(x,a,sizeof(x))
    #define FK(x) MEM(x,0)
    #define Tra(i,u) for(int i=G.st(u),v=G.to(i);~i;i=G.nx(i),v=G.to(i))
    #define p_b push_back
    #define sz(a) ((int)a.size())
    #define all(a) a.begin(),a.end()
    #define iter(a,p) (a.begin()+p)
    #define PUT(a,n) F(i,0,n) printf("%lld ",a[i]); puts("");
    int I() {char c=getchar(); int x=0; int f=1; while(c<'0' or c>'9') f=(c=='-')?-1:1,c=getchar(); while(c>='0' and c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar(); return ((f==1)?x:-x);}
    template <typename T> void Rd(T& arg){arg=I();}
    template <typename T,typename...Types> void Rd(T& arg,Types&...args){arg=I(); Rd(args...);}
    void RA(int *p,int n) {F(i,1,n) *p=I(),++p;}
    int n,q;
    int p[N],a[N],b[N];
    void Input()
    {
        Rd(n,q);
        RA(p+1,n); RA(a+1,n); RA(b+1,n);
    }
    int st[N],top;
    int fa[N],dep[N]; int jp[N][22];
    int LCA(int u,int v)
    {
        if (dep[u]<dep[v]) swap(u,v);
        D(i,20,0) if (dep[jp[u][i]]>=dep[v]) u=jp[u][i];
        if (u==v) return u;
        D(i,20,0) if (jp[u][i]!=jp[v][i]) u=jp[u][i],v=jp[v][i];
        return fa[u];
    }
    int c[N]; int dis[N];
    // c 就是上面说的 c
    int pathlen(int u,int v) {return dis[u]+dis[v]-2ll*dis[LCA(u,v)];}
    set<int> s; set<int> ::iterator it;
    int cursum=0;
    int vis[N]; bool visx[N];
    void add(int x)
    {
        s.insert(x); it=s.find(x); --it;
        int pre=*it;
        ++it; ++it;
        if (it==s.end()) it=s.begin();
        int nex=*it;
        cursum-=pathlen(pre,nex); cursum+=pathlen(pre,x)+pathlen(x,nex);
    }
    void del(int x)
    {
        it=s.find(x); --it; 
        int pre=*it;
        ++it; ++it;
        if (it==s.end()) it=s.begin();
        int nex=*it;
        cursum-=pathlen(pre,x)+pathlen(x,nex); cursum+=pathlen(pre,nex); 
        s.erase(x);
    }
    // 加入, 删除元素
    // 用 set 维护两边关系
    void Sakuya()
    {
        F(i,1,n)
        {
            while(top and p[st[top]]<p[i]) --top;
            fa[i]=st[top];
            st[++top]=i;
        } // 单调栈求前驱
        dep[0]=0; F(i,1,n) dep[i]=dep[fa[i]]+1;
        // 深度
        F(i,1,n) jp[i][0]=fa[i]; F(i,1,20) F(j,1,n) jp[j][i]=jp[jp[j][i-1]][i-1];
        // 倍增

        F(i,1,n) c[i]+=a[i]-b[i],c[fa[i]]+=b[i];
        D(i,n,0)
        {
            dis[i]+=c[i];
            if (dis[i]<0ll and i) // 下面有负的, 过去绕一圈
            {
                dis[fa[i]]+=dis[i];
                dis[i]=0;
            }
        }
        F(i,1,n) dis[i]+=dis[fa[i]];

        vis[0]=1; s.insert(0); // 注意先搞一个 0 在这里, 不然挺麻烦的
        F(i,1,q)
        {
            int x=I();
            if (!visx[x]) // add
            {
                visx[x]=1;
                if (!vis[fa[x]]) add(fa[x]);
                ++vis[fa[x]];
            }
            else // del
            {
                visx[x]=0;
                if (vis[fa[x]]==1) del(fa[x]);
                --vis[fa[x]];
            }
            printf("%lld\n",cursum/2+dis[0]);
            // 特殊处理0节点
            // 除以2别忘了
        }
    }
    void IsMyWife()
    {
        Input();
        Sakuya();
    }
}
#undef int //long long
int main()
{
    Flandre_Scarlet::IsMyWife();
    getchar();
    return 0;
}