題解/算法 {2538. 最大价值和与最小价值和的差值}

Link

Solution

Let $M[x]$ be the Maximal-Distance of $x$; Definition
. Let $a[x]$ be the point-value; then the Minimal-Distance of $x$ must be $a[x]$ in that all point-values are $\ge 1$;
. Obviously, the value asked for a point $x$ equals $V[x]=M[x]-a[x]$; then the final answer equals $max(V[x])\forall x$;

There are two totally different means.

朴素做法: 树的最长路径

The calculation for $M[x]$ is a template-algorithm;

DP做法

$V[x]$ denotes a Path which is the Maximal-Distance-Path of $x$ with removing the endpoint $x$;
. + If $V[x]$ is the answer, let’s analyze the Maximal-Distance-Path $M[x]$ (i.e., the Answer-path $V[x]$ joining the single point x);
. . The endpoints of $M[x]$ are $x,y$ where $y$ must be a Leaf-Node in that all point-values $\ge 1$;
. . $x$ is also a Leaf-Node (if not, you can prove that there must exist another point whose $V[]>V[x]$, which contradicts that $V[x]$ is the maximum);
. + But notice, even if $V[x]$ is the Answer, the $M[x]$ maybe not the Diameter of the tree; e.g., $a-b-c,b-d-e;A[a,b,c]=10,A[d,e]=1$, although the diameter is $a-b-c$ whose value is $30$ (it corresponds to $V[a]=V[c]=20$); while the Answer-Path is $d-b-a$ whose value is $V[e]=21$, but $M[e]=e-d-b-a$ is not the diameter;

Let $0$ be the root of the Tree;
. $D1[x]$ be the Maximal-Distance of the path $(x-...-y)$ where $x$ is the Peak of the path (cuz all point-values are $\ge 1$, $y$ must be a Leaf-Node);
. $D2[x]$ be the Maximal-Distance of the path $(x-...-y)$ where $x$ is the Peak and $y$ is not a Leaf-Node (it can be proved that the Child-Node of $y$ must be Leaf-Node);

Suppose $V[x]$ is the Answer, it corresponds to the Path $y-...-z$ (the $M[x]=(x-y-...-z)$); Let’s analyze the Path $M[x]$ (not $V[x]$), cuz $M[x]$ is the familiar-notion and just remove the point $x$ from $M[x]$ then it will become the Answer $V[x]$;
. The key is to find the Peak of this path, that is $V[x]$ is not calculated in the point $x$, but in the point $c$ while $c$ is the Peak of the path $V[x]$;
. Case-A If x be the Peak (最高点) of the Path $M[x]$, then $V[x]=max(D1[s])s\in \text{son of x}$;
. Case-B If z be the Peak of the Path $M[x]$, then $V[x]=max(D2[s])+A[x]s\in \text{son of x}$;
. Case-C Otherwise, there must has a point $c$ which is the Peak, ($x-...-a-c-b-...-y$ whose value $V[x]$ has two-cases:
. . Case-1: Let $b$ be a son of $c$ that has the maximal $D1[b]$, then update $V[x]=D1[b]+A[c]+D2[a]$ where $a\ne b$ and has the maximal $D2[a]$;
. . Case-2: Let $a$ be a son of $c$ that has the maximal $D2[a]$, then update $V[x]=D2[a]+A[c]+D1[b]$ where $b\ne a$ and has the maximal $D1[b]$;
. It can be proved that, the Answer of $M[x]=x-...-a-c-b-...-y$ (i.e., $V[x]=...-a-c-b-...-y$) must $\ge$ Case-1&2 (otherwise, $V[x]$ is not the Answer);
. The Answer $V[x]$ maybe Case-1, also maybe Case-2;
. . e.g., $a-b-c-d-e,V[a,b,c,d,e]=1,1,1,2,2$; the Answer is $V[a]=b-c-d-e$ and suppose $c$ is the Peak; when we at $c$: the Case-1 equals $4+1+1$, while Case-2 equals $2+1+2$; The answer $V[a]$ corresponds to Case-1;
. . e.g., $a-b-c-d-e,V[a,b,c,d,e]=1,10,1,1,9$; the Answer is $V[a]=b-c-d-e$ and suppose $c$ is the Peak; when we at $c$: the Case-1 equals $11+1+1$, while Case-2 equals $10+1+10$; The answer $V[a]$ corresponds to Case-2;

While the idea is somewhat complicated, the algorithm is much more clean:

pair< long long, long long> Dfs( int _cur, int _fa){
    long long len1 = 0, len2 = 0;
    int counter = 0;
    for( int nex, e = G->Head[ _cur]; ~e; e = G->Next[ e]){
        nex = G->Vertex[ e];
        if( nex == _fa){ continue;}
        auto ret = Dfs( nex, _cur);
        auto l1 = ret.first, l2 = ret.second;
        //--
        ++ counter;
        if( counter <= 1){
            len1 = max( l1, len1);
            len2 = max( l2, len2);
            continue;
        }
        // the Case-C; notice `len1, len2` may share the same Child-Node, so you should use `l1,len2` not `len1,len2`;
        //> [l1, _cur, len2]
        Ans = max( l1 + A[ _cur] + len2, Ans);
        //> [l2, _cur, len1]
        Ans = max( l2 + A[ _cur] + len1, Ans);
        //--
        len1 = max( l1, len1);
        len2 = max( l2, len2);
    }
    if( counter == 0){ //< Leaf-Node
        return {A[ _cur], 0};
    }
    else if( counter == 1){ //< The case-(A,B)
        Ans = max( len1, Ans);
        Ans = max( len2 + A[ _cur], Ans);
    }
    len1 += A[ _cur];
    len2 += A[ _cur];
    return {len1, len2};
}

Ans = 0;
Dfs( 0, -1);