C语言编写代码，要求如下：已知n+1个正数：w i ​ (1<=i<=n)和M，要求找出{w i ​ }的所有子集使得子集中元素之和等于M。解采用可变长的k-元组(x 1 ​ ,...,x k ​ ) 表达，其中：x i ​ ∈{1, ..n}，表示被选中的数值w的下标，1<=i<=k。隐式约束条件是选中的数值和数为M，x i ​ 相互不同，且按取值从小到大顺序排列。 要求利用FIFO分支限界方法解决子集和数问题。 输入格式: 第一行为一个不超过200的正整数n，表示总集规模； 第二行是正整数M，表示子集的和数； 第三行是总集中n个正整数，中间用空格隔开。 输出格式: 如果有答案，则输出所有满足条件的子集（用可变长度数组表示符合条件的一个子集，子集中元素表示被选中的数值的下标）； 如果没有答案，则输出“no solution!”。

好的，下面是C语言的代码实现，使用了队列和动态数组：

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

#define MAXN 200

// 定义队列结构体
typedef struct {
    int* data;  // 数据
    int front;  // 队首指针
    int rear;   // 队尾指针
    int maxsize;// 队列最大容量
} Queue;

// 定义动态数组结构体
typedef struct {
    int* data;  // 数据
    int size;   // 数组长度
    int capacity;   // 数组容量
} Array;

// 创建队列
Queue* createQueue(int maxsize) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (int*)malloc(sizeof(int) * maxsize);
    q->front = 0;
    q->rear = 0;
    q->maxsize = maxsize;
    return q;
}

// 销毁队列
void destroyQueue(Queue* q) {
    free(q->data);
    free(q);
}

// 判断队列是否为空
int isEmpty(Queue* q) {
    return q->front == q->rear;
}

// 入队
void enqueue(Queue* q, int x) {
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % q->maxsize;
}

// 出队
int dequeue(Queue* q) {
    int x = q->data[q->front];
    q->front = (q->front + 1) % q->maxsize;
    return x;
}

// 创建动态数组
Array* createArray(int capacity) {
    Array* arr = (Array*)malloc(sizeof(Array));
    arr->data = (int*)malloc(sizeof(int) * capacity);
    arr->size = 0;
    arr->capacity = capacity;
    return arr;
}

// 销毁动态数组
void destroyArray(Array* arr) {
    free(arr->data);
    free(arr);
}

// 在动态数组末尾插入元素
void pushBack(Array* arr, int x) {
    if (arr->size == arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int*)realloc(arr->data, sizeof(int) * arr->capacity);
    }
    arr->data[arr->size++] = x;
}

// 输出动态数组中的元素
void printArray(Array* arr) {
    printf("{");
    for (int i = 0; i < arr->size; i++) {
        printf("%d", arr->data[i]);
        if (i != arr->size - 1) {
            printf(", ");
        }
    }
    printf("}\n");
}

// 判断动态数组中的元素之和是否等于M
int checkSum(Array* arr, int* w, int M) {
    int sum = 0;
    for (int i = 0; i < arr->size; i++) {
        sum += w[arr->data[i]];
    }
    return sum == M;
}

// 利用FIFO分支限界法求解子集和数问题
void subsetSum(int* w, int n, int M) {
    // 创建队列和动态数组
    Queue* q = createQueue(1000);
    Array* subset = createArray(10);
    // 将空集入队
    enqueue(q, 0);
    // BFS搜索
    while (!isEmpty(q)) {
        // 取出队首元素
        int i = dequeue(q);
        if (i == n) {
            // 判断动态数组中的元素之和是否等于M
            if (checkSum(subset, w, M)) {
                // 如果等于M，则输出该子集
                printArray(subset);
            }
        } else {
            // 不选第i个元素的子集
            enqueue(q, i + 1);
            // 选第i个元素的子集
            pushBack(subset, i);
            enqueue(q, i + 1);
            // 回溯
            subset->size--;
        }
    }
    // 如果subset为空，则输出“no solution!”
    if (subset->size == 0) {
        printf("no solution!\n");
    }
    // 销毁队列和动态数组
    destroyQueue(q);
    destroyArray(subset);
}

int main() {
    int n, M, w[MAXN + 1];
    // 读入数据
    scanf("%d%d", &n, &M);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &w[i]);
    }
    // 求解子集和数问题
    subsetSum(w, n, M);
    return 0;
}

注意：由于C语言中没有现成的队列和动态数组数据结构，我们需要手动实现它们。上面的代码实现了一个循环队列和一个动态数组，分别用于存储搜索队列和符合条件的子集。