BZOJ1912 巡逻

链接

巡逻

题解

$k=1$的情况很容易，直接连接直径两端即可，同时这种情况带来思路，一个环的出现可以使得环上的路径只需经过一次，也就是说给环上每条边带来$1$个单位的收益。当$k=2$时，想法依然是让收益尽量大，但此时每条边的收益不同于前一种情况，第一种情况的环上的边的收益变成$-1$，其余边仍为$1$，此时再求一边树的直径就是最大收益。这里仍然用到了贪心思想，也就是分别最大化两次选择，正确性并不会证明。。。

代码

#include <bits/stdc++.h>

using namespace std;

#define REP(i, n) for (int i = 1; i <= (n); i++)
#define sqr(x) ((x) * (x))
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

const int maxn = 100000 + 100;
// const int maxn = 25;
const int maxm = 150000 + 100;
// const int maxm = 30;
const int maxt = 100 + 5;
const int maxk = 1000 + 10;

typedef long long LL;
typedef long double LD;
typedef unsigned long long uLL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;

const LL unit = 1LL;
const int INF = 0x3f3f3f3f;
const LL Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-4;
const double inf = 1e15;
const double pi = acos(-1.0);
// const LL mod = 1000000007;
const LL mod = 2147483647;

struct Edge
{
    int from, to, next, w;
} edge[maxn << 1];

int n, k, root;
int tot, head[maxn];
int d[maxn], pre[maxn];
int dp[maxn], f[maxn];

void AddEdge(int u, int v, int w)
{
    edge[tot] = (Edge){u, v, head[u], w};
    head[u] = tot++;
}

void dfs(int u, int fa, int dep)
{
    d[u] = dep;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa)
            continue;
        pre[v] = i;
        dfs(v, u, dep + 1);
    }
}

void change(int v)
{
    if(v == root)
        return;
    int id = pre[v];
    edge[id].w = edge[id ^ 1].w = -1;
    change(edge[id].from);
}

void DP(int u, int fa)
{
    dp[u] = f[u] = 0;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa)
            continue;
        DP(v, u);
        f[u] = max(f[u], dp[u] + edge[i].w + dp[v]);
        dp[u] = max(dp[u], edge[i].w + dp[v]);
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n >> k;
    int u, v;
    tot = 0;
    memset(head, -1, sizeof(head));
    for (int i = 0; i < n - 1; i++)
    {
        cin >> u >> v;
        AddEdge(u, v, 1), AddEdge(v, u, 1);
    }
    dfs(1, -1, 0);
    root = max_element(d + 1, d + 1 + n) - d;
    dfs(root, -1, 0);
    int far = max_element(d + 1, d + 1 + n) - d;
    int l1 = d[far];
    if(k == 1)
    {
        cout << 2 * (n - 1) - (l1 - 1) << "\n";
        return 0;
    }
    change(far);
    DP(1, -1);
    int l2 = *max_element(f + 1, f + 1 + n);
    cout << 2 * n - l1 - l2 << "\n";
    return 0;
}