1 #pragma once
  2 #include <iostream>
  3 #include <vector>
  4
  5 using namespace std;
  6
  7 ///使用动态规划求解
  8 void process(vector<vector<int>>data, vector<vector<int>>&dp, vector<bool>isVist, int& root)
  9 {
 10     isVist[root] = true;//遍历过
 11     dp[root][1] = data[root][1];//获取活跃值
 12     for (int i = 0; i < data.size(); ++i)
 13     {
 14         if (data[i][0] == root && !isVist[i])
 15         {
 16             process(data, dp, isVist, i);
 17             dp[root][1] += dp[i][0];
 18             dp[root][0] += dp[i][0] > dp[i][1] ? dp[i][0] : dp[i][1];
 19         }
 20     }
 21 }
 22
 23
 24 int getMaxHappy(vector<vector<int>>data)
 25 {
 26     vector<vector<int>>dp(data.size(), vector<int>(data[0].size(), 0));
 27     vector<bool>isVist(data.size(), false);
 28     int root = 0;//找到boss
 29     for (int i = 0; i < data.size(); ++i)
 30         if (data[i][0] == i)//自己是自己的 上司，则此人为boss
 31         {
 32             root = i;
 33             break;
 34         }
 35     process(data, dp, isVist, root);
 36     return dp[root][0] > dp[root][1] ? dp[root][0] : dp[root][1];
 37 }
 38
 39
 40 ///使用二叉树的递归来求解
 41 struct Node
 42 {
 43     int val;//活跃度
 44     vector<Node*>child;//下属，是1:n的关系
 45     Node(int a) :val(a) {}
 46 };
 47
 48 Node* Create(const vector<vector<int>>data)
 49 {
 50     Node* head = nullptr;
 51     vector<Node*>node(data.size());
 52     int root = 0;
 53     for (int i = 0; i < data.size(); ++i)
 54         if (data[i][0] == i)
 55         {
 56             root = i;
 57             break;
 58         }
 59     node[root] = new Node(data[root][1]);
 60     for (int i=0;i<data.size();++i)
 61     {
 62         if (data[i][0] != i)//不是大boss
 63         {
 64             node[i] = new Node(data[i][1]);
 65             node[data[i][0]]->child.push_back(node[i]);
 66         }
 67         else
 68             head = node[i];
 69     }
 70     return head;
 71 }
 72
 73
 74 struct returnType
 75 {
 76     int c;//来的活跃度
 77     int nc;//不来的活跃度
 78     returnType(int a, int b) :c(a), nc(b) {}
 79 };
 80
 81 returnType* calMaxHappy(Node* head)
 82 {
 83     int cvalue, ncvalue;
 84     cvalue = head->val;//head去的活跃度
 85     ncvalue = 0;//head不去的活跃度
 86     for (int i = 0; i != head->child.size(); ++i)
 87     {
 88         returnType* res = calMaxHappy(head->child[i]);
 89         cvalue += res->nc;
 90         //上司去的活跃度 = 上司的活跃度 + 下属不去的活跃度；因为上司去，下属不会去
 91         ncvalue += res->c > res->nc ? res->c : res->nc;
 92         //上司不去的活跃 = 上司不去的活跃度 + 下属去或者不去的最大值，因为上司不去，下属可以去，亦可以不去
 93     }
 94     return new returnType(cvalue, ncvalue);
 95 }
 96
 97 void Test()
 98 {
 99     vector<vector<int>>data;
100     data = { {1,6},{1,5},{1,4} };
101     cout << getMaxHappy(data) << endl;
102
103     Node* head = Create(data);
104     returnType* p = calMaxHappy(head);
105     cout << (p->c > p->nc ? p->c : p->nc) << endl;
106 }