树上的DP

CF#196B http://codeforces.com/contest/338/problem/B

题意：在一颗树上，给m个点，求到所有m个点距离不超过d的点的个数，所有路径长度为1。

分析：问题转化，就是求一个点是否到离它最远的给定点的距离小于d,

先第一遍dfs1求出以当前节点u为根的子树到子树中离它最远的给定点的距离d1[u]，和次远的距离d2[u]，

并且记录下最远距离是从哪个son转移过来的,fo[u]；

第二遍dfs2求出当前节点从它fa出发能碰到给定点的最远距离up[u]，那么对于当前点u,max(d1[u],up[u])，就是u到

所有给定点的最远的距离；

up[]的可以按照dfs的顺序递推求出，假设我们已经求出up[c1]，现在求up[c2]

up[c2]表示从c2的fa结点也就是c1那边给定结点（红色圆点）到c2的最远距离

那么up[c2] 由两部分转移过来，一个是原先以c1为根的子树除去c2的分支后的最远距离，这就是为什么要记录最远是从哪个son转移过来

dd = (fo[c1] == c2 ? d2[c1] : d1[c1]);

还有就是up[c1]；显然up[c2] = max(dd,up[c1])+1;(up[c1]表示从c6那边转移过来的值)

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#define pbk push_back
using namespace std;
const int N = 100000+10;
const int INF = 1000000+10;
vector<int> g[N];
int n,m,d;
bool p[N];
int d1[N],d2[N],fo[N],up[N];
int co[N];
void update(int c,int rt,int x,int &m1,int &m2) {
    if (x >= m1) {
        m2 = m1; m1 = x;
        fo[rt] = c;
    }else if (x < m1) {
        if (x > m2) m2 = x;
    }
}
void dfs1(int rt,int fa) {
    int sz = g[rt].size();
    d1[rt] = d2[rt] = -INF;
    for (int i = 0; i < sz; i++) {
        int c = g[rt][i];
        if (c == fa) continue;
        dfs1(c,rt);
        if (co[c]) {
            update(c,rt,d1[c]+1,d1[rt],d2[rt]);
            co[rt] = 1;
        }
    }
    if (p[rt]) {
        if (d1[rt] > 0 && d2[rt] < 0) d2[rt] = 0;
        if (d1[rt] < 0) {
            d1[rt] = 0; fo[rt] = rt;
        }
        co[rt] = 1;
    }
}
void dfs2(int rt,int fa) {
    int sz = g[rt].size();
    for (int i = 0; i < sz; i++) {
        int c = g[rt][i];
        if (c == fa) continue;
        int dd = (fo[rt] == c ? d2[rt] : d1[rt]);
        up[c] = max(dd, up[rt]) + 1;
        dfs2(c,rt);
    }
}
void solve(){
    memset(co,0,sizeof(co));
    memset(fo,-1,sizeof(fo));
    dfs1(1,-1);
    up[1] = -INF;
    dfs2(1,-1);
  
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        if (d1[i] <= d && up[i] <= d) ans++;
    }
    printf("%d\n",ans);
}
int main(){
    while (~scanf("%d%d%d",&n,&m,&d)) {
        memset(p,0,sizeof(p));
        for (int i = 0; i < m; i++) {
            int f; scanf("%d",&f);
            p[f] = 1;
        }
        for (int i = 0; i <= n; i++) g[i].clear();
        for (int i = 0; i < n-1; i++) {
            int u,v; scanf("%d%d",&u,&v);
            g[u].pbk(v); g[v].pbk(u);
        }
        solve();
    }
    return 0;
}

 

hdu4679 http://acm.hdu.edu.cn/showproblem.php?pid=4679

题意：给n个结点的树，每条边上都有一个w，去掉一条边后变成两颗树，选一条边使得w*max(diaA,diaB);其中diaA,diaB表示树的直径（树上最长路）；

分析：删掉一条边后，分成两部分，一部分是原先的子树，对于所有子树我们可以一遍dfs求出它的dia,问题我们该怎么求出

另外一部分的dia，设dia[u]表示从u的fa那一边能得到的最大直径，dis[u]表示u的fa那边能得到的最大距离，

那么这一部分的dia就是max(dia[u],dis[u]+1+md, dd);其中md表示删掉边后以u为根的子树叶子节点到u的最远距离，

dd表示删掉边后以u为根的子树的直径；这样就可以求出删掉一条边后的解了；

dd是B部分，dis[u]+1+md是A,B和起来的部分，dia[u]表示A部分；

接着就是该如何求dia[u], dis[u]；

dis[u]的求法和上一题一样，dia[u]的求法也差不多

在第一遍dfs的时候保留下以u为根的子树到u的最大，次大，次次大的距离，并且保存下最大，次大是从哪个son转移过来的，

这样就可以再第二遍dfs的时候递推求出dia[u],dis[u];

 

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<set>
#pragma comment(linker, "/STACK:1024000000,1024000000")
#define pbk push_back
using namespace std;
const int N = 100000+10;
const int INF = 1000000+10;
struct edge{
    int v,w,id;
    edge(int v,int w,int id):v(v),w(w),id(id){}
};
vector<edge> g[N];
int n;
int md1[N],md2[N],md3[N],fro1[N],fro2[N];
void update(int x,int c,int rt) {
    if (x >= md1[rt]) {
        md3[rt] = md2[rt];
        md2[rt] = md1[rt]; fro2[rt] = fro1[rt];
        md1[rt] = x; fro1[rt] = c;
    }else if (x >= md2[rt]){
        md3[rt] = md2[rt];
        md2[rt] = x; fro2[rt] = c;
    }else if (x > md3[rt]) md3[rt] = x;
}
void dfs1(int rt,int fa) {
    int sz = g[rt].size();
    md1[rt] = md2[rt] = md3[rt] = 0;
    for (int i = 0; i < sz; i++) {
        edge c = g[rt][i];
        if (c.v == fa) continue;
        dfs1(c.v,rt);
        update(md1[c.v]+1,c.v,rt);
    }
}
int dis[N],dia[N];
int an1,an2;
void dfs2(int rt,int fa) {
    int sz = g[rt].size();
    for (int i = 0; i < sz; i++) {
        edge c = g[rt][i];
        if (c.v == fa) continue;
        int dd ,md;
        if (fro1[rt] == c.v) {
            dd = md2[rt] + md3[rt]; md = md2[rt];
        }else if (fro2[rt] == c.v) {
            dd = md1[rt] + md3[rt]; md = md1[rt];
        } else {
            dd = md1[rt] + md2[rt]; md = md1[rt];
        }
        dd = max(dd, max(dia[rt],dis[rt] + 1 + md));
        dia[c.v] = dd;
        dd = max(dd, md1[c.v] + md2[c.v]);
        dis[c.v] = max(md, dis[rt] + 1);
        if (an1 == -1) {
            an1 = c.id; an2 = dd * c.w;
        }else if (dd * c.w < an2) {
            an1 = c.id; an2 = dd * c.w;
        }else if (dd * c.w == an2 && c.id < an1) {
            an1 = c.id;
        }

        dfs2(c.v,rt);
    }
}
void solve(){
    dfs1(1,-1);
    dia[1] = -INF; dis[1] = -INF;
    an1 = -1;
    dfs2(1,-1);
    printf("%d\n",an1);
}
int main(){
    int T,cas = 0; scanf("%d",&T);
    while (T--) {
        scanf("%d",&n);
        for (int i = 0; i <= n; i++) g[i].clear();
        for (int i = 1; i < n; i++) {
            int u,v,w; scanf("%d%d%d",&u,&v,&w);
            g[u].pbk(edge(v,w,i));
            g[v].pbk(edge(u,w,i));
        }
        printf("Case #%d: ",++cas);
        solve();
    }
    return 0;
}

 

 hdu 4661 http://acm.hdu.edu.cn/showproblem.php?pid=4661

题意：n个，他们之间的关系是一棵树，每个人都有一个消息，每次可以选一个人把他知道的所有消息传给另一个人，问

所有人知道所有消息的方案数，假设要传k次，其中只要有一次传出的人或接受的人不同都算不同；

分析：每个人至少要把自己的消息传出去，至少要接受一次消息，很明显，确定树根后只要从叶子节点一层一层传上来

直到跟然后再从跟传下去，一共(n-1)*2,是最优的；求方案数，首先是从叶子节点传到根，其实就是所有节点的拓扑序的个数；

设f[u]表以u为根节点的子树的拓扑序的总数num[u]表示子树的结点数，

那么f[u] = f[son1] * f[son2] * f[soni] * (num[u]-1)!/(num[son1]! * num[son2]! * num[soni] ! );

通过一遍dfs在确定根后，可以求出所有子树的f[]，在第二遍dfs的时候通过维护从当前结点的fa那边的拓扑序列，和num[]值

递推求出以当前结点为树根的最终方案； 

然后是根传到叶子结点是等价于从叶子结点传到根的，所有累加所有方案数的平方就是最终解；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000") 
#include<set>
using namespace std;
typedef long long LL;
const int N = 1000000+10;
const int Mod = 1e9+7;
vector<int> g[N];
int n;
LL ifac[N],fac[N];
void ex_gcd(LL a, LL b, LL &g, LL &x, LL &y) {
    if (b == 0) {
        g = a; x = 1; y = 0;
    }else {
        ex_gcd(b, a%b, g, y, x);
        y -= x * (a/b);
    }
}
LL inv(LL a, LL n) {
    LL x,y,g;
    ex_gcd(a,n,g,x,y);
    return g == 1 ? (x % n + n) % n : -1;
}
void init(){
    fac[0] = 1; ifac[0] = 1;
    for (int i = 1; i < N; i++) {
        fac[i] = fac[i-1] * i % Mod;
        ifac[i] = inv(fac[i],Mod);
    }
}
int num[N],f[N];
void dfs1(int rt,int fa) {
    int sz = g[rt].size();
    num[rt] = 0; f[rt] = 1;
    for (int i = 0; i < sz; i++) {
        int c = g[rt][i];
        if (c == fa) continue;
        dfs1(c,rt);
        num[rt] += num[c];
        f[rt] = (LL)f[rt] * f[c] % Mod * ifac[num[c]] % Mod;
    }
    num[rt] += 1;
    f[rt] = (LL)f[rt] * fac[num[rt] - 1] % Mod;
}
LL ans;
int up[N],cn[N];
void dfs2(int rt,int fa) {
    int sz = g[rt].size();
    for (int i = 0; i < sz; i++) {
        int c = g[rt][i];
        if (c == fa) continue;

        LL tmp = (LL)f[rt] * ifac[num[rt] - 1] % Mod * fac[num[c]] % Mod * inv(f[c],Mod) % Mod ;
        tmp = tmp * up[rt] % Mod * ifac[n - num[rt]] % Mod * fac[n - num[c] - 1] % Mod;
        up[c] = tmp;

        LL tp = f[c] * ifac[num[c] - 1] % Mod  * tmp % Mod * ifac[n - num[c]] % Mod * fac[n-1] % Mod;
        ans = (ans +  tp * tp) % Mod;
        dfs2(c,rt);
    }
}
void solve(){
    dfs1(1,-1);
    ans = (LL)f[1] * f[1] % Mod;
    up[1] = 1;
    dfs2(1,-1);
    printf("%I64d\n",ans);
}
int main(){
    init();
    int T; scanf("%d",&T);
    while (T--) {
        scanf("%d",&n);
        for (int i = 0; i <= n; i++) g[i].clear();
        for (int i = 0; i < n-1; i++) {
            int u,v; scanf("%d%d",&u,&v);
            g[u].push_back(v); g[v].push_back(u);
        }
        solve();
    }
    return 0;
}

 

hdu 4276 http://acm.hdu.edu.cn/showproblem.php?pid=4276

题意：给你一棵树，路径上有一个花费，每个节点有一个价值，问在T时间内，从1走到n能得到的最大价值；

分析：首先因为在树上，所有从1到n的路径是唯一的，也就是唯一路径上的边我们只会走一次，然后我们可以想象

如果把1和n结点拉直后，会变成一个森林并且树的根都是在路径上的，并且如果要去拿那里的价值每条路径都要经历2边；

思路就很明了，先预处理出所有路径上的点，然后以路径上的结点为子树根求出以每个根花费j能得到的最大代价,

最后就是分组背包，每组选一个；

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
#define mp make_pair
#define pbk push_back
using namespace std;
const int N = 100+10;
typedef pair<int,int> pii;
int dp[N][500+10];
int n,T;
vector<pii> G[N];
int val[N];
int On[N], f, sti;
void dfs_find(int u,int fa,int dep) {
    int sz = G[u].size();
    On[u] = 1;
    if (u == n) {
        f = 1;
        return;
    }
    for (int i = 0; i < sz; i++) {
        int v = G[u][i].first;
        if (v == fa) continue;
        sti = sti + G[u][i].second;
        dfs_find(v,u,dep+1);
        if (f) return;
        sti = sti - G[u][i].second;
    }
    On[u] = 0;
}
void dfs(int u,int fa) {
    int sz = G[u].size();
    for (int i = 0; i <= T - sti; i++) dp[u][i] = val[u];
    for (int i = 0; i < sz; i++) {
        int v = G[u][i].first;
        if (On[v] || v == fa) continue;
        dfs(v, u);
        int ti = G[u][i].second * 2;
        for (int j = T - sti; j >= 0; j--) {
            for (int k = 0; k <= j - ti; k++) {
                dp[u][j] = max(dp[u][j], dp[u][j - k - ti] + dp[v][k]);
            }
        }
    }

}
int an[500+10];
void solve(){
    memset(On,0,sizeof(On));
    f = 0; sti = 0;
    dfs_find(1,-1,0);
    if (sti > T) {
        puts("Human beings die in pursuit of wealth, and birds die in pursuit of food!");
        return;
    }
    memset(dp,0,sizeof(dp));
    for (int i = 1; i <= n; i++) {
        if (On[i]) {
          dfs(i,-1);
        }
    }
    //分组背包 
    memset(an,0,sizeof(an));
    for (int i = 1; i <= n; i++) if (On[i]){
        for (int j = T - sti; j >= 0; j--) {
            for (int k = 0; k <= j; k++) {
                an[j] = max(an[j], an[j - k] + dp[i][k]);
            }
        }
    }
    int idx = 0;
    for (int i = 0; i <= T - sti; i++) {
        if (an[i] > an[idx]) idx = i;
    }
    printf("%d\n",an[idx]);

}
int main(){
    while (~scanf("%d%d",&n,&T)) {
        for (int i = 0; i <= n; i++) G[i].clear();
        for (int i = 0; i < n-1; i++) {
            int u,v,w; scanf("%d%d%d",&u,&v,&w);
            G[u].pbk(mp(v,w)); G[v].pbk(mp(u,w));
        }
        for (int i = 1; i <= n; i++) scanf("%d",val+i);
        solve();
    }
    return 0;
}

 

 

 hdu 4044

题意：可以在结点上建至多一个炮台，花费已知，攻击力已知，求只有m费用的情况下从结点1到叶子结点的路径上攻击力之和的最小值最大；

分析：对于结点1，首先我们要分配m使得它的各个son的攻击力之和最小值经历大，dp[u][m]表示的就是以结点u为子树根花费m能得到的对于该子树的最小值最大；

现在的问题就是这么推出dp[u][m]; 显然 对已son1来说dp[u][m] = dp[son1][m]; 对于son2： tp = max(tp,min(dp[u][m-k], dp[son2][k])); dp[u][m] = tp;此时的dp[u][m-k]表示的前i个son都取完之后最小的攻击力最大的值；  当遍历完son之后，那么再加上u位置能建立的炮台，就是最终的答案；

trick : 因为花费有为zero的，所有直接dp[u][m] = max(dp[u][m], dp[u][m-x] + y);是有问题的，当存在两次以上花费为0的数据就会错误，所以要预先处理处理花费为i最大攻击力；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<vector>
#include<map>
#define pbk push_back
#define mp make_pair
using namespace std;
const int N = 1000+10;
typedef pair<int,int> pii;
int dp[N][200+10];
int n,m;
vector<int> g[N];
vector<pii> tow[N];
int tp[N][200+10];
void dfs(int u,int fa) {
    bool first = true;
    for (int i = 0; i < g[u].size(); i++) {
        int  v = g[u][i];
        if (v == fa) continue;
        dfs(v,u);
        if (first) {
            for (int j = 0; j <= m; j++) dp[u][j] = dp[v][j];
            first = false;
            continue;
        }
        for (int j = m; j >= 0; j--) {
            int tp = 0;
            for (int k = 0; k <= j; k++) {
                int tmp = min (dp[u][j-k], dp[v][k]);
                //if (first) tmp = dp[v][k];
                tp = max(tp, tmp);
            }
            dp[u][j] = tp;
        }
        //first = false;
    }

    for (int i = m; i >= 0; i--) {
       /* for (int j = 0; j < tow[u].size(); j++) {
             int x = tow[u][j].first, y = tow[u][j].second;
             dp[u][i] = max(dp[u][i], dp[u][i-x] + y);
        }*/
        for (int j = 0; j <= i; j++) dp[u][i] = max(dp[u][i], dp[u][i - j] + tp[u][j]);
    }
}
void solve() {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) tp[i][j] = max(tp[i][j], tp[i][j-1]);
    }
    memset(dp, 0, sizeof(dp));
    dfs(1,-1);
    int idx = 0;
    for (int i = 0; i <= m; i++) {
        if (dp[1][i] > dp[1][idx]) idx = i;
    }
    printf("%d\n",dp[1][idx]);
}
int main(){
    int T; scanf("%d",&T);
    while (T--) {
        scanf("%d",&n);
        for (int i = 0; i <= n; i++) g[i].clear();

        for (int i = 0; i < n-1; i++) {
            int u,v; scanf("%d%d",&u,&v);
            g[u].pbk(v); g[v].pbk(u);
        }
        scanf("%d",&m);
        memset(tp,0,sizeof(tp));
        for (int i = 1; i <= n; i++) {
            int c; scanf("%d",&c);
            tow[i].clear();
            for (int j = 0; j < c; j++) {
                int u,v; scanf("%d%d",&u,&v);
         //       tow[i].pbk(mp(u,v));
                tp[i][u] = max(tp[i][u],v);
            }
        }

        solve();

    }

    return 0;
}

/*
2
2
1 2
30
3 10 20 20 40 30 50
3 10 30 20 40 30 45
4
2 1
3 1
1 4
9
3 10 20 20 40 30 50
3 10 30 20 40 30 45
3 10 30 20 40 30 35
3 10 30 20 40 30 35

*/

 

 CF 219D

题意：一棵树，路径是由方向的，选一个节点，使得旋转最少的边使得从该结点到所有结点都有路；

分析：如果路径分别标记为1，-1那么就是统计以某个结点为根，-1的最小个数，dp[u]表示以u为根的子树下有多少个-1；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<set>
#define pbk push_back
#define mp make_pair
using namespace std;
const int N = 200000 + 10;
typedef pair<int,int> pii;
vector<pii> g[N];
int n;
int dp[N];
vector<int> an;
int up;
void dfs1(int u,int fa) {
    int sz = g[u].size();
    dp[u] = 0;
    for (int i = 0; i < sz; i++) {
        int v = g[u][i].first;
        if (v == fa) continue;
        dfs1(v,u);
        dp[u] += dp[v] + (g[u][i].second == -1 ? 1 : 0);
    }
}
void update(int u,int v) {
    if (u < up) {
        up = u;
        an.clear(); an.pbk(v);
    }else if ( u == up ) an.pbk(v);
}
void dfs2(int u,int fa,int ba) {
    int sz = g[u].size();

    for (int i = 0; i < sz; i++) {
        int v = g[u][i].first;
        if (v == fa) continue;
        int tp = dp[u] - dp[v] - (g[u][i].second == -1 ? 1 : 0) + ba + (g[u][i].second == 1 ? 1 : 0);
        update(dp[v] + tp,v);
        dfs2(v,u,tp);
    }
}
void solve(){
    memset(dp,0,sizeof(dp));
    dfs1(1,-1);
    up = dp[1];
    an.clear();
    an.pbk(1);
    dfs2(1,-1,0);
    printf("%d\n",up);
    sort(an.begin(),an.end());
    for (int i = 0; i < an.size(); i++) {
        printf("%d%c",an[i],i == an.size() - 1 ? '\n' : ' ');
    }
}
int main() {
    while (~scanf("%d",&n)) {
        for (int i = 0; i <= n; i++) g[i].clear();
        for (int i = 0; i < n-1; i++) {
            int u,v;  scanf("%d%d",&u,&v);
            g[u].pbk(mp(v,1)); g[v].pbk(mp(u,-1));
        }
        solve();
    }
    return 0;
}

 

CF 120F http://codeforces.com/problemset/problem/120/F

题意：给你n棵树，累加每棵树的直径；

分析：直接求；该题CF上是文件读入的；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<vector>
#define pbk push_back
#define mp make_pair
using namespace std;
typedef pair<int,int> pii;
const int N = 100+10;
vector<int> g[N];
int n;
int an;
int dia[N],di1[N],di2[N],fo[N],mxdia;
void update(int x,int u,int v) {
    if (x > di1[u]) {
        di2[u] = di1[u];
        di1[u] = x;
        fo[u] = v;
    }else if (x == di1[u] && x > di2[u]) di2[u] = x;
}
void dfs1(int u,int fa) {
    int sz = g[u].size();
    di1[u] = di2[u] = 0;
    for (int i = 0; i < sz; i++) {
        int v = g[u][i];
        if (v == fa) continue;
        dfs1(v,u);
        update(di1[v] + 1,u,v);
    }
    dia[u] = di1[u] + di2[u];
}
void dfs2(int u,int fa,int up) {
    int sz = g[u].size();
    for (int i = 0; i < sz; i++) {
        int v = g[u][i];
        if (v == fa) continue;
        int tp = max((fo[u] == v ? di2[u] : di1[u]) , up ) + 1;
        mxdia = max(mxdia, di1[v] + tp);
        dfs2(v,u,tp);
    }
}
void solve(){
    dfs1(1,-1);
    mxdia = dia[1];
    dfs2(1,-1,0);
    an += mxdia;
}
int main(){
    int c;
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    while (~scanf("%d",&c)) {
        an = 0;
        while (c--) {
            scanf("%d",&n);
            for (int i = 0; i <= n; i++) g[i].clear();
            for (int i = 0; i < n-1; i++) {
                int u,v; scanf("%d%d",&u,&v);
                g[u].pbk(v); g[v].pbk(u);
            }
            solve();
        }
        printf("%d\n",an);
    }
    return 0;
}

 

 CF 212E 

题意：一棵树上放两种餐厅，不同的餐厅不能相邻，每种餐厅至少一个，问最多能放几个，并且输出所有可行方案；

分析：显然对于一棵上来说，肯定可以选出一个节点，它有至少两个分支，所以最多的放置数为n-1

对于方案数，我们可以枚举结点，然后对于至少有两个分支的结点进行背包，求出第一中餐厅能放的值，那么所有答案并就是方案；

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<vector>
#define pbk push_back
using namespace std;
const int N = 50000+10;
vector<int> g[N];
int n;
int an[N];
int dp[N];

void dfs1(int u,int fa) {
    int sz = g[u].size();
    dp[u] = 1;
    for (int i = 0; i < sz; i++) {
        int v = g[u][i];
        if (v == fa) continue;
        dfs1(v,u);
        dp[u] += dp[v];
    }
}
void dfs2(int u,int fa,int up) {
    int sz = g[u].size();
    bool tmp[N];
    memset(tmp,0,sizeof(tmp));
    tmp[0] = 1;
    int cnt = 0;
    for (int i = 0; i < sz; i++) {
        int v = g[u][i];
        if (v == fa) continue;
        cnt++;
        dfs2(v,u,up + dp[u] - dp[v]);
        for (int j = n; j >= dp[v]; j--) {
            if (tmp[j - dp[v]] == 1) tmp[j] = 1;
        }
    }
    for (int j = n; j >= up; j--) {
        if (tmp[j - up]) tmp[j] = 1;
    }
    if (up == 0 && cnt == 1) return;
    for (int j = n; j >= 0; j--) {
        if (tmp[j]) an[j] = 1;
    }
}
void solve() {
    memset(an,0,sizeof(an));
    dfs1(1,-1);

    dfs2(1,-1,0);
    int cnt = 0;
    for (int i = 1; i < n-1; i++) if (an[i]) cnt++;
    printf("%d\n",cnt);
    for (int i = 1; i < n-1; i++) {
        if (an[i]) printf("%d %d\n",i,n-1-i);
    }
}
int main(){
    while (~scanf("%d",&n)) {
        for (int i = 0; i <= n; i++) g[i].clear();
        for (int i = 0; i < n-1; i++) {
            int u,v; scanf("%d%d",&u,&v);
            g[u].pbk(v); g[v].pbk(u);
        }
        solve();
    }
    return 0;
}