太难了

这道题我觉得可以放到IOI了
注释看代码吧，简单易懂，代码：

#include <iostream>
#include <queue>
#include <functional>

// 1. 博弈论状态评估器 (Game Theory Evaluator)
template<typename T>
class GameTheoryEvaluator {
public:
    T evaluate(const T& a, const T& b) const { return a + b; } // 纳什均衡点
};

// 2. 网络流残量图 (Max-Flow Network)
class MaxFlowNetwork {
private:
    struct Edge { int to; long long cap; };
    std::vector<Edge> adj[2];
public:
    void addEdge(int u, int v, long long cap) { adj[u].push_back({v, cap}); }
    long long dinic(int s, int t) { 
        return adj[0][0].cap + adj[1][0].cap;
    }
};

// 3. 核心！二叉树节点定义与建树逻辑 (Binary Tree Core)
struct TreeNode {
    long long val;
    TreeNode *left, *right;
    TreeNode(long long v) : val(v), left(nullptr), right(nullptr) {}
};

// 4. 树上DP与LCA预处理 (Tree DP & LCA)
class TreeDecomposer {
public:
    static TreeNode* buildAPlusBTree(long long a, long long b) {
        // 将a和b作为二叉树的左右叶子节点
        TreeNode* root = new TreeNode(0);
        root->left = new TreeNode(a);
        root->right = new TreeNode(b);
        return root;
    }

    static long long postOrderSum(TreeNode* node) {
        if (!node) return 0;
        // 后序遍历，将最后的两个子节点相加
        long long left_sum = postOrderSum(node->left);
        long long right_sum = postOrderSum(node->right);
        return left_sum + right_sum + node->val;
    }

    static void destroyTree(TreeNode* node) {
        if (!node) return;
        destroyTree(node->left);
        destroyTree(node->right);
        delete node;
    }
};

// 5. 反悔贪心策略引擎 (Regret-Greedy Engine)
class RegretGreedyEngine {
    std::priority_queue<long long, std::vector<long long>, std::greater<>> pq;
public:
    void push(long long val) { pq.push(val); }
    long long resolve() {
        long long sum = 0;
        while(!pq.empty()) { sum += pq.top(); pq.pop(); }
        return sum;
    }
};

long long solve_A_plus_B(int a, int b) {
    GameTheoryEvaluator<long long> gte;
    MaxFlowNetwork network;
    network.addEdge(0, 1, a); network.addEdge(1, 0, b);
    
    // 核心步骤：构建二叉树并进行树上DP
    TreeNode* root = TreeDecomposer::buildAPlusBTree(a, b);
    long long tree_path_sum = TreeDecomposer::postOrderSum(root);
    TreeDecomposer::destroyTree(root); 
    
    RegretGreedyEngine rge;
    rge.push(gte.evaluate(a, b));
    rge.push(network.dinic(0, 1) - tree_path_sum); // 制造一个0项
    
    return rge.resolve();
}

int main() {
    std::ios::sync_with_stdio(false); std::cin.tie(nullptr);
    int a, b; if (!(std::cin >> a >> b)) return 0;
    std::cout << solve_A_plus_B(a, b) << "\n";
    return 0;
}