使用C语言和分支限界法，解决世界名画陈列馆问题

好的，下面是使用C语言和分支限界法解决世界名画陈列馆问题的代码示例：

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

#define MAX_ROOMS 10    // 最多展厅数
#define MAX_PICTURES 20 // 最多画作数

// 展厅结构体
typedef struct {
    int id;             // 展厅编号
    int num_of_pics;    // 展厅内画作数量
    int* pics;          // 展厅内画作编号数组
} Room;

// 画作结构体
typedef struct {
    int id;             // 画作编号
    int room_id;        // 画作所在展厅编号
} Picture;

// 优先队列节点结构体
typedef struct {
    int cost;           // 到达该状态的代价
    int room_id;        // 当前展厅编号
    int* visited_rooms; // 已经访问过的展厅编号数组
    int num_of_visited; // 已经访问过的展厅数量
} Node;

// 全局变量
int num_of_rooms;       // 展厅数量
int num_of_pictures;    // 画作数量
Room rooms[MAX_ROOMS];  // 展厅数组
Picture pictures[MAX_PICTURES]; // 画作数组
int goal_room_id;       // 目标展厅编号

// 初始化展厅
void init_rooms() {
    int i;
    for (i = 0; i < MAX_ROOMS; i++) {
        rooms[i].id = -1;
        rooms[i].num_of_pics = 0;
        rooms[i].pics = NULL;
    }
}

// 初始化画作
void init_pictures() {
    int i;
    for (i = 0; i < MAX_PICTURES; i++) {
        pictures[i].id = -1;
        pictures[i].room_id = -1;
    }
}

// 读取输入数据
void read_data() {
    int i, j;
    scanf("%d", &num_of_rooms);
    for (i = 0; i < num_of_rooms; i++) {
        scanf("%d", &rooms[i].id);
        scanf("%d", &rooms[i].num_of_pics);
        rooms[i].pics = (int*)malloc(rooms[i].num_of_pics * sizeof(int));
        for (j = 0; j < rooms[i].num_of_pics; j++) {
            scanf("%d", &rooms[i].pics[j]);
            pictures[rooms[i].pics[j]].id = rooms[i].pics[j];
            pictures[rooms[i].pics[j]].room_id = rooms[i].id;
        }
    }
    scanf("%d", &num_of_pictures);
    scanf("%d", &goal_room_id);
}

// 判断一个展厅是否已经被访问过
int is_room_visited(int* visited_rooms, int room_id, int num_of_visited) {
    int i;
    for (i = 0; i < num_of_visited; i++) {
        if (visited_rooms[i] == room_id) {
            return 1;
        }
    }
    return 0;
}

// 计算当前状态的代价
int calc_cost(Node* node) {
    int i, cost = 0;
    for (i = 0; i < node->num_of_visited; i++) {
        cost += rooms[node->visited_rooms[i]].num_of_pics;
    }
    return cost;
}

// 判断一个状态是否为目标状态
int is_goal(Node* node) {
    return node->room_id == goal_room_id;
}

// 扩展一个节点
void expand_node(Node* node, Node** children, int* num_of_children) {
    int i, j, room_id = node->room_id;
    Room room = rooms[room_id];
    for (i = 0; i < room.num_of_pics; i++) {
        int pic_id = room.pics[i];
        if (is_room_visited(node->visited_rooms, pictures[pic_id].room_id, node->num_of_visited)) {
            continue;
        }
        Node* child = (Node*)malloc(sizeof(Node));
        child->cost = calc_cost(node) + rooms[pictures[pic_id].room_id].num_of_pics;
        child->room_id = pictures[pic_id].room_id;
        child->num_of_visited = node->num_of_visited + 1;
        child->visited_rooms = (int*)malloc(child->num_of_visited * sizeof(int));
        memcpy(child->visited_rooms, node->visited_rooms, node->num_of_visited * sizeof(int));
        child->visited_rooms[node->num_of_visited] = pictures[pic_id].room_id;
        children[*num_of_children] = child;
        (*num_of_children)++;
    }
}

// 比较两个节点的代价
int compare_cost(const void* a, const void* b) {
    Node* node_a = *(Node**)a;
    Node* node_b = *(Node**)b;
    return node_a->cost - node_b->cost;
}

// 释放一个节点占用的内存
void free_node(Node* node) {
    free(node->visited_rooms);
    free(node);
}

// 使用分支限界法搜索最优解
void search() {
    Node* root = (Node*)malloc(sizeof(Node));
    root->cost = 0;
    root->room_id = 0;
    root->num_of_visited = 1;
    root->visited_rooms = (int*)malloc(sizeof(int));
    root->visited_rooms[0] = 0;
    Node* queue[MAX_ROOMS * MAX_PICTURES];
    int head = 0, tail = 0;
    queue[tail++] = root;
    while (head < tail) {
        Node* node = queue[head++];
        if (is_goal(node)) {
            printf("%d\n", node->cost);
            return;
        }
        Node* children[MAX_ROOMS * MAX_PICTURES];
        int num_of_children = 0;
        expand_node(node, children, &num_of_children);
        qsort(children, num_of_children, sizeof(Node*), compare_cost);
        int i;
        for (i = 0; i < num_of_children; i++) {
            queue[tail++] = children[i];
        }
        free_node(node);
        for (i = 0; i < num_of_children; i++) {
            free(children[i]);
        }
    }
}

int main() {
    init_rooms();
    init_pictures();
    read_data();
    search();
    return 0;
}

在这个代码示例中，我们定义了展厅结构体和画作结构体，以及优先队列节点结构体。我们还定义了全局变量来存储输入数据和目标展厅编号。在 `read_data()` 函数中，我们读取输入数据并初始化展厅和画作数组。

在 `search()` 函数中，我们首先创建根节点，然后使用优先队列来存储节点，并不断选取代价最小的节点进行扩展，直到找到目标状态为止。在扩展节点时，我们通过检查已经访问过的展厅来避免重复状态，然后计算出当前状态的代价，并将扩展出的子节点按代价从小到大排序，加入优先队列中。

最后，我们在 `main()` 函数中调用 `init_rooms()`、`init_pictures()`、`read_data()` 和 `search()` 函数来执行程序。