Day1：T3 bfs T4 树形DP

T3:BFS

回看了一下Day1的T3...感觉裸裸的BFS，自己当时居然没有看出来...

同时用上升和下降两种状态bfs即可

这一题还要注意一个细节的地方，就是题目要求的是求往返的最优解

k=min(d[上升],d[下降]);

ans=min(2*k+1,d1[]+d2[]);

输出ans..这个地方需要理解；

以及如果这个点在边缘地区(边界) 且这个点的高度为0 那么就不需要转化

其余的照bfs模板打即可：

//刚开始以为是把每一个点都bfs一遍，看了标程之后发现有一个优很多的解法：

把出发点定为(0,0),设想在山区外面还有一圈海拔为极大值（或0）的区域

根据bfs算法的思路，可想从(0,0)出发之后当然为最优解

这样只需要bfs一遍就可以了（上升和下降两种状态同时），时间上省了很多；

//mark;感谢ccy大神详细的注释

直接附上标程：

//感谢笑尘的思路
const
  dx:array[1..4] of longint=(0,0,1,-1);
  dy:array[1..4] of longint=(1,-1,0,0);//四个方向
var
  h:array[1..1000000] of record
//队列 x,y表示坐标  g中1表示上升状态,2表示下降状态  l表示用掉几个装置
                      x,y:longint;
                           g:1..2;
                           l:longint;
                           end;
  dis:array[-1..105,-1..105,1..2] of longint;//每个坐标的最优解(用掉几个装置)
  a:array[-1..105,-1..105] of longint;//存地图
  n,m,i,j,head,tail,x1,y1,x2,y2,p,cishu,k:longint;
 
function min(a,b:longint):longint;//返回较小值
begin
  if a>b then exit(b) else exit(a);
end;
 
begin
  fillchar(a,sizeof(a),0);
  fillchar(dis,sizeof(dis),$7f div 3);//初始化值要大
  readln(m,n);
  for i:=1 to m do
    begin
      for j:=1 to n do
        read(a[i,j]);
      readln;
    end;
  head:=0;tail:=2;
  h[1].x:=0;h[1].y:=0;h[1].g:=1;h[1].l:=0;//这是第一个是上升状态的情况
  h[2].x:=0;h[2].y:=0;h[2].g:=2;h[2].l:=0;//这是第一个是下降状态的情况
  dis[0,0,1]:=0;//最优解一开始(0,0)坐标都是0
  dis[0,0,2]:=0;
  while head<tail do
    begin
      inc(head);
      x1:=h[head].x;y1:=h[head].y;p:=h[head].g;cishu:=h[head].l;//x1,y1是坐标(从队列中取出),p是当前状态，cishu是转//换次数
      for i:=1 to 4 do
        begin
          x2:=x1+dx[i];
          y2:=y1+dy[i];
          if (x2>=0) and (x2<=m+1) and (y2>=0) and (y2<=n+1) then//如果这四个方向符合
            begin
              if (a[x2,y2]>=a[x1,y1]) and (p=1) and (dis[x2,y2,1]>cishu) then
//如果目标点的高度大于等于当前的点的高度，而且当前处于上升阶段 那么cishu不需要加1,直接和目标点的最优解比较。如果可//以更新则更新
                begin
                  dis[x2,y2,1]:=cishu;//更新dis节点
                  inc(tail);
                  h[tail].x:=x2;
                  h[tail].y:=y2;
                  h[tail].g:=1;
                  h[tail].l:=cishu;
                end;
              if (a[x2,y2]>a[x1,y1]) and (p=2) and (dis[x2,y2,1]>cishu+1) then
//如果目标点的高度大于当前的点的高度且处于下降状态 那么cishu+1,用cishu+1和目标点的最优解比较
                begin
                  dis[x2,y2,1]:=cishu+1;//更新dis节点
                  inc(tail);
                  h[tail].x:=x2;
                  h[tail].y:=y2;
                  h[tail].g:=1;
                  h[tail].l:=cishu+1;
                end;
              if (a[x2,y2]<a[x1,y1]) and (p=1) and (dis[x2,y2,2]>cishu+1) then
//如果目标点的高度小于当前的点,且当前处于上升状态 那么cishu+1,用cishu+1和目标点的最优解比较
                begin
                  dis[x2,y2,2]:=cishu+1;//更新dis节点
                  inc(tail);
                  h[tail].x:=x2;
                  h[tail].y:=y2;
                  h[tail].g:=2;
                  h[tail].l:=cishu+1;
                end;
              if (a[x2,y2]<=a[x1,y1]) and (p=2) and (dis[x2,y2,2]>cishu) then
//如果目标点的高度小于或等于当前的点，且当前处于下降状态 那么cishu不需要+1,用cishu和目标点的最优解比较
                begin
                  dis[x2,y2,2]:=cishu;//更新dis节点
                  inc(tail);
                  h[tail].x:=x2;
                  h[tail].y:=y2;
                  h[tail].g:=2;
                  h[tail].l:=cishu;
                end;
            end;
        end;
    end;//直到队列结束
  for i:=1 to m do
    begin
      for j:=1 to n do
        begin
          k:=min(dis[i,j,1],dis[i,j,2]);//先找出dis中的上升状态的最优解和下降状态的最优解 取最小值
          if (k=0) and (a[i,j]=0) and ((i=1) or (i=m) or (j=1) or (j=n)) then
            if j=1 then write(0) else write(' 0')//如果这个点在边缘地区(边界) 且这个点的高度为0 那么就不需要转化装//置
              else if j=1 then write(min(2*k+1,dis[i,j,1]+dis[i,j,2])) else//其他情况下在2*k+1和dis[i,j,1]+dis//[i,j,2]中求更优解，这两个加起来表示其不用相同的方式回去。
                 write(' ',min(2*k+1,dis[i,j,1]+dis[i,j,2]));//之所以判断j=1是为了防止末尾输出多余空格
        end;
      writeln;
    end;
end.

//分别讨论四种情况，并把符合的全部入队

理解了思路打起来并不难，主要是要细心和耐心；

T4:树形DP；

由于自己在长乐集训那一段时间没有很认真地静下心来理解树形DP，以至于对树形DP没有什么概念

回来自己补题解的时候，认真看了某位学长的题解（貌似这天是师宜写的？），以及ccy大神的注释，觉得其实也很好理解

跟老人家俊（？还是萌哲？）说的很像吧，无非就是在树上的DP

用邻接表存边，然后根据父亲和子树的关系写DP

DP主要是由三个数组实现：

f1表示父亲这个点放人看守 并且这个点已经被控制到了，即有人监视着这台电脑.
f2表示父亲这个点不放人看守，但是这个点已经被控制到了.
f3表示父亲这个点没有人控制到，但是其子树全部都被控制到了。

然后状态转移方程就是：

f1[x]:=f1[x]+min(min(f1[go[e]],f2[go[e]]),f3[go[e]]);

//这个点之所以三种状态都能是因为,这个点要放了，那么其儿子节点也可以选择放或则不放，其较优解，//对于这个儿子节点没有被控制的情况，如果这个点放了，那么这个儿子节点就可以被控制了
          f3[x]:=f3[x]+f2[go[e]];//f3的意义是这个点没有被控制，但是子树都被控制了，这和2的含义正好相对应所以加上它就是累加f3的值
          if f1[go[e]]<=f2[go[e]] then bo:=true;//如果放更优那么bo就为true 否则就保持不变为false;(可以想象如果不放更优，那么就会出现这个父亲节点没人控制的情//况)
          f2[x]:=f2[x]+min(f1[go[e]],f2[go[e]]);//不放的话就不能加上第三种情况了，因为那样就会有一个点不受控制
          aa:=min(aa,f1[go[e]]-f2[go[e]]);//这是为了防止上述 “不放更优”的情况出现，那样我们必须在儿子中找一个“较优值"来控制这个父亲;

如果忘了找aa的原因，可以看学长的注释：

如果父亲放了人，那么孩子就不需要放人了，当然也可以放人，所以可以直接取它们的最小值。如果父亲不放人，孩子至少要有一个放人，否则就看守不住父亲。所以，此时要找一个最优的孩子u来放人。怎么找到u呢？
 
我们可以这样考虑：穷举所有的孩子节点，用D[i]表示孩子节点i的DP[I,1]-DP[I,0]的值。这个值越小，说明这个节点放人越好。于是找到所有孩子中这个值的最小值，把这时的i作为u节点使用。

理解了过程写起来其实很简单：

自己乱yy了一下

//是把控制孩子的人数推回去，以及要不要加上u指也是根据孩子的f1,f2

这里的孩子和父亲的关系，是相对的

至于递归的时候是check(1,0)中的1指的是从邻接表的第一个节点开始

最后比较f1[1],f2[1]即可.

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
int f1[1500],f2[1500],f3[1500];
int tot=0,u,n,x,k,y;
struct node{
	int from,to,next;
}a[1500];
void add(int x,int y){
	a[++tot].next=a[x].from;
	a[x].from=tot;
	a[tot].to=y;
}
void check(int x,int fa){
	u=1500;
	bool f=false;
	int e=a[x].from;
	while(e!=0){
		if(a[e].to!=fa){
			check(a[e].to,x);
			f1[x]=f1[x]+min(min(f1[a[e].to],f2[a[e].to]),f3[a[e].to]);
			f3[x]=f3[x]+f2[a[e].to];
			if(f1[a[e].to]>f2[a[e].to]) f=true;
			f2[x]=f2[x]+min(f1[a[e].to],f2[a[e].to]);
			u=min(u,f1[a[e].to]-f2[a[e].to]);
		}
		e=a[e].next;
	}
	f1[x]++;
	if(f) f2[x]=f2[x]+u;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d%d",&x,&k);
		for(int j=1;j<=k;j++){
			scanf("%d",&y);
			add(x+1,y+1);
			add(y+1,x+1);
		}
	}
	check(1,0);
	printf("%d",min(f1[1],f2[1]));
	return 0;
}

顺便附上ccy大神的各种详细注释：

这个程序:(可以看看我画的示意图)
采用邻接表的形式存储边信息(因为是无向图所以要多存一条);
 
f1表示父亲这个点放人看守 并且这个点已经被控制到了，即有人监视着这台电脑.
f2表示父亲这个点不放人看守，但是这个点已经被控制到了.
f3表示父亲这个点没有人控制到，但是其子树全部都被控制到了。
 
var
  i,j,n,x,k,y,tot:longint;
  f1,f2,f3:array[0..2000] of longint;
  first,next,go:array[0..10010] of longint;
 
function min(a,b:longint):longint;
begin
  if a>b then exit(b) else
     exit(a);
end;
 
procedure cm(x,fa:longint);//x的父亲是fa
var
  bo:boolean;
  e,aa:longint;
 
begin
  aa:=10000;
  bo:=false;
  e:=first[x];//找到表头
  while e<>0 do//如果还有出度
    begin
      if go[e]<>fa then//如果这个点的出度不是父亲节点
        begin
          cm(go[e],x);//从这个点继续找其儿子节点
          f1[x]:=f1[x]+min(min(f1[go[e]],f2[go[e]]),f3[go[e]]);//这个点之所以三种状态都能是因为,这个点要放了，那么其儿子节点也可以选择放或则不放，其较优解，//对于这个儿子节点没有被控制的情况，如果这个点放了，那么这个儿子节点就可以被控制了
          f3[x]:=f3[x]+f2[go[e]];//f3的意义是这个点没有被控制，但是子树都被控制了，这和2的含义正好相对应所以加上它就是累加f3的值
          if f1[go[e]]<=f2[go[e]] then bo:=true;//如果放更优那么bo就为true 否则就保持不变为false;(可以想象如果不放更优，那么就会出现这个父亲节点没人控制的情//况)
          f2[x]:=f2[x]+min(f1[go[e]],f2[go[e]]);//不放的话就不能加上第三种情况了，因为那样就会有一个点不受控制
          aa:=min(aa,f1[go[e]]-f2[go[e]]);//这是为了防止上述 “不放更优”的情况出现，那样我们必须在儿子中找一个“较优值"来控制这个父亲;
        end;
      e:=next[e];//找下一个儿子(father是fa)
    end;
  f1[x]:=f1[x]+1;
  if not bo then f2[x]:=f2[x]+aa;
end;
 
procedure add(x,y:longint);
begin
  inc(tot);
  next[tot]:=first[x];//采取邻接表的形式存储,我在群文件中将会给出邻接表的使用方法
  first[x]:=tot;
  go[tot]:=y;//存储其出度信息
end;
 
begin
  assign(input,'virus.in');
  reset(input);
  assign(output,'virus.out');
  rewrite(output);
  readln(n);//读入n个点
  for i:=1 to n do//读入n个点的子节点
    begin
      read(x);//读入这个点
      read(k);//这个点的儿子个数
      for j:=1 to k do//读入儿子
        begin
          read(y);
          add(x+1,y+1);//因为是无向图所以加两次
          add(y+1,x+1);
        end;
      readln;
    end;
  cm(1,0);//1为儿子0为父亲
  writeln(min(f1[1],f2[1]));
  close(input);
  close(output);
end.

//说一句题外话，很感谢ccy把他的题解拷给我...很感激真的，他的题解写的很详细很清楚，每一篇都让我学习到了很多很多...

认识你很荣幸，希望这样棒的人一切顺利。。阿里噶多