hihoCoder #1104 Suzhou Adventure

传送门：http://hihocoder.com/problemset/problem/1104

解题思路：

　　这是一道树上的动态规划问题 首先将多叉树转化为二叉树存储，再根据题中推荐访问的村庄地点预先处理得到必须访问的村庄集合，以便在动态规划时使用辅助决策，根据状态转移方程求解。

#include <iostream>
#include <vector>
#include <cstring>
#include <set>

int score[101];
int N, K, M;
int dp[101][101];
std::vector<int> edges[101];
int b[101] = {0};
int c[101] = {0};
std::set<int> must;

void makeTree()
{
    int a,b;
    for (int i = 0; i < N-1; ++i) {
        std::cin >> a >> b;
        edges[a].push_back(b);
        edges[b].push_back(a);
    }
}

void convertToBT(int node, int par)
{
    for (int i = 0; i < edges[node].size(); ++i) {
        if (edges[node][i] != par) {
            b[edges[node][i]] = c[node];
            c[node] = edges[node][i];
            convertToBT(edges[node][i], node);
        }
    }
}

void preProcess(int node, int par)
{
    if (edges[node].size() == 1 && edges[node][0] == par) return;

    for (int i = 0; i < edges[node].size(); ++i) {
        if (edges[node][i] != par) {
            preProcess(edges[node][i], node);
            if (must.count(edges[node][i])) {
                must.insert(node);
            }
        }
    } 
}

int dfs(int n, int m)
{
    if (dp[n][m] != -1) return dp[n][m];
    if (m == 0 ) {
        if (n == 0 || ( must.count(n) == 0 && dfs(c[n],0)==0 && dfs(b[n], 0) == 0)) return dp[n][m] = 0;
        else return dp[n][m] = -2;
    }
    if (n == 0 && m != 0) {return dp[n][m] = -2;}
    

    int maxm = -2;
    if (must.count(n) == 0) {
        maxm = dfs(b[n], m);
    }

    for (int i = 0; i < m; ++i) {
        if (dfs(c[n], i) == -2 || dfs(b[n], m-1-i) == -2) continue;
        else {
            maxm = std::max(maxm, dp[c[n]][i] + dp[b[n]][m-1-i] + score[n]);
        }
    }

    return dp[n][m] = maxm;    

}

int main()
{
    std::cin >> N >> K >> M;
    for (int i = 1; i <= N; ++i) {
        std::cin >> score[i];
    }
    int v;
    for (int i = 0; i < K; ++i) {
        std::cin >> v;
        must.insert(v);
    }
    if (K > M) {std::cout << -1 << std::endl; return 0;}
    memset(dp, -1, sizeof dp);
    makeTree();
    convertToBT(1,-1);
    preProcess(1, -1);
    int maxm = dfs(1, M);
    if (maxm < 0) std::cout << -1 << std::endl;
    else std::cout << maxm << std::endl;
}