用C语言分支限界法求解装载问题。

装载问题是一个经典的NP完全问题，分支限界法是求解该问题的一种有效方法。以下是用C语言实现分支限界法求解装载问题的主要步骤：

1. 定义数据结构：定义节点结构体，包含当前节点的状态、已经装载的重量、剩余物品的重量、剩余容量、以及当前节点的价值。

2. 初始化根节点：将根节点的状态设置为0，表示没有物品被装载，已经装载的重量为0，剩余物品的重量为总重量，剩余容量为总容量，当前节点的价值为0。

3. 定义优先队列：用于存储所有待扩展的节点，按照价值从大到小排序。

4. 扩展节点：从优先队列中取出价值最大的节点进行扩展。对于每个节点，根据当前状态和剩余物品，计算出可能的下一个状态，并计算该状态的价值。如果该状态是一个可行解，则更新最优解。将所有扩展出的节点加入优先队列中。

5. 处理完所有节点后，输出最优解。

以下是用C语言实现分支限界法求解装载问题的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 20

// 定义节点结构体
struct Node {
    int status; // 当前节点的状态
    int loaded_weight; // 已经装载的重量
    int remain_weight; // 剩余物品的重量
    int remain_capacity; // 剩余容量
    int value; // 当前节点的价值
};

int n; // 物品数量
int total_weight; // 总重量
int total_capacity; // 总容量
int weight[MAX_N]; // 物品重量
int capacity[MAX_N]; // 物品容量
int value[MAX_N]; // 物品价值
int best_value; // 最优解

// 定义优先队列的比较函数，按照价值从大到小排序
int cmp(const void *a, const void *b) {
    const struct Node *pa = a;
    const struct Node *pb = b;
    return pb->value - pa->value;
}

int main() {
    // 输入数据
    scanf("%d %d %d", &n, &total_weight, &total_capacity);
    for (int i = 0; i < n; i++) {
        scanf("%d %d %d", &weight[i], &capacity[i], &value[i]);
    }

    // 初始化根节点
    Node root;
    root.status = 0;
    root.loaded_weight = 0;
    root.remain_weight = total_weight;
    root.remain_capacity = total_capacity;
    root.value = 0;

    // 定义优先队列
    Node q[1 << n];
    int head = 0, tail = 0;
    q[tail++] = root;

    // 扩展节点
    while (head < tail) {
        Node cur = q[head++];
        for (int i = 0; i < n; i++) {
            if (cur.status & (1 << i)) continue; // 当前物品已经装载过
            int new_status = cur.status | (1 << i);
            int new_loaded_weight = cur.loaded_weight + weight[i];
            int new_remain_weight = cur.remain_weight - weight[i];
            int new_remain_capacity = cur.remain_capacity - capacity[i];
            if (new_remain_capacity < 0) continue; // 超出容量
            int new_value = cur.value + value[i];
            if (new_value > best_value) best_value = new_value; // 更新最优解
            Node new_node;
            new_node.status = new_status;
            new_node.loaded_weight = new_loaded_weight;
            new_node.remain_weight = new_remain_weight;
            new_node.remain_capacity = new_remain_capacity;
            new_node.value = new_value;
            q[tail++] = new_node;
        }
        // 按照价值从大到小排序
        qsort(q + head, tail - head, sizeof(Node), cmp);
    }

    // 输出最优解
    printf("%d\n", best_value);

    return 0;
}

注意，这里使用了一个数组作为优先队列，每次扩展节点时都需要对队列进行排序。这样的时间复杂度是O(2^n * n * log2(2^n * n))，其中2^n是状态数，n是物品数量，时间复杂度较高。可以使用堆优化优先队列来降低时间复杂度。