AGC018D

题意

给出一个n个点的带边权的树，再给出一个n个点的完全图，其中每两个点之间的距离为这两个点在树上的距离，求最大的哈密顿图。

做法

直接考虑在树上的游历，如果存在一条边把树分成大小相同的两半，然后在两半中的点中交替走，这样子显然是最优的，因为每条边都会达到可能的最多的访问次数；否则必然存在一个点（重心），去除这个点之后的森林里每棵树的大小都不大于n/2，这样最优的游历一定是从每棵树出来走到另一棵中没走过的点，这样的安排总是存在的。考虑到最后并不会再访问重心，取重心连出去的权值最小的一条边来承担这个代价。

这种题就考虑到最优情况仔细分析就好了.

#include <bits/stdc++.h>
using namespace std;
namespace my_header {
#define pb push_back
#define mp make_pair
#define pir pair<int, int>
#define vec vector<int>
#define pc putchar
#define clr(t) memset(t, 0, sizeof t)
#define pse(t, v) memset(t, v, sizeof t)
#define bl puts("")
#define wn(x) wr(x), bl
#define ws(x) wr(x), pc(' ')
    const int INF = 0x3f3f3f3f;
    typedef long long LL;
    typedef double DB;
    inline char gchar() {
        char ret = getchar();
        for(; (ret == '
' || ret == '
' || ret == ' ') && ret != EOF; ret = getchar());
        return ret; }
    template<class T> inline void fr(T &ret, char c = ' ', int flg = 1) {
        for(c = getchar(); (c < '0' || '9' < c) && c != '-'; c = getchar());
        if (c == '-') { flg = -1; c = getchar(); }
        for(ret = 0; '0' <= c && c <= '9'; c = getchar())
            ret = ret * 10 + c - '0';
        ret = ret * flg; }
    inline int fr() { int t; fr(t); return t; }
    template<class T> inline void fr(T&a, T&b) { fr(a), fr(b); }
    template<class T> inline void fr(T&a, T&b, T&c) { fr(a), fr(b), fr(c); }
    template<class T> inline char wr(T a, int b = 10, bool p = 1) {
        return a < 0 ? pc('-'), wr(-a, b, 0) : (a == 0 ? (p ? pc('0') : p) : 
            (wr(a/b, b, 0), pc('0' + a % b)));
    }
    template<class T> inline void wt(T a) { wn(a); }
    template<class T> inline void wt(T a, T b) { ws(a), wn(b); }
    template<class T> inline void wt(T a, T b, T c) { ws(a), ws(b), wn(c); }
    template<class T> inline void wt(T a, T b, T c, T d) { ws(a), ws(b), ws(c), wn(d); }
    template<class T> inline T gcd(T a, T b) {
        return b == 0 ? a : gcd(b, a % b); }
    template<class T> inline T fpw(T b, T i, T _m, T r = 1) {
        for(; i; i >>= 1, b = b * b % _m)
            if(i & 1) r = r * b % _m;
        return r; }
};
using namespace my_header;

const int N = 1e5 + 100;
const int M = N<<1;

struct Edge {
    int e, h[N], t[M], n[M], w[M];
    void init() {
        e = 0; memset(h, -1, sizeof h);
    }
    void add(int u, int v, int c) {
        t[e] = v, n[e] = h[u], w[e] = c, h[u] = e++;
        t[e] = u, n[e] = h[v], w[e] = c, h[v] = e++;
    }
} e;

int n;
LL ans;

int siz[N], ef[N];
void dfs(int u, int f = -1) {
    siz[u] = 1;
    for (int i = e.h[u]; i != -1; i = e.n[i]) {
        int v = e.t[i];
        if (v == f) continue;
        ef[v] = i;
        dfs(v, u);
        siz[u] += siz[v];
    }
    ans += 1LL * e.w[ef[u]] * min(siz[u], n - siz[u]) * 2;
}


int main() {
#ifdef lol
    freopen("d.in", "r", stdin);
    freopen("d.out", "w", stdout);
#endif

    fr(n);
    e.init();
    for (int i = 1; i < n; ++i) {
        int u, v, w;
        fr(u, v, w);
        e.add(u, v, w);
    }
    dfs(1);
    //for (int i = 1; i <= n; ++i)
    //    ws(siz[i]);
    //puts("");
    for (int i = 2; i <= n; ++i) {
        if (siz[i] * 2 == n) {
            wt(ans - e.w[ef[i]]);
            return 0;
        }
    }
    int val = INT_MAX;
    
    //wt(ans);
    for (int i = 1; i <= n; ++i) {
        int maxSiz = n - siz[i], minEdge = i == 1 ? INT_MAX : e.w[ef[i]];
        for (int j = e.h[i]; j != -1; j = e.n[j]) {
            if (e.t[j] != e.t[ef[i] ^ 1]) {
                maxSiz = max(maxSiz, siz[e.t[j]]);
                minEdge = min(minEdge, e.w[j]);
            }
        }
        //wt(maxSiz);
        if (maxSiz * 2 <= n) {
            val = min(val, minEdge);
        }
    }
    wt(ans - val);

    return 0;
}