350. 巡逻

在一个地区有 n 个村庄，编号为 1,2,…,n。

有 n−1条道路连接着这些村庄，每条道路刚好连接两个村庄，从任何一个村庄，都可以通过这些道路到达其他任一个村庄。

每条道路的长度均为 1 个单位。

为保证该地区的安全，巡警车每天都要到所有的道路上巡逻。

警察局设在编号为 1 的村庄里，每天巡警车总是从警局出发，最终又回到警局。

为了减少总的巡逻距离，该地区准备在这些村庄之间建立 KK 条新的道路，每条新道路可以连接任意两个村庄。

两条新道路可以在同一个村庄会合或结束，甚至新道路可以是一个环。

因为资金有限，所以 K 只能为 1 或 2。

同时，为了不浪费资金，每天巡警车必须经过新建的道路正好一次。

编写一个程序，在给定村庄间道路信息和需要新建的道路数的情况下，计算出最佳的新建道路的方案，使得总的巡逻距离最小。

输入格式

第一行包含两个整数 n 和 K。

接下来 n−1 行每行两个整数 a 和 b，表示村庄 a 和 b之间有一条道路。

输出格式

输出一个整数，表示新建了 K 条道路后能达到的最小巡逻距离。

数据范围

3≤n≤100000,
1≤K≤2,
1≤a,b≤n

输入样例：

8 1 
1 2 
3 1 
3 4 
5 3 
7 5 
8 5 
5 6 

输出样例：

11

分析： 

在最初的树上,求出树的直径L1,然后将这条路径上的所有边权统统取反，1变成−1，然后我们再求一次树的直径L2.

答案就是：
2×(n−1)−(L1−1)−(L2−1)=2×(n−1)−L1+1−L2+1
假如说L2和L1有重叠部分.

那么当我们−L1+1，的时候,我们就会发现,重叠的部分变成了只需要经过一次.然后−L2+1，相当于把重叠部分相加回来了，此时变成了经过了两次。

代码如下：

#include <bits/stdc++.h>

using namespace std;
const int N=1e5+10;
struct node{
int v,w;
}an[N];
vector<node>adj[N];
int n,k,a,b,ans,id,anss;

int dfs(int fa,int u)//寻找最大直径
{
    int maxx=0,te=0;
    for(int i=0;i<adj[u].size();i++)
    {
        int v=adj[u][i].v,w=adj[u][i].w;
        if(v==fa)continue;
        int tem=dfs(u,v)+w;
        if(maxx<tem)
        {
            if(!maxx) maxx=tem,an[u].v=v;
            else te=maxx,maxx=tem,an[u].w=an[u].v,an[u].v=v;
        }
        else if(tem>te) te=tem,an[u].w=v;
    }
    if(ans<te+maxx)ans=te+maxx,id=u;
    return maxx;
}
void dfs1(int u)//将第一条直径中算到的边的边权均变为-1；
{
    for(int i=0;i<adj[u].size();i++)
    {
        int v=adj[u][i].v;
        if(v!=an[u].v) continue;
        adj[u][i].w=-1;
        dfs1(v);
    }
}
int main()
{
    cin>>n>>k;
    for(int i=1;i<n;i++)
    {
        cin>>a>>b;
        adj[a].push_back({b,1});
        adj[b].push_back({a,1});
    }
    dfs(-1,1);//求L1
    for(int i=0;i<adj[id].size();i++)
    {
        int v=adj[id][i].v;
        if(v!=an[id].v&&v!=an[id].w) continue;
        adj[id][i].w=-1;
        dfs1(v);//改权值
    }
    anss=(n-1)*2-(ans-1);
    if(k==2)
    {
        ans=0;
        dfs(-1,1);//求L2
        anss-=(ans-1);
    }
    cout<<anss;
    return 0;
}