翻转树边~

给定一个 n 个节点的树。

节点编号为 1∼n。

树中的 n−1 条边均为单向边。

现在，我们需要选取一个节点作为中心点，并希望从中心点出发可以到达其他所有节点。

但是，由于树中的边均为单向边，所以在选定中心点后，可能无法从中心点出发到达其他所有节点。

为此，我们需要翻转一些边的方向，从而使得所选中心点可以到达其他所有节点。

我们希望选定中心点后，所需翻转方向的边的数量尽可能少。

请你确定哪些点可以选定为中心点，并输出所需的最少翻转边数量。

输入格式

第一行包含整数 n。

接下来 n−1 行，每行包含两个整数 a,b，表示存在一条从 a到 b 的单向边。

输出格式

第一行输出一个整数，表示所需的最少翻转边数量。

第二行以升序顺序输出所有可选中心点（即所需翻转边数量最少的中心点）的编号。

数据范围

前三个测试点满足 2≤n≤5。
所有测试点满足 2≤n≤2×1e5，1≤a,b≤n，a≠b。

输入样例1：

3
2 1
2 3

输出样例1：

0
2

输入样例2：

4
1 4
2 4
3 4

输出样例2：

2
1 2 3

分析：

昨天写这道题时想法很简单，看了n的数据范围，是在2e5 的范围内，因此不可能遍历每一个点为根节点的情况，这样必然会超时，然后我就想到了现遍历一遍试一下，遍历后发现，每个点v为根节点时，它的翻转边的数量只和它的父节点u有关，因为以v为根节点时,画图后可以发现除了u--v这条边在以u为根节点时和以v为根节点时的情况不一样，其他边的情况是一样的，因此只需要遍历一遍先知道一个点的翻转边的数量，然后更新它的子节点，继而更新到所有的点，这里是以1为根节点现遍历了节点1的翻转边数，然后由1写出了其他所有的点。

代码如下：

#include <bits/stdc++.h>

using namespace std;

const int N=2e5+10;
vector<int> ans[N];
struct node{
 int v;
 int st;
};
vector<node>adj[N];
int su[N];
int n,a,b;
int dfs(int fa,int u)
{
    int sum=0;
    for(int i=0;i<adj[u].size();i++)
    {
        int v=adj[u][i].v,st=adj[u][i].st,flag=0;
        if(v==fa) continue;
        if(!st) flag=1;
        sum+=flag+dfs(u,v);
    }
    return sum;
}
void dfs1(int fa,int u)
{
    for(int i=0;i<adj[u].size();i++)
    {
        int v=adj[u][i].v,st=adj[u][i].st,flag=0;
        //cout<<"u: "<<u<<" v: "<<v<<endl;
        if(v==fa) continue;
        if(st) flag=1;
        else flag=-1;
        su[v]=flag+su[u];
        //cout<<v<<" "<<su[v]<<endl;
        ans[su[v]].push_back(v);
        dfs1(u,v);
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<n;i++)
    {
        cin>>a>>b;
        adj[a].push_back({b,1});
        adj[b].push_back({a,0});
    }
    int sum=dfs(-1,1);
    ans[sum].push_back(1);
    su[1]=sum;
    dfs1(-1,1);
    for(int i=0;i<n;i++)
    {
        if(!ans[i].size()) continue;
        sort(ans[i].begin(),ans[i].end());
        cout<<i<<endl;
        for(int j=0;j<ans[i].size();j++)
        {
            cout<<ans[i][j]<<" ";
        }
        break;
    }
}