🎯 Branch-and-Bound và tìm kiếm tăng dần

struct Node {
    int level;
    int weight;
    int value;
    double bound;

    bool operator<(const Node& other) const {
        return bound < other.bound;
    }
};

priority_queue pq;
pq.push(root);

while (!pq.empty()) {
    Node current = pq.top();
    pq.pop();

    if (current.bound <= bestValue) {
        continue;
    }

    // Sinh node chọn và không chọn.
}

enum Result {
    FOUND,
    NOT_FOUND,
    CUTOFF
};

Result depthLimitedSearch(
    int node,
    int target,
    int remainingDepth
) {
    if (node == target) return FOUND;
    if (remainingDepth == 0) return CUTOFF;

    bool hadCutoff = false;

    for (int child : children[node]) {
        Result result = depthLimitedSearch(
            child,
            target,
            remainingDepth - 1
        );

        if (result == FOUND) return FOUND;
        if (result == CUTOFF) hadCutoff = true;
    }

    return hadCutoff ? CUTOFF : NOT_FOUND;
}

bool iddfs(int start, int target) {
    for (int limit = 0; ; limit++) {
        Result result = depthLimitedSearch(
            start,
            target,
            limit
        );

        if (result == FOUND) return true;
        if (result == NOT_FOUND) return false;
    }
}

const int FOUND = -1;
const int INF = 1e9;

int dfs(State state, int g, int threshold) {
    int f = g + heuristic(state);

    if (f > threshold) return f;
    if (isGoal(state)) return FOUND;

    int nextThreshold = INF;

    for (State next : neighbors(state)) {
        if (onCurrentPath(next)) continue;

        mark(next);

        int result = dfs(
            next,
            g + moveCost(state, next),
            threshold
        );

        unmark(next);

        if (result == FOUND) return FOUND;
        nextThreshold = min(nextThreshold, result);
    }

    return nextThreshold;
}

bool idaStar(State start) {
    int threshold = heuristic(start);

    while (true) {
        int result = dfs(start, 0, threshold);

        if (result == FOUND) return true;
        if (result == INF) return false;

        threshold = result;
    }
}