TYOI Day1 travel：Tree dp【处理重复走边】

题意：

　　给你一棵树，n个节点，每条边有长度。

　　然后有q组询问(u,k)，每次问你：从节点u出发，走到某个节点的距离mod k的最大值。

题解：

　　对于无根树上的dp，一般都是先转成以1为根的有根树，然后分别从上到下和从下到上两遍dp。

　　另一个技巧是：处理重复走边的情况时，可以让dp值表示达到某种状态的方案数。

　　表示状态：

　　　　dp[i][j][k] = max dis

　　　　表示从i节点出发，走的距离mod k = j时的方案数

　　找出答案：

　　　　对于每次询问(u,k)，答案为：满足dp[u][d][k]>0的最大的d值。

　　如何转移：

　　　　第一遍dfs:

　　　　　　dp[i][(j+len)%k][k] = ∑ dp[son][j][k]

　　　　　　只考虑从上往下的路径。

　　　　第二遍dfs:

　　　　　　dp[i][(j+len)%k][k] += dp[par][j][k]

　　　　　　dp[i][(j+len)%k][k] -= old[i][((j-len)%k+k)%k][k]

　　　　　　其中old[i][j][k]代表原来的dp，即只考虑从上往下时的dp。

　　　　　　减去old是因为要将会导致重复走边的方案删去。

　　边界条件：

　　　　dp[i][0][k] = 1

　　　　others = 0

　　复杂度：

　　　　Tree dp: O(n*k*k)

　　　　Query: O(q*k)

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <vector>
 #define MAX_N 3005
 #define MAX_K 105

 using namespace std;

 struct Edge
 {
     int dst;
     int len;
     Edge(int _dst,int _len)
     {
         dst=_dst;
         len=_len;
     }
     Edge(){}
 };

 int n,q;
 int dp[MAX_N][MAX_K][MAX_K];
 int old[MAX_N][MAX_K][MAX_K];
 vector<Edge> edge[MAX_N];

 void read()
 {
     cin>>n;
     int x,y,z;
     for(int i=;i<n;i++)
     {
         cin>>x>>y>>z;
         edge[x].push_back(Edge(y,z));
         edge[y].push_back(Edge(x,z));
     }
 }

 void dfs1(int now,int p)
 {
     for(int i=;i<edge[now].size();i++)
     {
         Edge temp=edge[now][i];
         if(temp.dst!=p) dfs1(temp.dst,now);
     }
     for(int k=;k<=;k++)
     {
         for(int i=;i<edge[now].size();i++)
         {
             Edge temp=edge[now][i];
             if(temp.dst!=p)
             {
                 for(int j=;j<k;j++)
                 {
                     dp[now][(j+temp.len)%k][k]+=dp[temp.dst][j][k];
                 }
             }
         }
     }
 }

 void dfs2(int now,int p,int l)
 {
     if(p!=-)
     {
         for(int k=;k<=;k++)
         {
             for(int j=;j<k;j++)
             {
                 old[now][j][k]=dp[now][j][k];
             }
         }
         for(int k=;k<=;k++)
         {
             for(int j=;j<k;j++)
             {
                 dp[now][(j+l)%k][k]+=dp[p][j][k];
                 dp[now][(j+l)%k][k]-=old[now][((j-l)%k+k)%k][k];
             }
         }
     }
     for(int i=;i<edge[now].size();i++)
     {
         Edge temp=edge[now][i];
         if(temp.dst!=p) dfs2(temp.dst,now,temp.len);
     }
 }

 void work()
 {
     memset(dp,,sizeof(dp));
     for(int i=;i<=n;i++)
     {
         for(int k=;k<=;k++)
         {
             dp[i][][k]=;
         }
     }
     dfs1(,-);
     dfs2(,-,);
     cin>>q;
     int u,k;
     while(q--)
     {
         cin>>u>>k;
         for(int d=k-;d>=;d--)
         {
             if(dp[u][d][k])
             {
                 cout<<d<<endl;
                 break;
             }
         }
     }
 }

 int main()
 {
     read();
     work();
 }