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=1;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=0;i<edge[now].size();i++)
    {
        Edge temp=edge[now][i];
        if(temp.dst!=p) dfs1(temp.dst,now);
    }
    for(int k=1;k<=100;k++)
    {
        for(int i=0;i<edge[now].size();i++)
        {
            Edge temp=edge[now][i];
            if(temp.dst!=p)
            {
                for(int j=0;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!=-1)
    {
        for(int k=1;k<=100;k++)
        {
            for(int j=0;j<k;j++)
            {
                old[now][j][k]=dp[now][j][k];
            }
        }
        for(int k=1;k<=100;k++)
        {
            for(int j=0;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=0;i<edge[now].size();i++)
    {
        Edge temp=edge[now][i];
        if(temp.dst!=p) dfs2(temp.dst,now,temp.len);
    }
}

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

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