CodeForces 618D Hamiltonian Spanning Tree

题意：要把所有的节点都访问一次，并且不能重复访问，有两种方式访问，一种是根据树上的路径

走和当前节点连接的下一个节点cost x, 或者可以不走树上边，直接跳到不与当前节点连接的节点，cost y

分析：

别被树吓着！

一定会走n-1条路，那么就是有一些走树上的边，有一些不走。

如果树上的路径cost更大(x >= y)，那么尽可能的不走树上的路径，那么根据尝试可以找到规律

如果有一个节点是所有节点的父节点，也就是说这个节点的度为n-1，那么只会走一个x其他都是y

如果没有这个节点，一定可以全部走y

另一种情况如果（x < y），那么也就是说要尽可能的多走树上的边，我们知道一个节点只能访问一次，也就是说

一个节点最多只能连两条边出去，然后dfs搜索，找到最多可以走多少条，每个节点的度数如果不被剪完就可以继续连，

剩下的只能走y。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <stack>
#include <set>
#include <map>
#include <math.h>
#define pb push_back
#define CLR(a) memset(a, 0, sizeof(a));
#define MEM(a, b) memset(a, b, sizeof(a));
#define fi first
#define se second

using namespace std;

typedef long long ll;

const int MAXN = 200007;
const int MAXV = 207;
const int MAXE = 207;
const int INF = 0x3f3f3f3f;
ll x, y, n;
struct Edge
{
    int to, next;
    Edge () {}
    Edge(int to, int next) : to(to), next(next) {}
}edge[MAXN << 1];
int num;
int head[MAXN];
void Add(int from, int to)
{
    edge[num] = Edge(to, head[from]);
    head[from] = num++;
}
int deg[MAXN];
ll ans = 0;
ll len = 0;
int cnt = 0;
bool dfs(int crt, int fa)
{
    int rem = 2;
    for (int t = head[crt]; t != -1; t = edge[t].next)
    {
        Edge e = edge[t];
        int v = e.to;
        if (v == fa) continue;
        if (dfs(v, crt) && rem > 0)
        {
            len++; rem--;
        }
    }
    return rem > 0;
}

int main()
{
    //freopen("in.txt", "r", stdin);
    while (~scanf("%lld%lld%lld", &n, &x, &y))
    {
        MEM(head, -1);
        MEM(edge, -1);
        CLR(deg);
        num = 0;
        len = 0;
        for (int i = 0; i < n-1; i++)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            Add(u, v);
            Add(v, u);
            deg[u]++;
            deg[v]++;
        }
        bool done = false;
        if (x >= y)
        {
            for (int i = 1; i <= n; i++)
            {
                if (deg[i] == n-1)
                {
                    ans = y*(n-2)+x;
                    printf("%lld
", ans);
                    done = true;
                    break;
                }
            }
            if (done) continue;
            ans = (n-1)*y;
            printf("%lld
", ans);
            continue;
        }
        dfs(1, 0); ans = len*x + (n-1-len)*y;
        printf("%lld
", ans);
    }
    return 0;
}