patrol 巡逻 （HYSBZ - 1912，树的直径）

一.题目链接：

HYSBZ-1912

二.题目大意：

给定 n，k（k 取 1 或 2）.

给定 n 个点的树，每条边权为 1.

从 1 号点出发，要求每条路都要走，最终回到 1 号点.

之后建造 k 条新路，要求新路走且仅走一次.

求最短路径.

三.分析：

显然，若不建造新路，每条边都要走两遍（进一次，出一次），此时花费为 2 * (n - 1).

显然，若只建造一条新路，则此路构成的环上的边仅需要走一次，设该 “环” 长度为 L1，则花费为 2 * (n - 1) - L1 + 1.

即，当 L1 取最大值（树的直径）时，花费最小.

下面讨论建两条新路的情况

首先，证明建两条新路中比包含树的直径

证明如下：orzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz

现在再考虑第二条路怎样加.

若两条路无重叠，则两个环的边都只需要走一遍.

若两条路有重叠，则两个环的不同边都只需要走一遍，而重叠的边需要走两遍.

不妨设花费为 2 * (n - 1) - L1 + 1 - L2 + 1

其中，L2 的计算方法如下：

若该边为重叠边，则该边权值为 -1.

若该边为非重叠边，则该边权值为 1.

可由 L1 与 L2 的算术表达式得出

如图：

最初的一棵树

2 * (n - 1) = 2 * (e1 + e2 + e3 + e4 + e5  +e6 + e7 + e8 + e9 + e10 + e11 + e12 + e13)

第一次连接了红边（假设），构成了环.

L1 = e3 + e4 + e8 + e9

2 * (n - 1) - L1 + 1 = 2 * (e1 + e2 + e5  +e6 + e7 + e10 + e11 + e12 + e13) + e3 + e4 + e8 + e9 + 1

第二次连接了蓝边（假设），构成了环.

L2 = -e4 - e9 + e1 + e2 + e5 + e10

2 * (n - 1) - L1 + 1  - L2 + 1 = 2 * (e4 + e6 + e7 + e9 + e11 + e12 + e13) + e1 + e2 + e3 + e5 + e8 + e10 + 2

由此可知，只需将 L1 路径上的权值置为 -1，求出最大的 L2，即为所添加的第二条路径.

 

注意：两遍 bfs 求直径用来记录路径，但不能用于负边.

四.代码实现：

#include <bits/stdc++.h>
using namespace std;

const int M = (int)1e5;
const int inf = 0x3f3f3f3f;

int n, k;

int cnt;
int head[M + 5];
struct node
{
    int v, w, nx;
}Edge[M * 2 + 5];

int dis[M + 5];
int pre[M + 5];

void init()
{
    cnt = 0;
    for(int i = 1; i <= n; ++i)
    {
        head[i] = -1;
    }
}

void add(int u, int v, int w)
{
    Edge[cnt].v = v;
    Edge[cnt].w = w;
    Edge[cnt].nx = head[u];
    head[u] = cnt++;
}

int bfs(int s)
{
    memset(dis, inf, sizeof(dis));
    dis[s] = 0;
    for(int i = 0; i < cnt; ++i)
    {
        if(Edge[i].v == s)
        {
            pre[s] = i;
            break;
        }
    }
    queue <int> q;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = Edge[i].nx)
        {
            int v = Edge[i].v;
            if(dis[v] == inf)
            {
                dis[v] = dis[u] + Edge[i].w;
                pre[v] = i;
                q.push(v);
            }
        }
    }
    int p = 1;
    for(int i = 1; i <= n; ++i)
    {
        if(dis[i] > dis[p])
        {
            p = i;
        }
    }
    return p;
}

void change(int p, int q)
{
    for( ; p != q; q = Edge[pre[q]^1].v)
    {
        Edge[pre[q]].w = Edge[pre[q]^1].w = -1;
    }
}

void dfs(int u, int fa, int &dia)
{
    for(int i = head[u]; ~i; i = Edge[i].nx)
    {
        int v = Edge[i].v;
        if(v == fa) continue;
        dfs(v, u, dia);
        dia = max(dia, dis[u] + dis[v] + Edge[i].w);
        dis[u] = max(dis[u], dis[v] + Edge[i].w);
    }
}

int work()
{
    int p = bfs(1);
    int q = bfs(p);
    int dia1 = dis[q];
    if(k == 1)
        return 2 * (n - 1) - dia1 + 1;
    else if(k == 2)
    {
        change(p, q);
        int dia2 = 0;
        memset(dis, 0, sizeof(dis));
        dfs(1, 0, dia2);
        return 2 * (n -1) - dia1 + 1 - dia2 + 1;
    }
}

int main()
{
    scanf("%d %d", &n, &k);
    init();
    for(int i = 0, u, v; i < n - 1; ++i)
    {
        scanf("%d %d", &u, &v);
        add(u, v, 1), add(v, u, 1);
    }
    printf("%d\n", work());
    return 0;
}