节点选择

一、题目

问题描述

有一棵 n 个节点的树，树上每个节点都有一个正整数权值。如果一个点被选择了，
那么在树上和它相邻的点都不能被选择。求选出的点的权值和最大是多少？
输入格式

第一行包含一个整数 n 。

接下来的一行包含 n 个正整数，第 i 个正整数代表点 i 的权值。

接下来一共 n-1 行，每行描述树上的一条边。
输出格式
输出一个整数，代表选出的点的权值和的最大值。
样例输入
5
1 2 3 4 5
1 2
1 3
2 4
2 5
样例输出
12
样例说明
选择3、4、5号点，权值和为 3+4+5 = 12 。
数据规模与约定

对于20%的数据， n <= 20。

对于50%的数据， n <= 1000。

对于100%的数据， n <= 100000。

权值均为不超过1000的正整数。

二、分析

这题用到了树形动态规划。
设dp[i][0]代表第i个节点不被选择时以第i个节点为根节点的树的最大权值,
dp[i][1]代表第i个节点被选择时以第i个节点为根节点的树的最大权值。
由于题目中要求了,如果一个节点被选中了,那么与它相邻的节点都不能被选中,根据这个要求可以推出以下状态转移方程。
1、dp[i][0]=Sum{Max(dp[x][0],dp[x][1])} 注:x是i节点的子节点,这个方程意思是第i个节点不被选中时,以它为根节点的树的最大权值为i节点的所有子节点被选中与不被选中时的权值的最大值的累加值。
2、dp[i][1]=Sum{dp[x][0]} +value[i] 注:当i节点被选中时,它的子节点都不能被选,因此这个方程表示的意思是第i个节点被选中时,以它为根节点的树的最大权值为i节点的所有子节点不被选中的权值+自己的权值

public class Main4 {
    //静态嵌套类
    static class Node {
        Vector<Integer> vector = new Vector<>();// 孩子集合
        int[] dp = new int[2];// 0--->不去 1--->去
        int value = 0;// 自身的权值
    }

    static Node[] nodes;//树

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = Integer.parseInt(scanner.nextLine());
        String[] s = scanner.nextLine().split(" ");
        nodes = new Node[n + 1];
        int index1, index2;
        for (int i = 0; i < n; i++) {
            nodes[i + 1] = new Node();
            nodes[i + 1].value = Integer.parseInt(s[i]);
        }
        for (int i = 0; i < n - 1; i++) {
            s = scanner.nextLine().split(" ");
            index1 = Integer.parseInt(s[0]);
            index2 = Integer.parseInt(s[1]);
            nodes[index1].vector.add(index2);
            nodes[index2].vector.add(index1);//完成树的初始化
        }

        /*
         * for(int i=1;i<=n;i++){ System.out.print(nodes[i].value+" "); for(int
         * j=0;j<nodes[i].vector.size();j++){
         * System.out.print(nodes[i].vector.get(j)+" "); } System.out.println();
         * }
         */
        dfs(1, 0);
        int max = Math.max(nodes[1].dp[1], nodes[1].dp[0]);
        System.out.println(max);
    }

    public static void dfs(int start, int father) {
        for (int i = 0; i < nodes[start].vector.size(); i++) {
            int x = nodes[start].vector.get(i);// 得到孩子节点
            if (x != father) {// 防止start的孩子节点成为start的父节点
                dfs(x, start);//先对它的孩子节点进行计算
                //根据状态转移方程
                nodes[start].dp[0] += Math.max(nodes[x].dp[0], nodes[x].dp[1]);
                nodes[start].dp[1] += nodes[x].dp[0];
            }
        }
        nodes[start].dp[1] += nodes[start].value;
    }
}

三、备注

1、上面代码在oj上因为运行超时只得到了50分,思路没错就是该如何进一步优化,,,,,,

2、这个题目和周年庆宴会这个题目很像,同样是树形动态规划,两题只有很小的差别。

Some people succeed because they are destined to,but most people succeed because they are determined to.