Kick Start 19 F spectating villages

Kick Start 19 F spectating villages

链接：Google Kick Start 2019 Round F 3

题目大意：一个有V个结点的树，结点编号为1到V，每个结点i有一个beauty值，B[i]。如果在结点u放一个lighthouse灯塔，会使得u以及与u直接相连的所有结点被照亮illuminated。任意结点都可以放一个灯塔，求所有被照亮的结点的beauty和的最大值。

显然这是树的dp，题目给的是一个无根树，先转化为以结点1为根的有根树，设结点u的子结点集合为adj[u]，adj[u][0]是u第1个子结点的编号，以此类推。剩下有两种做法。

Approach 1

f(u, st) 结点u处于st状态时，树u的最大beauty和。

• st=0，u放灯塔；
• st=1，u不放灯塔，u的父结点放了；
• st=2，u和u的父结点都不放

前两种状态比较容易求解，状态转移方程
$$\begin{gathered} f(u,0)=B[u]+\sum _{v\in adj[u]}max(f(v,1),f(v,0)) \\ f(u,1)=B[u]+\sum _{v\in adj[u]}max(f(v,2),f(v,0)) \end{gathered}$$

设u子结点有M个。如果M=0，那f(u, 2)=0；如果M>0，那复杂一点，引入新状态

• h(k, 0) u的前k个子结点都不放灯塔，以这些结点为根的树的最大beauty和
• h(k, 1) 前k个子结点至少有放一个灯塔

所以f(u, 2) = max(B[u] + h(M, 1), h(M, 0))

边界条件 h(0, 0) = 0， h(1, 1) = f(adj[u][0]], 0)。状态转移方程

• h(k, 0) = h(k-1, 0) + f(adj[u][k], 2) 前k个子结点无灯塔，分成前k-1个无灯塔和第k个无灯塔两部分
• 令idx = adj[u][k-1]，则h(k, 1) = max(h(k-1, 1) + max(f(idx, 0), f(idx, 2)), h(i-1, 0) + f(idx, 0)) 已知前k个子结点有至少一个灯塔，如果前k-1个无灯塔，那第k个一定有灯塔；如果前k-1个有，那第k个分有和无两种情况讨论

最终结果 max(f(1, 0), f(1, 2))

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;
using ll = long long;
const int MAXV = 1e5 + 5;
int B[MAXV];
vector<int> G[MAXV]; // neighbors
vector<int> adj[MAXV]; // children
ll f[MAXV][3];

class Solution
{
public:
    void dfs(int x, int fa)
    {
        for (int y : G[x])
        {
            if (y != fa)
            {
                adj[x].push_back(y);
                dfs(y, x);
            }
        }
    }

    // 创建以1为根的树
    void build_tree()
    {
        dfs(1, -1);
    }

    void solve()
    {
        int V;
        cin >> V;
        // 结点编号1-V
        for (int i = 1; i <= V; i++)
        {
            cin >> B[i];
            G[i].clear();
            adj[i].clear();
        }
        for (int i = 0; i < V - 1; i++)
        {
            int xi, yi;
            cin >> xi >> yi;
            G[xi].push_back(yi);
            G[yi].push_back(xi);
        }

        build_tree();
        
         // approach 1
        traverse(1);
        cout << max(f[1][0], f[1][2]) << endl;
        
        // approach 2
        // traverse(1);
        // cout << max(f[1][0], max(f[1][1], f[1][2])) << endl; 
    }
    
    void traverse(int u) {
        if(adj[u].empty()) {
            f[u][0] = B[u];
            f[u][1] = B[u];
            f[u][2] = 0;
        } else {
            for(int j : adj[u]) traverse1(j);
            f[u][0] = B[u];
            for(int j : adj[u]) {
                f[u][0] += max(f[j][0], f[j][1]);
            }

            f[u][1] = B[u];
            for(int j : adj[u]) {
                f[u][1] += max(f[j][2], f[j][0]);
            }

            int M = adj[u].size();
            vector<vector<ll>> h(M + 1, vector<ll>(2));
            h[0][0] = 0;
            for (int i = 1; i <= M; i++)
            {
                h[i][0] = h[i - 1][0] + f[adj[u][i - 1]][2];
            }
            h[1][1] = f[adj[u][0]][0];
            for (int i = 2; i <= M; i++)
            {
                int idx = adj[u][i - 1];
                h[i][1] = max(h[i - 1][1] + max(f[idx][0], f[idx][2]), h[i - 1][0] + f[idx][0]);
            }
            f[u][2] = max(h[M][1] + B[u], h[M][0]);
        }
    }
    
};

int main()
{
    int T;
    cin >> T;
    auto sln = new Solution();
    for (int i = 1; i <= T; i++)
    {
        cout << "Case #" << i << ": ";
        sln->solve();
    }
    return 0;
}

Approach 2

使用类似的f(u, st)，只是st的含义变了

• st=0，u不放灯塔，且它的子结点也不放
• st=1，u放灯塔
• st=2，u不放，但它的子结点至少有一个放了灯塔（所以u不能是叶结点）

状态转移方程
$$\begin{gathered} f(u,0)=\sum _{v\in adj[u]}max(f(v,0),f(v,2)) \\ f(u,1)=B[u]+\sum _{v\in adj[u]}max(f(v,1),f(v,2),f(v,0)+B[v]) \\ f(u,2)=B[u]+h(M,1) \end{gathered}$$

最终结果 max(f(1, 0), f(1, 1), f(1, 2))

代码只需修改traverse()，以及最后输出结果的部分

void traverse(int u)
{
    if (adj[u].empty())
    {
        f[u][0] = 0;
        f[u][1] = B[u];
        // 不存在u是叶结点，且有子结点放灯塔的情况，所以设一个很小的值，
        // 当它与其它情况比较时，它永远不会被选
        f[u][2] = INT_MIN; 
    }
    else
    {
        f[u][0] = 0;
        for (int j : adj[u])
        {
            traverse(j);
            f[u][0] += max(f[j][0], f[j][2]);
        }
      
        int M = adj[u].size();
        vector<vector<int>> h(M + 1, vector<int>(2));
        h[0][0] = 0;
        for (int i = 1; i < M; i++) // h[M][0]不需要计算
        {
            h[i][0] = h[i - 1][0] + max(f[adj[u][i - 1]][0], f[adj[u][i - 1]][2]);
        }
        h[1][1] = f[adj[u][0]][1];
        for (int i = 2; i <= M; i++)
        {
            int idx = adj[u][i - 1];
            h[i][1] = max(h[i - 1][1] + max(f[idx][0], max(f[idx][1], f[idx][2])), h[i - 1][0] + f[idx][1]);
        }
        f[u][2] = B[u] + h[M][1];

        f[u][1] = B[u];
        for (int j : adj[u])
        {
            f[u][1] += max(f[j][0] + B[j], max(f[j][1], f[j][2]));
        }
    }
}