Title Description:
Problem solving ideas:
According to the meaning of the question, this question is to select several points on a tree to maximize the point weight, in which the selected points meet two conditions:
- If the parent node is selected, the child node cannot be selected
- If a child node is selected, the parent node cannot be selected
Obviously, the top priority of the problem is how to store a tree or a graph in the program. At this time, the popular adjacency matrix has spatial defects, so we need to use the chain forward star.
Chain forward Star:
Chained forward star is a flexible storage structure. We need to use the structure to implement it in the program.
There is a graph. The relationship between points and edges is:
1 3
2 3
6 4
7 4
4 5
3 5
The actual figure above is:
Set structure array
e
e
e represents the relationship between the midpoint and the edge of the point in the diagram, including
h
e
a
d
,
x
,
y
,
n
e
x
t
head,x,y,next
head,x,y,next, then
e
.
x
e.x
e.x represents the starting point,
e
.
y
e.y
e.y represents the target point,
e
.
n
e
x
t
e.next
e.next means and
e
.
x
e.x
e.x is the sequence number of the next side of the same starting point,
e
.
h
e
a
d
e.head
e.head representation
e
.
x
e.x
e. The sequence number of the first side of X.
As shown in the figure, it is the state when a linked forward star stores a diagram.
We find the starting point No. 4 according to the header
e
4
.
h
e
a
d
=
4
e_4.head=4
e4. head=4
4
4
The first edge with 4 points as the starting point is numbered
4
4
4, the target point of this edge is
e
4
.
y
=
7
e_4.y=7
e4. y=7, i.e. No
7
7
7 points.
Then observe to
4
4
4 as the next edge of the starting point, the number of the edge is
e
4
.
n
e
x
t
=
3
e_4.next=3
e4. next=3, so the number is
3
3
The side of 3 is
4
4
The second side of 4, the target point is
e
3
.
y
=
6
e_3.y=6
e3.y=6.
If we look at the next side, we find that
e
3
.
n
e
x
t
=
0
e_3.next=0
e3. next=0, that is, there is no next edge, that is, the end pair
4
4
Traversal of 4 points.
Thus, by traversing all the edges of the root node, we can get the child nodes. By repeating this, we can store and traverse a graph.
struct note
{
int x,y,next;
} e[6010];
int head[6010]={0},tot=0; //tot represents the number of edges
void add(int x,int y) //Creates a directed edge between X and Y
{
tot++;
e[tot].x=x;
e[tot].y=y;
e[tot].next=head[x];
head[x]=tot;
}
Tree DP:
After solving the problem of storing graphs, we will consider DP on this tree.
set up
f
i
,
1
/
0
f_{i,1/0}
fi,1/0 ， indicates when considering the second
i
i
When i points are selected
/
/
/When not selected, the
i
i
i is the maximum point weight sum of the subtree of the root.
When the parent node is selected, its child nodes cannot be selected; When the parent node is not selected, its child nodes can also be selected or not selected.
The state transition equation is not difficult to give:
f
i
=
{
∑
j
f
j
,
0
choose
The first
i
individual
spot
,
j
by
i
of
son
son
∑
j
m
a
x
(
f
j
,
0
,
f
j
,
1
)
no
choose
The first
i
individual
spot
，
j
by
i
of
son
son
f_ i=\begin{cases} \sum_ {j}f_ {J, 0} & select the ith point, where j is the son of I \ \ \ \ sum_ {j} Max (f {J, 0}, f {J, 1}) & do not select the ith point, j is the son of I \ end{cases}
fi = {∑ J} fj,0 ∑ J} max(fj,0, fj,1) select the ith point, j is the son of i, not the ith point, j is the son of i
Because the tree itself has the nature of recursion, we find a root node, start from the root node, traverse its subtree through the chain forward star, and perform DP recursively.
CODE:
#include <iostream>
#include <cstring>
using namespace std;
struct note
{
int x,y,next;
} e[6010];
int head[6010]={0},tot=0;
void add(int x,int y) //Chain forward star
{
tot++;
e[tot].x=x;
e[tot].y=y;
e[tot].next=head[x];
head[x]=tot;
}
int n,ri[6010]={0},f[6010][2]={0};
bool vis[6010]={false};
void dp(int s) //s is the root node of the current tree
{
f[s][1]=ri[s];
int i=head[s]; //i is the number of the first side of s
while(i)
{
dp(e[i].y); //Handle the target point of this edge and recurse the subtree
f[s][1]=f[e[i].y][0]+f[s][1];
f[s][0]=max(f[e[i].y][1],f[e[i].y][0])+f[s][0];
i=e[i].next; //Next edge
}
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>ri[i];
int a,b;
for(int i=1;i<n;i++)
{
cin>>a>>b;
add(b,a);
vis[a]=true;
}
for(int i=1;i<=n;i++)
{
if(vis[i]) continue; //Find the root node, that is, the point with penetration of 0
dp(i);
cout<<max(f[i][1],f[i][0]);
break;
}
return 0;
}