牛客多校2-Cover the tree

题意：

　　给定一棵无根树，求用最少的链覆盖树上所有的边，并输出每条链的首位两端编号

做法：

　　首先确认需要多少条链来覆盖所有边。

　　显然，当n = 1时，只需要一条，链头尾编号都为1

　　　　　当n = 2时，需要一条，链头尾为1， 2

　　　　　当n >= 3时，上述两种情况链的头尾都是入度为1的点，而确实，当从一个叶子节点1出发，向上走到假定的根节点，再往下走到叶子节点2，如此反复形成的链，足以覆盖所有的边，并确为最少情况。

　　　　　但此法仅于叶子节点为偶数时适用，如何在叶子节点个数为奇数时确定最少链数，只需让根节点和最后剩余的叶子节点成链即可。

　　　　　对于每个叶子节点分配一个dfs序，用dfn[]数组记录，找到一个非叶子节点作为根节点，把一个树分成假定的左右子树，让每条链的两端分别处于左右不同的子树即可。

遍历一棵树的时间复杂度O(n)

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

const int inf = 0x3f3f3f3f;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 2e5 + 7;

vector<int> g[maxn];
int n;

int du[maxn];
int dfn[maxn];
int vis[maxn];
int cnt = 0;

void dfs(int u, int fa) {
    int d = g[u].size();
    for ( int i = 0; i < d; ++i ) {
        int v = g[u][i];
        if(v == fa || vis[v]) {
            continue;
        }
        vis[v] = 1;
        dfs(v, u);
    }
    if(d == 1) {
        dfn[++cnt] = u;
    }
}

int main()
{
    read(n);
    for ( int i = 1; i <= n - 1; ++i ) {
        int u, v;
        read(u); read(v);
        g[u].push_back(v);
        g[v].push_back(u);
        ++du[u], ++du[v];
    }
    int root = -1;
    int num = 0;
    for ( int i = 1; i <= n; ++i ) {
        if(du[i] == 1) {
            ++num;
        }
    }
    for ( int i = 1; i <= n; ++i ) {
        if(du[i] > 1) {
            root = i;
            break;
        }
    }
    int ans = num / 2;
    if(num & 1) {
        ++ans;
    }
    if(n == 1) {
        cout << "1 1" << endl;
        return 0;
    }
    if(n == 2) {
        cout << "1 2" << endl;
        return 0;
    }
    dfs(root, -1);
    // for ( int i = 1; i <= cnt; ++i ) {
    //     printf("dfn[%d]:%d
",i, dfn[i]);
    // }
    int mid = (cnt + 1) >> 1;
    // dbg(mid);
    cout << ans << endl;
    for ( int i = 1; i <= cnt - mid; ++i ) {
        printf("%d %d
",dfn[i], dfn[i + mid]);
    }
    if(cnt & 1) {
        printf("%d %d
",dfn[mid], root);
    }
    return 0;
}