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

const int MAXN = 500005;
int height[MAXN];
long long dp[MAXN];

int n;
long long A, B, res;

void dfs1(vector<vector<int>> &tree, int cur, int par) {
    int max_height = -1;
    for (int nei : tree[cur]) {
        if (nei != par) {
            dfs1(tree, nei, cur);
            if (max_height == -1 || height[nei] > height[max_height]) {
                max_height = nei;
            }
        }
    }
    height[cur] = (max_height == -1 ? 0 : height[max_height] + 1);
    dp[cur] = 0;
    for (int nei : tree[cur]) {
        if (nei != par) {
            dp[cur] += dp[nei];
            if (nei != max_height) {
                dp[cur] += min(B, (height[nei] + 1) * A);
            }
        }
    }
}

void dfs2(vector<vector<int>> &tree, int par_height, int cur, int par) {
    int prev_cur = dp[cur];
    vector<pair<int, int>> by_height;
    if (par != -1) {
        by_height.emplace_back(par_height, par);
    }
    for (int nei : tree[cur]) {
        if (nei != par) {
            by_height.emplace_back(height[nei], nei);
        }
    }
    sort(by_height.begin(), by_height.end());
    dp[cur] = 0;
    for (int nei : tree[cur]) {
        if (nei != par) {
            dp[cur] += dp[nei];
            if (nei != by_height.back().second) {
                dp[cur] += min(B, (height[nei] + 1) * A);
            }
        }
    }
    if (par != -1) {
        dp[cur] += dp[par];
        if (par != by_height.back().second) {
            dp[cur] += min(B, (par_height + 1) * A);
        }
    }
    res = min(res, dp[cur]);

    for (int nei : tree[cur]) {
        if (nei != par) {
            dp[cur] -= dp[nei];
            if (nei == by_height.back().second) {
                int next_height = max(par_height + 1, 
                    (by_height.size() >= 2 ? by_height[by_height.size() - 2].first : 0) + 1);
                int add = 0;
                if (by_height.size() >= 2) {
                    int new_max = by_height[by_height.size() - 2].first;
                    add = min(B, (new_max + 1) * A);
                    dp[cur] -= add; 
                }
                dfs2(tree, next_height, nei, cur);
                dp[cur] += add;
            } else {
                int next_height = max(par_height + 1, by_height.back().first + 1);
                dp[cur] -= min(B, (height[nei] + 1) * A);
                dfs2(tree, next_height, nei, cur);
                dp[cur] += min(B, (height[nei] + 1) * A);
            }
            dp[cur] += dp[nei];
        }
    }
    dp[cur] = prev_cur;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    cin >> n >> A >> B;
    vector<vector<int>> tree(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    dfs1(tree, 0, -1);
    res = LONG_LONG_MAX;
    dfs2(tree, -1, 0, -1);
    cout << res << "\n";
}