hdu5593 树形dp

ZYB's Tree

 

 Accepts: 77

 

 Submissions: 513

 Time Limit: 3000/1500 MS (Java/Others)

 

 Memory Limit: 131072/131072 K (Java/Others)

问题描述

$ZYB$有一颗$N$个节点的树,现在他希望你对于每一个点,求出离每个点距离不超过$K$的点的个数.

两个点$(x,y)$在树上的距离定义为两个点树上最短路径经过的边数,

为了节约读入和输出的时间,我们采用如下方式进行读入输出:

读入:读入两个数$A,B$,令fa_ifa​i​​为节点$i$的父亲,fa_1=0fa​1​​=0;fa_i=(A*i+B)\%(i-1)+1fa​i​​=(A∗i+B)%(i−1)+1 $i\in [2,N]$ .

输出:输出时只需输出$N$个点的答案的$xor$和即可。

输入描述

第一行一个整数$T$表示数据组数。

接下来每组数据：

 一行四个正整数$N,K,A,B$.

 最终数据中只有两组$N\ge 100000$。

$1\le T\le 5$,$1\le N\le 500000$,$1\le K\le 10$,$1\le A,B\le 1000000$

输出描述

$T$行每行一个整数表示答案.

输入样例

1
3 1 1 1

输出样例

3

点分治可做，但是常数很大，ｋ很小直接ｄｐ更好，令ｆ[u][i]表示和ｕ节点相邻距离不超过ｋ的节点数木，可以先ｄｆｓ一遍求出ｕ的子树中和他距离不超过ｋ的，然后向上走ｋ次就能得到这个节点的ｆ值了．比赛时候数组开成了f[][10]被ｈａｃｋ。。。。

#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
typedef long long ll;
const int maxn = 5e5+10;
using namespace std;
vector<int> g[maxn];
int dep[maxn],id[maxn];
int f[maxn][10],k,p[maxn];
void dfs(int u,int fa)
{
    f[u][0] = 1;
    dep[u] = dep[fa] +1;
    for(int i = 1; i <= k; ++i) f[u][i] = 1;
    for(int i = 0; i < g[u].size(); ++i) {
        int v = g[u][i];
        if(v == fa) continue;
        dfs(v,u);
        for(int j = 1; j <= k; ++j) f[u][j] += f[v][j-1];
    }
}
bool cmp(const int &i,const int &j)
{
    return dep[i] > dep[j];
}
int main()
{
    int T;scanf("%d",&T);
    while(T--) {
        int n,a,b;scanf("%d%d%d%d",&n,&k,&a,&b);
        for(int i = 1; i <= n; ++i) {
            g[i].clear();
            id[i] = i;
        }
        p[1] = 0;
        dep[0] = 0;
        for(int i = 2; i <= n; ++i) {
            int fa = (a*(i+0LL)+b)%(i-1)+1;
            g[fa].push_back(i);
            p[i] = fa;
        }
        dfs(1,0);
        sort(id+1,id+1+n,cmp);///按深度排序
        int ans = 0;
        for(int i = 1; i <= n; ++i) {
            int v = id[i];
            int pre = v,tp = v;
            for(int d = 1; d <= k; ++d) {
                pre = p[pre];
                if(!pre)break;
                f[v][k] += f[pre][k-d]-((k-d==0)?0:f[tp][k-d-1]);　///用祖先来更新ｖ
                tp = pre;
            }
            ans ^= f[v][k];
        }
        printf("%d\n",ans);
    }
    return 0;
}