【搜索】codeforces C. The Tag Game

http://codeforces.com/contest/813/problem/C

【题意】

给定一棵有n个结点的树，初始时Alice在根结点1,Bob在非根结点x;

Alice和Bob轮流走，每一步都有两种选择：走向相邻结点或静止不动，Bob先走；

当Alice和Bob相遇时游戏结束；

Alice的目标是游戏结束是的总步数最少，Bob的目标是游戏结束时总步数最少；

求最后的总步数是多少。

2 ≤ n ≤ 2·10^5， 2 ≤ x ≤ n

【思路】

Alice想要游戏尽早结束，所以Alice的每一步是靠近Bob; Bob不想游戏结束，所以他选择躲Alice,在尽量不遇到Alice的情况下选择一条最长的路径然后逃到这条路的叶节点不动。所以可以这样做：

bfs求出树上每个点k到1的距离dis[k]，O(n)
bfs求出树上每个点k到x的距离dist[k]，O(n)

如果dis[k]<dist[k]，说明k是可行点，在所有可行点中找到最大的dist[k]。

还有一种方法更复杂一点：

找出x到1的路径上的可行点k，所谓可行点就是当Bob到达这点的时候Alice还没有到达，1->k的路径长度+以结点K为根的子树高度

dfs一次找出每个点的深度和高度，O(n)

dfs一次找出1->x路径上的结点，O(n)

【Accepted】

 #include <iostream>
 #include <stdio.h>
 #include <cmath>
 #include <vector>
 #include <algorithm>
 #include <set>
 #include <map>
 #include <queue>
 #include <deque>
 #include <stack>
 #include <string>
 #include <bitset>
 #include <ctime>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 typedef long long ll;
 const int maxn=2e5+;
 const int inf=0x3f3f3f3f;
 int n,x;
 struct node
 {
     int to;
     int nxt;
 }edge[maxn<<];
 int tot;
 int ans;
 int head[maxn];
 int du[maxn];
 int dis[maxn];
 int dist[maxn];
 void Init()
 {
     memset(head,-,sizeof(head));
     memset(dis,inf,sizeof(dis));
     memset(dist,inf,sizeof(dist));
     tot=;
     ans=;
 }
 void add(int u,int v)
 {
     edge[tot].to=v;
     edge[tot].nxt=head[u];
     head[u]=tot++;
 }
 void bfs1(int u)
 {
     int vis[maxn];
     memset(vis,,sizeof(vis));
     dist[u]=;
     vis[u]=;
     queue<int> Q;
     Q.push(u);
     while(!Q.empty())
     {
         u=Q.front();
         Q.pop();
         for(int i=head[u];i!=-;i=edge[i].nxt)
         {
             int to=edge[i].to;
             if(vis[to])
             {
                 continue;
             }
             dist[to]=dist[u]+;
             vis[to]=;
             Q.push(to);
         }
     }
 }

 void bfs2(int u)
 {
     int vis[maxn];
     memset(vis,,sizeof(vis));
     dis[u]=;
     vis[u]=;
     queue<int> Q;
     Q.push(u);
     while(!Q.empty())
     {
         u=Q.front();
         Q.pop();
         for(int i=head[u];i!=-;i=edge[i].nxt)
         {
             int to=edge[i].to;
             if(vis[to])
             {
                 continue;
             }
             dis[to]=dis[u]+;
             vis[to]=;
             Q.push(to);
         }
     }
 }

 void Solve()
 {
     bfs1();
     bfs2(x);
     for(int i=;i<=n;i++)
     {
     //    cout<<dis[i]<<" "<<dist[i]<<endl;
         if(dis[i]<dist[i])
         {
             ans=max(ans,dist[i]);
         }
     }
     cout<<ans*<<endl;
 }
 int main()
 {
     while(~scanf("%d%d",&n,&x))
     {
         Init();
         int u,v;
         for(int i=;i<n-;i++)
         {
             scanf("%d%d",&u,&v);
             add(u,v);
             add(v,u);
             du[u]++;
             du[v]++;
         }
         Solve();
     }
     return ;
 }

BFS

 #include <iostream>
 #include <stdio.h>
 #include <cmath>
 #include <vector>
 #include <algorithm>
 #include <set>
 #include <map>
 #include <queue>
 #include <deque>
 #include <stack>
 #include <string>
 #include <bitset>
 #include <ctime>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 typedef long long ll;

 int n,x;
 const int maxn=2e5+;
 struct node
 {
     int to;
     int nxt;
 }edge[maxn<<];
 int tot;
 int head[maxn];
 int du[maxn];
 int dep[maxn];
 int path[maxn];
 int vis[maxn];
 int d[maxn];
 int col;
 int ans;
 void Init()
 {
     memset(path,,sizeof(path));
     memset(du,,sizeof(du));
     memset(head,-,sizeof(head));
     memset(dep,,sizeof(dep));
     memset(vis,,sizeof(vis));
     memset(d,,sizeof(d));
     tot=;
     col=;
     ans=;
 }
 void add(int u,int v)
 {
     edge[tot].to=v;
     edge[tot].nxt=head[u];
     head[u]=tot++;
 }

 int dfs(int u,int pre)
 {
     for(int i=head[u];i!=-;i=edge[i].nxt)
     {
         int to=edge[i].to;
         if(to==pre)
         {
             continue;
         }
         dep[to]=dep[u]+;
         d[u]=max(d[u],dfs(to,u)+);
     }
     return d[u];
 }

 void pdfs(int u,int pre,int cnt)
 {
     if(col!=)
     {
         return;
     }
     path[cnt]=u;
     if(u==x)
     {
         col=cnt;
         return;
     }
     for(int i=head[u];i!=-;i=edge[i].nxt)
     {
         int to=edge[i].to;
         if(to==pre)
         {
             continue;
         }
         pdfs(to,u,cnt+);
     }
 }
 void Solve()
 {
     dfs(,);
     pdfs(,,);
     vis[]=;
     for(int i=col,k=;i>=,k<=col;i--,k++)
     {
         if(!vis[i])
         {
             ans=max(ans,d[path[i]]+dep[path[i]]);
         }
         vis[k]=;
     }
     cout<<ans*<<endl;

 }
 int main()
 {
     while(~scanf("%d%d",&n,&x))
     {
         Init();
         int u,v;
         for(int i=;i<n-;i++)
         {
             scanf("%d%d",&u,&v);
             add(u,v);
             add(v,u);
             du[u]++;
             du[v]++;
         }
         Solve();
     }
     return ;
 }

DFS