分析:
这种爸爸儿子绑在一块,要么都出现,要么不能同时出现的,就是树形DP了。题解:
1.先建立结构体,以每个关系为单位,关系的序号为下标,里面包括这条关系里的父亲,与下一个同级关系的序号
struct node
{
int v;
int next;
}People[/*总关系数*/];
2.然后开始把每一条关系加进去
void ADD (int u, int v)
{
People[e].v = v; //父亲的序号v
People[e].next = head[u]; //head数组存放的是儿子的下标指向的第一个父亲的关系序号,这里存放的就是当前父亲
head[u] = e ++; //更新关系下标的值:如果一个儿子有多个父亲的话,head数组能保存最新父亲的关系的序号,而旧的父亲的关系序号则存放再next里。
}
3.这是DFS搜索:
int DFS (int u)
{
visit[u] = 1;//表示已经搜索过这个儿子
dp[u][0] = 0;//u不去的最大值
dp[u][1] = val[u];//u去的最大值
for (int i = head[u]; i != -1; i = People[i].next)//先找u最新的父亲的关系序号,然后换成u下一个父亲的关系序号
{
int v = People[i].v; //得到这个关系序号里的父亲的值
DFS(v); //再搜索它的父亲
dp[u][0] += max(dp[v][0], dp[v][1]); //儿子不去的值 = max(父亲不去的值,父亲去的值)
dp[u][1] += dp[v][0]; //儿子去的值 = 它加上父亲不去的值
}
return max(dp[u][0], dp[u][1]); 返回儿子去和不去的值中最大的
}
- AC代码:
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <iostream>
using namespace std;
#define N 6666
int dp[N][2], val[N], visit[N];
int fa[N];
struct node
{
int v;
int next;
}People[N<<1];
int e, head[N];
void init ()
{
memset (head, -1, sizeof (head));
e = 1;
}
void ADD (int u, int v)
{
People[e].v = v;
People[e].next = head[u];
head[u] = e ++;
}
int DFS (int u)
{
visit[u] = 1;
dp[u][0] = 0;
dp[u][1] = val[u];
for (int i = head[u]; i != -1; i = People[i].next)
{
int v = People[i].v;
DFS(v);
dp[u][0] += max(dp[v][0], dp[v][1]);
dp[u][1] += dp[v][0];
}
return max(dp[u][0], dp[u][1]);
}
int main()
{
int n, v, u;
while (scanf ("%d", &n) != EOF)
{
init();
for (int i = 1; i <= n; ++i)
{
fa[i] = 0;
visit[i] = 0;
scanf ("%d", &val[i]);
}
while (scanf ("%d%d", &v, &u) && v + u != 0)
{
ADD (u, v);
fa[v]++;
}
int ans = 0;
for (int i = 1; i <= n; ++i)
{
if(!fa[i])
ans += DFS(i);
}
//for(int i=1;i<=e;i++)
// cout << i << ":" << head[i] << "---" <<People[head[i]].next<< endl;
printf("%d\n", ans);
}
return 0;
}