0-1背包问题（FIFO）

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

typedef struct {
    int level;  // 当前层次
    int weight; // 当前重量
    int value;  // 当前价值
    int include[100]; // 是否包含某物品
} Node;

typedef struct QueueNode {
    Node data;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
} Queue;

void enqueue(Queue* q, Node data) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = data;
    newNode->next = NULL;
    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

Node dequeue(Queue* q) {
    if (q->front == NULL) {
        Node emptyNode = {0, 0, 0, {0}};
        return emptyNode;
    }
    QueueNode* temp = q->front;
    Node data = temp->data;
    q->front = q->front->next;
    if (q->front == NULL) {
        q->rear = NULL;
    }
    free(temp);
    return data;
}

int isEmpty(Queue* q) {
    return q->front == NULL;
}

int main() {
    int n, C;
    scanf("%d", &n);
    scanf("%d", &C);

    int weights[100], values[100];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &weights[i], &values[i]);
    }

    Queue q = {NULL, NULL};
    Node u, v;
    v.level = -1;
    v.weight = 0;
    v.value = 0;
    for (int i = 0; i < n; i++) {
        v.include[i] = 0;
    }
    enqueue(&q, v);

    int maxValue = 0;
    int bestInclude[100] = {0};

    while (!isEmpty(&q)) {
        v = dequeue(&q);

        if (v.level == n - 1) continue;

        u.level = v.level + 1;
        u.weight = v.weight + weights[u.level];
        u.value = v.value + values[u.level];
        for (int i = 0; i <= u.level; i++) {
            u.include[i] = v.include[i];
        }
        u.include[u.level] = 1;

        if (u.weight <= C && u.value > maxValue) {
            maxValue = u.value;
            for (int i = 0; i < n; i++) {
                bestInclude[i] = u.include[i];
            }
        }

        if (u.weight <= C) {
            enqueue(&q, u);
        }

        u.weight = v.weight;
        u.value = v.value;
        for (int i = 0; i <= u.level; i++) {
            u.include[i] = v.include[i];
        }
        u.include[u.level] = 0;

        enqueue(&q, u);
    }

    printf("%d\n", maxValue);
    printf("(");
    for (int i = 0; i < n; i++) {
        printf("%d", bestInclude[i]);
        if (i < n - 1) {
            printf(",");
        }
    }
    printf(")\n");

    return 0;
}

1. 定义节点和队列结构：

   • Node 结构体包含当前层次、当前重量、当前价值和包含物品的布尔数组。
   • QueueNode 结构体用于构建队列链表。
   • Queue 结构体包含队列的前后指针。

2. 队列操作：

   • enqueue 函数将节点加入队列。
   • dequeue 函数从队列中取出节点。
   • isEmpty 函数检查队列是否为空。

3. 主函数：

   • 输入物品数量 n 和背包容量 C。
   • 输入每个物品的重量和价值。
   • 初始化队列和根节点。
   • 使用FIFO队列进行分支限界搜索：
     • 从队列中取出节点。
     • 生成左子节点（包含当前物品）并检查其重量和价值是否满足条件。
     • 如果左子节点满足条件且其价值大于当前最大价值，则更新最大价值和最佳包含状态。
     • 将左子节点加入队列。
     • 生成右子节点（不包含当前物品）并加入队列。
   • 输出最大价值和最佳包含状态。