minZ=a+b+c+d+e+f+g f+g+a>=15 g+a+b>=18 a+b+c>=25 b+c+d>=19 c+d+e>=31 d+e+f>=45 e+f+g>=47 用单纯形法解整数规划问题，不用任何库的C语言代码

好的，下面是单纯形法解整数规划问题的C语言代码：

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

#define M 6   // 约束条件的个数
#define N 7   // 变量的个数

int A[M][N] = {{1, 0, 1, 0, 0, 1, 1},
               {0, 0, 1, 1, 0, 1, 0},
               {1, 1, 1, 0, 0, 0, 0},
               {0, 1, 0, 1, 1, 0, 0},
               {0, 0, 1, 0, 1, 1, 0},
               {0, 0, 0, 1, 1, 1, 1}};  // 系数矩阵A

int b[M] = {15, 18, 25, 19, 31, 45};  // 约束条件的右端向量b

int c[N] = {1, 1, 1, 1, 1, 1, 1};  // 目标函数的系数向量c

int x[N];  // 最终解

int simplex();  // 单纯形法求解函数

int main()
{
    int i, j;

    int result = simplex();  // 调用单纯形法求解函数

    if (result == -1)
    {
        printf("无可行解！\n");
    }
    else if (result == -2)
    {
        printf("无界解！\n");
    }
    else
    {
        printf("最优解为：%d\n", x[N-1]);  // 最优解为目标函数的最大值
        printf("取得最优解时，各变量的取值为：\n");

        for (i = 0; i < N-1; i++)
        {
            printf("x[%d] = %d\n", i+1, x[i]);
        }
    }

    return 0;
}

// 单纯形法求解函数
int simplex()
{
    int i, j, k, l;

    int max_index, min_index;  // 最大值和最小值的下标

    int max_value, min_value;  // 最大值和最小值

    int row, col;  // 离基变量所在的行和列

    int pivot;  // 主元

    int flag = 0;  // 判断是否结束迭代的标志

    // 初始化基变量
    for (i = 0; i < M; i++)
    {
        x[N-M+i] = b[i];
    }

    // 主循环
    while (1)
    {
        // 选择入基变量
        max_index = -1;
        max_value = 0;

        for (j = 0; j < N-1; j++)
        {
            if (c[j] > max_value)
            {
                max_value = c[j];
                max_index = j;
            }
        }

        if (max_index == -1)  // 如果目标函数的系数都小于等于0，则已达到最优解
        {
            return 0;
        }

        // 选择出基变量
        min_index = -1;
        min_value = 0x7fffffff;

        for (i = 0; i < M; i++)
        {
            if (A[i][max_index] > 0 && x[N-M+i] / A[i][max_index] < min_value)
            {
                min_value = x[N-M+i] / A[i][max_index];
                min_index = i;
            }
        }

        if (min_index == -1)  // 如果无可行解，则返回-1
        {
            return -1;
        }

        // 更新基变量
        x[N-M+min_index] = x[N-M+min_index] / A[min_index][max_index];
        pivot = A[min_index][max_index];
        A[min_index][max_index] = 1;

        for (j = 0; j < N; j++)
        {
            if (j != max_index)
            {
                A[min_index][j] /= pivot;
            }
        }

        b[min_index] /= pivot;

        // 更新非基变量
        for (i = 0; i < M; i++)
        {
            if (i != min_index)
            {
                pivot = A[i][max_index];
                A[i][max_index] = 0;

                for (j = 0; j < N; j++)
                {
                    if (j != max_index)
                    {
                        A[i][j] -= A[min_index][j] * pivot;
                    }
                }

                b[i] -= x[N-M+min_index] * pivot;
            }
        }

        c[max_index] = 0;

        // 判断是否结束迭代
        flag = 1;

        for (j = 0; j < N-1; j++)
        {
            if (c[j] > 0)
            {
                flag = 0;
                break;
            }
        }

        if (flag == 1)  // 如果目标函数的系数都小于等于0，则已达到最优解
        {
            return 0;
        }
    }

    return -2;  // 如果无界解，则返回-2
}

其中，系数矩阵A、约束条件的右端向量b和目标函数的系数向量c是根据题目给出的数据进行初始化的。在主函数中，调用了单纯形法求解函数simplex()，并根据函数的返回值输出相应的结果。在求解函数simplex()中，首先初始化基变量，然后进入主循环，不断选择入基变量、出基变量，更新基变量和非基变量，直到达到最优解或者无可行解/无界解为止。