label

题意：

给出一棵以1为根节点包含n（<=100）个节点的树，然后在每个节点填上一个范围在[1,m(<=1e9)]的一个数字，使得任意两个节点之间的差的绝对值大于等于K(<=100)，求方案数。

题解：

很显然是树形dp，定义状态dp[u][i]表示在u这个节点填上i这个数的这棵子树的方案数。

考虑转移：

复杂度为 N * M * M ：TLE

但是会发现i可取的值的范围是连续的一段，那么可以维护一个前缀和就可以不用枚举i了。 复杂度为 N*M ：TLE

考虑一条链的情况，从根节点一直到叶子节点，很显然叶子节点的dp值全部为1，

那么往上返回的时候，令叶子节点的父节点的编号为u，会发现dp[u][1~K-1]的值对应dp[u][m~m-K+1]，然后dp[u][K~m-K]的值全部相等。

嗯再往上返回的时候，令其节点的父亲节点的编号为u，会发现dp[u][1~2*(K-1)]的值对应dp[u][m~m-2*(K-1)]，然后dp[u][2*K-1，m-2*K+1]的值全部相等

………………………………（这个可能需要自己手推一下）

然后就会发现dp[u][1~(n-1)*(K-1)]对应于dp[u][m~m-(n-1)*(K-1)]，然后dp[u][(n-1)*(K-1)+1 ~ m-(n-1)*(K-1)-1]的值全部相等。

现在，发现这个性质之后，观察(n-1)*(K-1)的大小只有1W，只需要关心前面(n-1)*(K-1)个数，中间的数，后面的(n-1)*(K-1)个数会大大降低复杂度，然后会得到这样的一个dp函数图像

前缀有lim-1个数，那么自然后缀的个数也为lim-1,那么中间相等的个数为m - 2*lim + 2，考虑维护前缀和，后缀和，所以现在只需要考虑i在lim范围只能选值，因为算出这些值其余的值都可以由这些值得到。

情况一：

那么这时的dp值应为(pre[i-K]) + (pre[lim-1] - pre[i+K-1]) + (m - 2*lim + 2) * mid[lim] + pre[lim-1]，也就是说除了[i-K,i+K]的部分的dp值之和。

情况二：

那么这时的dp值应该为pre[i-K] + (lim - i - K + 1) * mid[lim] + pre[lim-1]

情况三：

那么这时的dp值应该为pre[i-K] + pre[m-i-K+1]

然后就OK了~

代码：

#include <cstdio>
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
 
const int N = 1e2 + 7;
const int M = 1e4 + 7;
const int mod = 1e9 + 7;
#define ll long long
vector <int> e[N];
int lim, K, n, m, kase, ans;
ll mid[N][M], pre[N][M], suf[N][M];
 
void Dfs (int u, int father) {
    for (int i = 0; i < e[u].size(); ++i) {
        if (e[u][i] != father) Dfs (e[u][i], u);
    }
    for (int i = 1; i <= lim; ++i) mid[u][i] = 1;
    for (int i = 1; i <= lim; ++i) {
        for (int j = 0; j < e[u].size(); ++j) {
            int v = e[u][j];
            if (v == father) continue;
            ll sum = 0;
            if (i - K >= 1) sum = (sum + pre[v][i-K]) % mod;
            if (i + K <= lim) {
                sum = (sum + suf[v][i+K]) % mod;
                sum = (sum + pre[v][lim-1]) % mod;
                sum = (sum + mid[v][lim] * (m - 2 * lim + 1)) % mod;
            }
            else if (i + K <= m) {
                if (i + K <= m - lim + 1) {
                    sum = (sum + pre[v][lim-1]) % mod;
                    sum = (sum + mid[v][lim] * (m - lim - i - K + 2)) % mod;
                }
                else sum = (sum + pre[v][m - K - i + 1]) % mod;
            }
            if (K == 0) sum = (sum - mid[v][i] + mod) % mod;
            mid[u][i] = (mid[u][i] * sum) % mod;
        }
    }
    for (int i = 1; i <= lim; ++i) pre[u][i] = (mid[u][i] + pre[u][i-1]) % mod;
    for (int i = lim; i >= 1; --i) suf[u][i] = (mid[u][i] + suf[u][i+1]) % mod;
}
 
int main () {
    scanf ("%d", &kase);
    while (kase--) {
        for (int i = 1; i <= n; ++i) e[i].clear();
        memset (suf, 0, sizeof suf);
        memset (pre, 0, sizeof pre);
        scanf ("%d%d%d", &n, &m, &K);
        for (int i = 1; i < n; ++i) {
            int u, v;
            scanf ("%d%d", &u, &v);
            e[u].push_back(v);
            e[v].push_back(u);
        }
        lim = min (10000, m / 2 + (m & 1));
        Dfs (1, 0);
        ll ans = 0;
        ans = (ans + pre[1][lim-1]*2) % mod;
        ans = (ans + (m - 2 * lim + 2) * mid[1][lim]) % mod;
        cout << ans << endl;
    }
    return 0;
}

　　

总结：

做树形dp的时候一般先考虑链的特殊情况吧~然后真的要动笔算一算，其实主要就是发现这个性质，减少冗余计算，好坑呀有木有，被玩坏了QAQ