使用C语言实现单纯形法求解线性规划问题

#include<stdio.h>#define M 5#define N 7float Max(float a[],int n);int k,l;void main(){ float a[M][N];//{{0,2,3,0,0,0,0},{12,2,2,1,0,0,0},{8,1,2,0,1,0,0},{16,4,0,0,0,1, 0},{12,0,4,0,0,0,1}};//初始化单纯形表float cb[M],X[N],z[N],cj[N];//z[M]为检验数准备,jj[M],cj[N]是检验数int jj[M],i,j;int s,p,t=0;float maxcj,Z=0.0;printf("请输入一个%d行%d列的初始单纯形表用于求解%d个约束条件%d个变量的线性规划的原问题！",M,N,M-1,N-1);printf("\n"); printf("请输入初始单纯形表的第1行元素即变量的价值系数（第一个元素应默认为0.0）！");printf("\n");for(j=0;j<N;j++)scanf("%f",&a[0][j]);for(i=1;i<M;i++){printf("请输入初始单纯形表的第%d行元素即限定条件与系数矩阵！",i+1);printf("\n");for(j=0;j<N;j++)scanf("%f",&a[i][j]);}//初始化单纯形表*/for(i=1;i<N;i++) //最优解矩阵的初始化X[i]=0.0;for(j=1;j<N;j++){ s=0;p=0;for(i=1;i<M;i++){if(a[i][j]==1){s++;p=i;}}if(s==1)jj[p]=j;} //确定初始基变量，并标识基变量位置//jj[1]=3;jj[2]=4;jj[3]=5;jj[4]=6;//确定初始基变量，并标识基变量位置for(i=1;i<M;i++) cb[i]=a[0][jj[i]]; //基变量的价值系数for(j=0;j<N;j++)X[j]=0.0;for(i=1;i<M;i++)X[jj[i]]=a[i][0];for(j=1;j<N;j++){ z[j]=0.0;for(i=1;i<M;i++)z[j]+=cb[i]*a[i][j]; }//为寻找出基变量的检验数做准备for(j=1;j<N;j++){ cj[j]=0.0;cj[j]=a[0][j]-z[j];}// 检验数maxcj=Max(cj,N);printf("*********************************\n"); printf("输入的单纯形表如下：\n");for(i=0;i<M;i++){ for(j=0;j<N;j++)printf("%6.2f",a[i][j]);printf("\n");} //输出初始化单纯形表//for(i=1;i<M;i++)//printf("%6.2f",cb[i]);printf("\n");//输出基变量的价值系数//for(i=1;i<N;i++)//printf("%6.2f",X[i]);printf("\n");//输出一个基本可行解矩阵//for(j=1;j<N;j++)//printf("%6.2f",cj[j]);printf("\n");// 输出检验数printf("*********************************\n");while(maxcj>0){float R,alk;R=1000.0;for(i=1;i<M;i++)if(a[i][k]>0){ if(R>a[i][0]/a[i][k]){ R=a[i][0]/a[i][k];l=i;}else if(R==a[i][0]/a[i][k])if(jj[l]<jj[i])l=i;else;}if(R==1000.0){ printf("此问题无解!");t=1;break;}jj[l]=k;alk=a[l][k];for(j=0;j<N;j++)a[l][j]=a[l][j]/alk;for(i=1;i<M;i++)if(i!=l)for(j=0;j<N;j++)if(j!=k)a[i][j]=a[i][j]-a[l][j]/a[l][k]*a[i][k]; for(i=1;i<M;i++)if(i!=l)a[i][k]=0.0;for(i=1;i<M;i++)cb[i]=a[0][jj[i]]; //基变量的价值系数for(j=0;j<N;j++)X[j]=0.0;for(i=1;i<M;i++)X[jj[i]]=a[i][0];for(j=1;j<N;j++){ z[j]=0.0;for(i=1;i<M;i++)z[j]+=cb[i]*a[i][j]; }//为寻找出基变量的检验数做准备for(j=1;j<N;j++){ cj[j]=0.0;cj[j]=a[0][j]-z[j];} // 检验数maxcj=Max(cj,N);}if(t!=1){for(j=0;j<N;j++)Z+=a[0][j]*X[j];for(i=0;i<M;i++){ for(j=0;j<N;j++)printf("%6.2f",a[i][j]);printf("\n");}//输出初始化单纯形表//for(i=1;i<M;i++)//printf("%6.2f",cb[i]);printf("\n");//输出基变量的价值系数printf("满足最优解时，X的取值如下：");printf("\n");for(i=1;i<N;i++)printf("X[%d]=%6.2f,",i,X[i]);printf("\n");//输出一个基本可行解矩阵//for(j=1;j<N;j++)//printf("%6.1f",z[j]);printf("\n");//for(j=1;j<N;j++)//printf("%6.2f",cj[j]);printf("\n");// 输出检验数printf("最优解为Z=%6.2f",Z);printf("\n");}}float Max(float a[],int n){int i,maxjj;float maxaj;maxaj=a[1];maxjj=1;for(i=2;i<n;i++)if(maxaj<a[i]){ maxaj=a[i]; maxjj=i;} k=maxjj;return (maxaj);}。

1 / 2使用单纯形法解线性规划问题要求：目标函数为：123min 3z x x x =--约束条件为：1231231312321142321,,0x x x x x x x x x x x -+≤⎧⎪-++≥⎪⎨-+=⎪⎪≥⎩ 用单纯形法列表求解，写出计算过程。

解：1） 将线性规划问题标准化如下：目标函数为：123max max()3f z x x x =-=-++s.t.： 123412356137123456721142321,,,,,,0x x x x x x x x x x x x x x x x x x x -++=⎧⎪-++-+=⎪⎨-++=⎪⎪≥⎩2） 找出初始基变量，为x 4、x 6、x 7，做出单纯形表如下：表一：最初的单纯形表3） 换入变量有两种取法，第一种取为x 2，相应的换出变量为x 6，进行第一次迭代。

迭代后新的单纯形表为：表二：第一种换入换出变量取法迭代后的单纯形表由于x1和x5对应的系数不是0就是负数，所以此时用单纯形法得不到最优解。

表一中也可以把换入变量取为x3，相应的换出变量为x7，进行一次迭代后的单纯形表为：表三：第二种换入换出变量取法迭代后的单纯形表4）表三中，取换入变量为x2，换出变量为x6，进行第二次迭代。

之后的单纯形表为：表四：第二次迭代后的单纯形表5）表四中，取换入变量为x7，换出变量为x3，进行第三次迭代。

之后的单纯形表为：表五：第三次迭代后的单纯形表可以看出，此时x1，x5对应的系数全部非零即负，故迭代结束，没有最优解。

结论：综上所述，本线性规划问题，使用单纯形法得不到最优解。

（注：文档可能无法思考全面，请浏览后下载，供参考。

可复制、编制，期待你的好评与关注）。

线性拟合C语言算法线性拟合是一种常见的统计方法，用于确定一组数据中的线性关系并据此预测未知数据点。

在C语言中，可以使用最小二乘法来进行线性拟合。

最小二乘法的基本原理是找到一条直线，使得该直线到所有数据点的距离之和最小。

以下是一个使用C语言实现线性拟合的算法示例：```c#include <stdio.h>#include <math.h>//定义数据点结构体typedef structdouble x;double y;} DataPoint;//计算线性回归的斜率和截距void linearRegression(DataPoint data[], int n, double* slope, double* intercept)double sumX = 0; // x的和double sumY = 0; // y的和double sumX2 = 0; // x的平方和double sumXY = 0; // x和y的乘积和//计算各项和for (int i = 0; i < n; i++)sumX += data[i].x;sumY += data[i].y;sumX2 += pow(data[i].x, 2);sumXY += data[i].x * data[i].y;}//计算斜率和截距*slope = (n * sumXY - sumX * sumY) / (n * sumX2 - pow(sumX, 2));*intercept = (sumY - (*slope) * sumX) / n;int maiDataPoint data[] = {{1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}}; // 样本数据int n = sizeof(data) / sizeof(data[0]); // 数据点个数double slope, intercept; // 斜率和截距linearRegression(data, n, &slope, &intercept);//打印结果printf("Linear regression equation: y = %.2fx + %.2f\n", slope, intercept);return 0;```在上述算法中，首先定义了一个数据点的结构体`DataPoint`，包含`x`和`y`两个属性，分别表示数据点的自变量和因变量。

单纯形法C++实现使⽤单纯型法来求解线性规划，输⼊单纯型法的松弛形式，是⼀个⼤矩阵，第⼀⾏为⽬标函数的系数，且最后⼀个数字为当前轴值下的 z 值。

下⾯每⼀⾏代表⼀个约束，数字代表系数每⾏最后⼀个数字代表 b 值。

算法和使⽤单纯性表求解线性规划相同。

对于线性规划问题：Max x1 + 14* x2 + 6*x3s . t . x1 + x2 + x3 <= 4 x1<= 2 x3 <= 3 3*x2 + x3 <= 6 x1,x2,x3 >= 0我们可以得到其松弛形式：Max x1 + 14*x2 + 6*x3s.t. x1 + x2 + x3 + x4 = 4 x1 + x5 = 2 x3 + x6 = 3 3*x2 + x3 + x7 = 6 x1 , x2 , x3 , x4 , x5 , x6 , x7 ≥ 0我们可以构造单纯性表，其中最后⼀⾏打星的列为轴值。

单纯性表x1x2x3x4x5x6x7bc1=1c2=14c3=6c4=0c5=0c6=0c7=0-z=011110004100010020010010303100016****在单纯性表中，我们发现⾮轴值的x上的系数⼤于零，因此可以通过增加这些个x的值，来使⽬标函数增加。

我们可以贪⼼的选择最⼤的c，再上⾯的例⼦中我们选择c2作为新的轴，加⼊轴集合中，那么谁该出轴呢？其实我们由于每个x都⼤于零，对于x2它的增加是有所限制的，如果x2过⼤，由于其他的限制条件，就会使得其他的x⼩于零，于是我们应该让x2⼀直增⼤，直到有⼀个其他的x刚好等于0为⽌，那么这个x就被换出轴。

我们可以发现，对于约束⽅程1，即第⼀⾏约束，x2最⼤可以为4（4/1），对于约束⽅程4，x2最⼤可以为3(6/3），因此x2最⼤只能为他们之间最⼩的那个，这样才能保证每个x都⼤于零。

因此使⽤第4⾏，来对各⾏进⾏⾼斯⾏变换，使得⼆列第四⾏中的每个x都变成零，也包括c2。

用c语言实现单纯形法的编程#include "stdio.h"#include "math.h"#include <iostream>int M,N;float c[100],a[100][100],b[100],CZ[100],Dn[100],th[100],x[100];int Fn[100];int K,L,ths;float zy;int shuru();void findmm();void chang();main(){float max_Z,sum=0,s=0;int i,j,r=0;if(!shuru()) { printf("ERROR!!!\n");return 0;}while(r<N){ r=0;for(j=0;j<N;j++){if(Dn[j]>0){findmm();if(ths==M) {goto loop;}else chang();}else r++;}}loop:if(ths==M){printf("\n此线性规划没有有限最优解!!!\n");printf("\n此线性规划最终迭代结果为：");printf("\n Cj ");for(j=0;j<N;j++)printf("%.3f ",c[j]);printf("\n");printf("Cb Xb b ");for(j=0;j<N;j++)printf(" x%d ",j+1);printf(" th ");for(i=0;i<M;i++){ printf("\n%.1f ",CZ[i]);printf("x%d ",Fn[i]+1);printf("%.3f ",b[i]);for(j=0;j<N;j++){ printf(" %.3f ",a[i][j]);}printf(" %.3f ",th[i]);printf("\n");}printf(" Dn ");for(j=0;j<N;j++)printf(" %.3f ",Dn[j]);printf("\n");printf("\n此时的解为:");sum=0;for(i=0;i<M;i++){ sum+=CZ[i]*b[i];printf("\nx%d=%.3f",Fn[i]+1,b[i]);}max_Z=sum;printf("\n此时目标函数的值为：Z= %.3f\n",max_Z);}else{printf("\n此线性规划最终迭代结果为：");printf("\n Cj ");for(j=0;j<N;j++)printf("%.3f ",c[j]);printf("\n");printf("Cb Xb b ");for(j=0;j<N;j++)printf(" x%d ",j+1);printf(" th ");for(i=0;i<M;i++){ printf("\n%.1f ",CZ[i]);printf("x%d ",Fn[i]+1);printf("%.3f ",b[i]);for(j=0;j<N;j++){ printf(" %.3f ",a[i][j]);}printf(" %.3f ",th[i]);printf("\n");}printf(" Dn ");for(j=0;j<N;j++)printf(" %.3f ",Dn[j]);printf("\n");printf("\n故,目标函数的基解为:");sum=0;for(i=0;i<M;i++){ sum+=CZ[i]*b[i];printf("\nx%d=%.3f",Fn[i]+1,b[i]);}max_Z=sum;printf("\n目标函数的值为：max_Z= %.3f\n",max_Z);}system("pause");return 1;}int shuru(){ int i,j;float sum=0;printf("请输入线性规划问题的约束条件个数M：");scanf("%d",&M);printf("请输入线性规划问题的决策变量个数N：");scanf("%d",&N);printf("请输入目标函数的系数：");for(i=0;i<N;i++)scanf("%f",&c[i]);printf("请输入线性规划问题的约束矩阵：\n");for(i=0;i<M;i++){ for(j=0;j<N;j++)scanf("%f",&a[i][j]);scanf("%f",&b[i]);}printf("请输入线性规划问题的初始基：\n");for(j=0;j<N;j++)scanf("%f",&x[j]);for(i=j=0;j<N;j++){if(x[j]!=0){ Fn[i]=j;CZ[i]=c[j];i++;}}for(j=0;j<N;j++){ sum=0;for(i=0;i<M;i++)sum+=CZ[i]*a[i][j];Dn[j]=c[j]-sum;}return 1;}void findmm(){ int i;int max,min;max=0;K=max;for(i=1;i<N;i++)if(Dn[i]>Dn[K]) max=i;K=max;for(i=0;i<M;i++){if(a[i][K]!=0) {th[i]=b[i]/a[i][K];min=i;} else th[i]=-1;}ths=0;for(i=0;i<M;i++)if(th[i]<0) ths=ths+1;for(i=0;i<M;i++)if((th[i]>0)&&(th[i]<th[min])) min=i;L=min;zy=a[L][K];Fn[L]=K;CZ[L]=c[K];}void chang(){ int i,j;float t;for(j=0;j<N;j++)a[L][j]=a[L][j]/zy;b[L]=b[L]/zy;for(i=0;i<M;i++){if(i==L) continue;t=a[i][K];b[i]=b[L]*(-t)+b[i];for(j=0;j<N;j++)a[i][j]=a[L][j]*(-t)+a[i][j];}t=Dn[K];for(j=0;j<N;j++)Dn[j]=(-t)*a[L][j]+Dn[j];K=0;for(i=1;i<N;i++)if(Dn[i]>Dn[K]) K=i;for(i=0;i<M;i++){if(a[i][K]!=0) {th[i]=b[i]/a[i][K];}else th[i]=-1;}}#include "stdio.h"#include "math.h"#include <iostream>int M,N;float c[100],a[100][100],b[100],CZ[100],Dn[100],th[100],x[100]; int Fn[100];int K,L,ths;float zy;int shuru();void findmm();void chang();main(){float max_Z,sum=0,s=0;int i,j,r=0;if(!shuru()) { printf("ERROR!!!\n");return 0;}while(r<N){ r=0;for(j=0;j<N;j++){if(Dn[j]>0){findmm();if(ths==M) {goto loop;} else chang();}else r++;}}loop:if(ths==M){printf("\n此线性规划没有有限最优解!!!\n");printf("\n此线性规划最终迭代结果为：");printf("\n Cj ");for(j=0;j<N;j++)printf("%.3f ",c[j]);printf("\n");printf("Cb Xb b ");for(j=0;j<N;j++)printf(" x%d ",j+1);printf(" th ");for(i=0;i<M;i++){ printf("\n%.1f ",CZ[i]);printf("x%d ",Fn[i]+1);printf("%.3f ",b[i]);for(j=0;j<N;j++){ printf(" %.3f ",a[i][j]);}printf(" %.3f ",th[i]);printf("\n");}printf(" Dn ");for(j=0;j<N;j++)printf(" %.3f ",Dn[j]);printf("\n");printf("\n此时的解为:");sum=0;for(i=0;i<M;i++){ sum+=CZ[i]*b[i];printf("\nx%d=%.3f",Fn[i]+1,b[i]);}max_Z=sum;printf("\n此时目标函数的值为：Z= %.3f\n",max_Z); }else{printf("\n此线性规划最终迭代结果为：");printf("\n Cj ");for(j=0;j<N;j++)printf("%.3f ",c[j]);printf("\n");printf("Cb Xb b ");for(j=0;j<N;j++)printf(" x%d ",j+1);printf(" th ");for(i=0;i<M;i++){ printf("\n%.1f ",CZ[i]);printf("x%d ",Fn[i]+1);printf("%.3f ",b[i]);for(j=0;j<N;j++){ printf(" %.3f ",a[i][j]);}printf(" %.3f ",th[i]);printf("\n");}printf(" Dn ");for(j=0;j<N;j++)printf(" %.3f ",Dn[j]);printf("\n");printf("\n故,目标函数的基解为:");sum=0;for(i=0;i<M;i++){ sum+=CZ[i]*b[i];printf("\nx%d=%.3f",Fn[i]+1,b[i]);}max_Z=sum;printf("\n目标函数的值为：max_Z= %.3f\n",max_Z);}system("pause");return 1;}int shuru(){ int i,j;float sum=0;printf("请输入线性规划问题的约束条件个数M："); scanf("%d",&M);printf("请输入线性规划问题的决策变量个数N："); scanf("%d",&N);printf("请输入目标函数的系数：");for(i=0;i<N;i++)scanf("%f",&c[i]);printf("请输入线性规划问题的约束矩阵：\n");for(i=0;i<M;i++){ for(j=0;j<N;j++)scanf("%f",&a[i][j]);scanf("%f",&b[i]);}printf("请输入线性规划问题的初始基：\n");for(j=0;j<N;j++)scanf("%f",&x[j]);for(i=j=0;j<N;j++){if(x[j]!=0){ Fn[i]=j;CZ[i]=c[j];i++;}}for(j=0;j<N;j++){ sum=0;for(i=0;i<M;i++)sum+=CZ[i]*a[i][j];Dn[j]=c[j]-sum;}return 1;}void findmm(){ int i;int max,min;max=0;K=max;for(i=1;i<N;i++)if(Dn[i]>Dn[K]) max=i;K=max;for(i=0;i<M;i++){if(a[i][K]!=0) {th[i]=b[i]/a[i][K];min=i;} else th[i]=-1;}ths=0;for(i=0;i<M;i++)if(th[i]<0) ths=ths+1;for(i=0;i<M;i++)if((th[i]>0)&&(th[i]<th[min])) min=i; L=min;zy=a[L][K];Fn[L]=K;CZ[L]=c[K];}void chang(){ int i,j;float t;for(j=0;j<N;j++)a[L][j]=a[L][j]/zy;b[L]=b[L]/zy;for(i=0;i<M;i++){if(i==L) continue;t=a[i][K];b[i]=b[L]*(-t)+b[i];for(j=0;j<N;j++)a[i][j]=a[L][j]*(-t)+a[i][j];}t=Dn[K];for(j=0;j<N;j++)Dn[j]=(-t)*a[L][j]+Dn[j];K=0;for(i=1;i<N;i++)if(Dn[i]>Dn[K]) K=i;for(i=0;i<M;i++){if(a[i][K]!=0) {th[i]=b[i]/a[i][K];} else th[i]=-1;}}/view/579bf98b79563c1ec5da71a4.html /view/560260a8647d27284a73510c.html /view/da495b9b76eeaeaad1f330f9.html//在Visual C++控制台程序中编译执行#include<iostream.h>#include<math.h>#define M 10000//全局变量float kernel[11][31];//核心矩阵表int m=0,n=0,t=0;//m:结构向量的个数//n:约束不等式个数//t:目标函数类型：－1代表求求最小值，1代表求最大值//输入接口函数void input(){//读入所求问题的基本条件cout<<"－－－－－－－－－－参数输入－－－－－－－－－－－"<<endl;cout<<"请按提示输入下列参数："<<endl<<endl;cout<<" 结构向量数m: "<<" m= ";cin>>m;cout<<endl<<" 约束不等式数n:"<<" n= ";cin>>n;int i,j;//初始化核心向量for (i=0;i<=n+1;i++)for (j=0;j<=m+n+n;j++)kernel [i][j]=0;//读入约束条件cout<<endl<<" 约束方程矩阵的系数及不等式方向（1代表<=,-1代表>=）:"<<endl<<endl<<" ";for (i=1;i<=m;i++)cout<<" x"<<i;cout<<" 不等式方向 "<<" 常数项"<<endl;for (i=1;i<=n;i++){cout<<" 不等式"<<i<<" ";for (j=1;j<=m+2;j++)cin>>kernel [i][j];}for (i=1;i<=n;i++){kernel [i][0]=kernel [i][m+2];kernel [i][m+2]=0;}//读入目标条件cout<<endl<<endl<<" 目标函数的系数及类型（求最小值:1；求最大值:-1）:"<<endl<<endl<<" ";for(i=1;i<=m;i++)cout<<"x"<<i<<" ";cout<<"类型"<<endl<<" ";cout<<" 目标函数: ";for (i=1;i<=m;i++)cin>>kernel [0][i];cin>>t;//矩阵调整if(t==-1)for(i=1;i<=m;i++)kernel [0][i]=(-1)*kernel [0][i];for(i=1;i<=n;i++){kernel [i][m+i]=kernel [i][m+1];if(i!=1)kernel [i][m+1]=0;}}//算法函数void comput(){int i,j,flag,temp1,temp2,h,k=0,temp3[10];float a,b[11],temp,temp4[11],temp5[11],f=0,aa,d,c; //初始化for(i=1;i<=n;i++)temp3[i]=0;for(i=0;i<11;i++){ temp4[i]=0;temp5[i]=0;}for(i=1;i<=n;i++){if(kernel [i][m+i]==-1){kernel [i][m+n+i]=1;kernel [0][m+n+i]=M;temp3[i]=m+n+i;}elsetemp3[i]=m+i;}for(i=1;i<=n;i++)temp4[i]=kernel [0][temp3[i]];//循环求解do{for(i=1;i<=m+n+n;i++){a=0;for(j=1;j<=n;j++)a+=kernel [j][i]*temp4[j];kernel [n+1][i]=kernel [0][i]-a; }for(i=1;i<=m+n+n;i++){if(kernel [n+1][i]>=0) flag=1; else{flag=-1;break;}}if(flag==1){ for(i=1;i<=n;i++){if(temp3[i]<=m+n) temp1=1; else{temp1=-1; break;}}//输出结果cout<<endl<<endl;cout<<"－－－－－－－－－－结果输出－－－－－－－－－－－"<<endl<<endl;if(temp1==1){cout<<" 此线性规划的最优解存在!"<<endl<<endl<<" 最优解为："<<endl<<endl<<" ";for(i=1;i<=n;i++)temp5[temp3[i]]=kernel [i][0];for(i=1;i<=m;i++)f+=t*kernel [0][i]*temp5[i];for(i=1;i<=m;i++){cout<<"x"<<i<<" = "<<temp5[i];if(i!=m)cout<<"， ";}cout<<" ;"<<endl<<endl<<" 最优目标函数值f= "<<f<<endl<<endl;return ;}else{cout<<" 此线性规划无解"<<endl<<endl; return ;}}if(flag==-1){temp=100000;for(i=1;i<=m+n+n;i++)if(kernel [n+1][i]<temp){temp=kernel [n+1][i];h=i;}for(i=1;i<=n;i++){if(kernel [i][h]<=0) temp2=1;else {temp2=-1;break;}}}if(temp2==1){cout<<"此线性规划无约束";return ;}if(temp2==-1){c=100000;for(i=1;i<=n;i++){if(kernel [i][h]!=0) b[i]=kernel [i][0]/kernel [i][h]; if(kernel [i][h]==0) b[i]=100000;if(b[i]<0) b[i]=100000;if(b[i]<c){c=b[i];k=i;}}temp3[k]=h;temp4[k]=kernel [0][h];d=kernel [k][h];for(i=0;i<=m+n+n;i++)kernel [k][i]=kernel [k][i]/d;for(i=1;i<=n;i++){ if(i==k)continue;aa=kernel [i][h];for(j=0;j<=m+n+n;j++)kernel [i][j]=kernel [i][j]-aa*kernel [k][j];}}}while(1);return ;}//主函数void main(){ cout<<"-------------------单纯形算法程序----------------------"<<endl<<endl; input();comput();}#include<stdio.h>#include<math.h>#define m 3 /*定义约束条件方程组的个数*/#define n 5 /*定义未知量的个数*/float M=1000000.0;float A[m][n]; /*用于记录方程组的数目和系数;*/float C[n]; /*用于存储目标函数中各个变量的系数*/ float b[m]; /*用于存储常约束条件中的常数*/float CB[m]; /*用于存储基变量的系数*/float seta[m]; /*存放出基与入基的变化情况*/float delta[n]; /*存储检验数矩阵*/float x[n];int num[m]; /*用于存放出基与进基变量的情况*/ float ZB=0; /*记录目标函数值*/void input();void print();int danchunxing1();int danchunxing2(int a);void danchunxing3(int a,int b);int danchunxing1(){int i,k=0;int flag=0;float min=0;for(i=0;i<n;i++)if(delta[i]>=0)flag=1;else {flag=0;break;}if(flag==1)return -1;for(i=0;i<n;i++){if(min>delta[i]){min=delta[i];k=i;}return k;}int danchunxing2(int a){int i,k,j;int flag=0;float min;k=a;for(i=0;i<m;i++)if(A[i][k]<=0)flag=1;else {flag=0;break;}if(flag==1){printf("\n该线性规划无最优解!\n"); return -1;} for(i=0;i<m;i++){if(A[i][k]>0)seta[i]=b[i]/A[i][k];else seta[i]=M;}min=M;for(i=0;i<m;i++){if(min>=seta[i]){min=seta[i];j=i;}}num[j]=k+1;CB[j]=C[k];return j;}void danchunxing3(int p,int q){int i,j,c,l;float temp1,temp2,temp3;c=p;/*行号*/l=q;/*列号*/ temp1=A[c][l];b[c]=b[c]/temp1;for(j=0;j<n;j++)A[c][j]=A[c][j]/temp1;for(i=0;i<m;i++){if(i!=c)if(A[i][l]!=0){temp2=A[i][l];b[i]=b[i]-b[c]*temp2;for(j=0;j<n;j++)A[i][j]=A[i][j]-A[c][j]*temp2;}}temp3=delta[l];for(i=0;i<n;i++)delta[i]=delta[i]-A[c][i]*temp3;}void print(){int i,j=0;printf("\n--------------------------------------------------------------------------\n"); for(i=0;i<m;i++){printf("%8.2f\tX(%d) %8.2f ",CB[i],num[i],b[i]);for(j=0;j<n;j++)printf("%8.2f ",A[i][j]);printf("\n");}printf("\n--------------------------------------------------------------------------\n"); printf("\t\t\t");for(i=0;i<n;i++)printf(" %8.2f",delta[i]);printf("\n--------------------------------------------------------------------------\n"); }void input(){int i,j; /*循环变量*/int k;printf("请输入方程组的系数矩阵A(%d行%d列):\n",m,n);for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&A[i][j]);printf("\n请输入初始基变量的数字代码num矩阵:\n");for(i=0;i<m;i++)scanf("%d",&num[i]);printf("\n请输入方程组右边的值矩阵b:\n");for(i=0;i<m;i++)scanf("%f",&b[i]);printf("\n请输入目标函数各个变量的系数所构成的系数阵C:\n");for(i=0;i<n;i++)scanf("%f",&C[i]);for(i=0;i<n;i++)delta[i]=C[i];for(i=0;i<m;i++){k=num[i]-1;CB[i]=C[k];}}void main(){int i,j=0;int p,q,temp;input();printf("\n--------------------------------------------------------------------------\n"); printf(" \tCB\tXB\tb\t");for(i=0;i<n;i++)printf(" X(%d)\t",i+1);for(i=0;i<n;i++)x[i]=0;printf("\n");while(1){q=danchunxing1();if(q==-1){print();printf("\n所得解已经是最优解!\n");printf("\n最优解为:\n");for(j=0;j<m;j++){temp=num[j]-1;x[temp]=b[j];}for(i=0;i<n;i++){printf("x%d=%.2f ",i+1,x[i]);ZB=ZB-x[i]*C[i];}printf("ZB=%.2f",ZB);break;}print();p=danchunxing2(q);printf("\np=%d,q=%d",p,q);if(q==-1) break;danchunxing3(p,q);}}。

管理运筹学,用单纯形法求解以下线性规划问题管理运筹学是处理决策问题的重要科学，不仅根据不同目标和条件制定策略，而且可以更有效地识别和解决问题。

有些决策问题往往是非线性复杂性，涉及多个因素和变量之间的复杂关系，因此，以线性规划模型的形式来处理这些问题被认为是最有效的方法之一。

但是，线性规划模型的求解可能会非常困难，尤其是规模较大的问题。

而单纯形法作为其中一种有效的求解方法，其有效性和灵活性，使其在管理运筹学的研究中具有重要的意义。

单纯形法是指将原始线性规划问题转换为单纯形问题，然后利用相应的单纯形算法求解该问题，以求解线性规划问题。

单纯形法最早由威廉伯恩斯特（William B.Von Neumann）提出，它是利用单纯形理论把原始线性规划问题转化为单纯形问题，然后求解单纯形问题，得到原始线性规划问题的最优解。

单纯形算法的基本步骤包括：首先，根据原始线性规划问题的约束条件，构造单纯形方程组；其次，可以以此单纯形方程组为基础，进行单纯形法的迭代；最后，根据迭代的结果来求解原始的线性规划问题。

单纯形法在管理运筹学中的应用非常广泛，它不仅可以用来求解比较复杂的线性规划问题，而且可以用来解决某些约束条件下的非线性规划问题，从而解决管理运筹学中的相关问题。

另外，单纯形法还可以在企业资源规划（ERP）等管理运筹学领域的应用中发挥重要作用。

在实际应用中，单纯形法有其优缺点。

优点主要有以下几点：首先，它是一种有效的求解线性规划问题的方法，可以用来解决比较复杂的问题；其次，求解步骤简单，可以在较短的时间里求得最优解；最后，它适用性强，也可以用来解决某些约束条件下的非线性规划问题。

然而，单纯形法也有一些缺点，比如具有结构性特征，可能不能求解一些复杂的问题；另外，在求解比较大的问题时，运算负荷较大，效率较低。

总之，单纯形法是一种求解线性规划问题的有效方法，在管理运筹学中，它具有重要的意义和应用价值，它可以有效地解决复杂的线性规划问题，也能够解决某些特定条件下的非线性规划问题。

单纯形法c语言单纯形法（Simplex Algorithm）是一种用于线性规划问题的常用算法。

它的目标是找到线性规划问题的最优解，即满足约束条件下的最大或最小目标函数值。

单纯形法的思想相对简单，但是在实现时需要注意一些细节。

单纯形法的基本原理是通过不断地在可行解空间中移动，逐步逼近最优解。

它通过迭代的方式，每次找到一个更优的可行解，直到找到最优解为止。

这个过程是通过转动问题的一个角点，使其向邻近的角点移动，直到达到最优解。

单纯形法的核心是构造单纯形表（Simplex Tableau）。

单纯形表是一个矩阵，由目标函数和约束条件组成。

表中的每一行代表一个约束条件，而列则代表决策变量。

单纯形表中的元素表示某个变量在约束条件下的系数。

单纯形法的步骤如下：1.将线性规划问题转化为标准形式。

标准形式要求目标函数为最小化形式，约束条件为等式形式，并且决策变量为非负数。

2.构造初始单纯形表。

将约束条件和目标函数转化为单纯形表的形式，并填写初始值。

3.检查单纯形表是否为最优解。

如果表中的目标函数系数均为负数，则可以确定该解为最优解，算法结束。

否则，找到目标函数系数中的最小值所在的列。

4.选择合适的基变量。

在所选列中，找到使约束条件保持满足的最优值所在的行，并将其称为主元行。

将主元行与所选列进行交换，使得目标函数系数中的最小值所在的位置变为主元。

5.进行主元行的消元操作。

通过将主元行除以主元元素，使主元元素变为1，并将其他行的元素都变为0，同时更新单纯形表的其他值。

6.重复第3步到第5步，直到找到最优解或者确定无界问题或者无可行解。

在实现单纯形法的过程中，需要注意以下几点：1.单纯形表的数据结构。

单纯形表可以使用矩阵或数组表示，同时需要记录变量的基变量和非基变量，以及目标函数的最优值。

2.主元行的选取。

可以使用不同的策略选择主元行，例如选取最小比值法或者随机选择法。

3.主元行的消元操作。

消元操作时，需要将主元行的其他元素变为0。

单纯形法求解线性规划的步骤1>初始化将给定的线性规划问题化成标准形式,并建立一个初始表格,它最右边的单元格都是非负的(否则无解),接下来的m列组成一个m*m的单元矩阵(目标行的单元格则不必满足这一条件),这m列确定了初始的基本可行解的基本变量,而表格中行用基本变量来表示2>最优化测试如果目标行的所有单元格都是非负的(除了最右列中代表目标函数值的那个单元格),就可以停止了,该表格代表了一个最优解,它的基本变量的值在最右列中,而剩下的非基本变量都为03>确定输入变量从目标行的前n个单元格中选择一个负的单元格(选择绝对值最大的那个)该单元格所在的列确定的输入变量及主元列4>确定分离变量对于主元列的每个正单元格,求出θ比率(如果主元格的单元格为负或为0,说明该问题是无解的,算法终止),找出θ比率最小的列,改行确定了分离变量和主元行5>建立下一张表格将主元行的所有单元格除以主元得到新的主元行,包括主元行在内的每一行,要减去改行主元列单元格和新主元行的成绩(除主元行为1外,这一步将主元列的所有单元格变成0).把主元列的变量名进行代换,得到新的单纯形表,返回第一步为求简单在本程序中,需要自己建立标准矩阵(比如加入松弛变量等工作需要用户自己完成),程序的输入有两种方式:1:指定行和列,由用户自行输入每一个元素SimpleMatrix(introw=0,int col=0);2:直接在主程序中初始化一个二维数组,然后利用构造函数SimpleMatrix(introw,int col,double **M) 来初始化和处理(本程序所用的实例用的是这种方法)程序中主要的函数以及说明~SimpleMatrix();销毁动态分配的数组.用于很难预先估计矩阵的行和列,所以在程序中才了动态的内存分配.需要重载析构函数bool Is_objectLine_All_Positive();其中row2为主元所在的行,col为主元所在的列,row1为要处理的行void PrintAnswer();数不合法"<<endl;}SimpleMatrix::SimpleMatrix(int row,int col){init(row,col);for(int i=0;i<rowLen;i++)cout<<"请输入矩阵中第"<<i+1<<"行的系数"<<endl; for(int j=0;j<colLen;j++)cin>>data[i][j];}？}SimpleMatrix::SimpleMatrix(int row,int col,double **M) {rowLen=row;colLen=col;init(row,col);for (int i=0;i<row;i++)for(int j=0;j<col;j++){data[i][j]=*((double*)M+col*i+j); ;}}SimpleMatrix::~SimpleMatrix(){if(colLen*rowLen != 0 ){for(int i=rowLen-1;i>=0;i--){if (data[i]!=NULL)delete[] data[i];}if (data!=NULL)delete[] data;}？}bool SimpleMatrix::Is_objectLine_All_Positive(){for(int i=0;i<colLen-1;i++)if(data[rowLen-1][i]<0)return false;return true;}bool SimpleMatrix::Is_MainCol_All_Negative(int col) {for(int i=0;i<rowLen;i++)if(data[i][col]>0)return false;return true;}bool SimpleMatrix::Is_column_all_Positive(int col){for(int i=0;i<rowLen-1;i++){return false;}return true;}int SimpleMatrix::InColumn(){int count=0;for(int i=0;i<colLen-1;i++){int temp=GetItem(rowLen-1,i);if(temp>=0){count++;}elsebreak;}double maxItem=fabs(GetItem(rowLen-1,count));int index_col;for(i=0;i<colLen-1;i++){double temp=GetItem(rowLen-1,i);if(temp<0){if(maxItem<=fabs(temp)){maxItem=fabs(temp);index_col=i;}}}return index_col;}int SimpleMatrix::DepartRow(int col){int index_row;int count=0;for(int i=0;i<rowLen;i++){if(data[i][col]<0)count++;elsebreak;}double minItem=data[count][colLen-1]/data[count][col]; index_row=count;double temp;for(i=0;i<rowLen-1;i++)temp=data[i][col];if(temp>0){temp=data[i][colLen-1]/temp;if(temp<minItem){minItem=temp;index_row=i;}}}return index_row;}void SimpleMatrix::MainItem_To_1(int row,int col){double temp=GetItem(row,col);pp#include <iostream>#include ""using namespace std;int main(){double M[4][7]={{5,3,1,1,0,0,9},{-5,6,15,0,1,0,15},{2,-1,1,0,0,-1,5},{-10,-15,-12,0,0,0,}}; SimpleMatrix Matrix(4,7,(double **)M);if(5))//判断是否存在最优解{bool p=();//判断主元列是否全部为正,确定是否已经取得最优解while(!p){int col=();//确定主元所在的行if(col))//确定线性规划的解是否为无解的{cout<<"线性规划问题是无界的,没有最优解"<<endl;exit(EXIT_FAILURE);}else{int mainRow=(col);//确定主元所在的行(mainRow,col);//将主元所在的行做变换,使主元变成1int i=0;while(i<()){if(i!=mainRow){(i,mainRow,col);//处理矩阵中其他的行,使主元列的元素为0i++;}elsei++;}}}for(int i=0;i<();i++)//输出变换以后的矩阵,判断是否正确处理{for (int j=0;j<();j++){cout<<(i,j)<<" ";}cout<<endl;}p=();}();}elsecout<<"线性规划无解"<<endl;return0;}。

目录一．摘要 (2)二．实验目的 (2)三．实验内容 (2)四．建立数学模型 (3)五．实验原理 (5)六．MALTAB程序代码及注释 (7)七．结果运行测试 (13)八．心得与感悟 (15)一．摘要：线性规划是运筹学中研究较早、发展较快、应用广泛、方法较成熟的一个重要分支,它是辅助人们进行科学管理的一种数学方法.研究线性约束条件下线性目标函数的极值问题的数学理论和方法,英文缩写LP。

自1946年G.B.Dantizig提出单纯形法以来，它一直是求解线性规划问题的最有效的数学方法之一。

单纯形法的理论根据是：线性规划问题的可行域是 n 维向量空间Rn中的多面凸集,其最优值如果存在必在该凸集的某顶点处达到。

顶点所对应的可行解称为基本可行解。

通过引入普通单纯形法，依次迭代并判断，逐步逼近，最后得到最优解。

若不是，则按照一定法则转换到另一改进的基本可行解，再鉴别；若仍不是，则再转换，按此重复进行。

因基本可行解的个数有限，故经有限次转换必能得出问题的最优解。

如果问题无最优解也可用此法判别。

关键字：线性规划，单纯形法，最优值，最优解二．实验目的：1.加强学生分析问题能力，锻炼数学建模能力。

2.了解并掌握MATLAB软件中的线性规划问题的编程、求解和分析。

3.利用所学的MALTAB语言，完成对单纯形法问题的编程设计。

三．实验内容：某商场决定，营业员每周连续工作5天后连续休息2天，轮流休息，据统计，商场每天需要营业员如下：星期一：300，二：300；三：350，四：400，五：480，六：600；日：500；（1）商场人力资源部应如何安排每天上班的人数才能使商场总的营业员最少（2）若商场可以雇佣临时工，上班时间同正式工，若正式工每天工资80，临时工每天100，问商场是否应雇佣临时工及雇佣多少名？四．建立数学模型：从实际问题中建立数学模型一般有以下三个步骤：1.根据影响所要达到目的的因素找到决策变量；2.由决策变量和所在达到目的之间的函数关系确定目标函数；3.由决策变量所受的限制条件确定决策变量所要满足的约束条件。

盐城师范学院运筹学期末论文题目: 用单纯形法解决线性规划问题**: **二级学院: 数学科学学院专业: 数学与应用数学班级: 111 班学号: ********成绩评定:前言线性规划问题是数学以及日常生活中最基本的问题之一，如何快速有效的解决线性规划问题是数学家也在努力研究的科目之一。

以前中学时我们解决线性规划问题一般采用的是图解法，即画出所给条件的可行域，找出目标函数的最优解。

这种方法的优点是直观性强，计算方便，但缺点是只适用于问题中有两个变量的情况。

下面我们介绍另外一种方法—单纯形法，来解决图解法不能解决的问题。

1 单纯形法1.1 单纯形法的基本思路利用求线性规划问题基本可行解的方法求解较大规模的问题是不可行的。

有选择地取基本可行解，即从可行域的一个极点出发，沿着可行域的边界移动到另一个相邻的极点，要求新极点的目标函数值不比原目标函数值差。

在线性规划的可行域中先找出一个可行解，检验它是否为最优解，如果是最优解，计算停止；如果不是最优解，那么可以判断线性规划无有限最优解，或者根据一定步骤得出使目标函数值接近最优值的另一个基本可行解。

由于基本可行解的个数有限，所以总可以通过有限次迭代，得到线性规划的最优基本可行解或判定线性规划无有限最优解。

1.2 单纯形法的基本步骤第1步求初始基可行解，列出初始单纯形表。

对非标准型的线性规划问题首先要化成标准形式。

由于总可以设法使约束方程的系数矩阵中包含一个单位矩阵（P1,P2，…，Pm），以此作为基求出问题的一个初始基可行解。

为检验一个基可行解是否最优，需要将其目标函数值与相邻基可行解的目标函数值进行比较。

为了书写规范和便于计算，对单纯形法的计算设计了一种专门表格，称为单纯形表（见表1—1）。

迭代计算中每找出一个新的基可行解时，就重画一张单纯形表。

含初始基可行解的单纯形表称初始单纯形表，含最优解的单纯形表称最终单纯形表。

第2步：最优性检验如表中所有检验数c j−z j≤0，且基变量中不含有人工变量时，表中的基可行解即为最优解，计算结束。

实验2 单纯形法求解线性规划一、实验目的1. 理解线性规划的概念和基本形式。

2. 熟悉单纯形法的步骤和实现过程。

3. 学会使用Matlab编程求解线性规划问题。

二、实验原理线性规划是一种优化问题，其目标是在一组约束条件下，使目标函数（通常是一个线性函数）最大或最小化。

线性规划具有以下一般形式：$$\begin{aligned}&\underset{x_{1},x_{2},\cdots,x_{n}}{\max }\quadc_{1}x_{1}+c_{2}x_{2}+\cdots+c_{n}x_{n}\\&\text{s.t.}\quad a_{11}x_{1}+a_{12}x_{2}+\cdots+a_{1n}x_{n}\leq b_{1}\\&\quad \quad \quad \,\,\,\quada_{21}x_{1}+a_{22}x_{2}+\cdots+a_{2n}x_{n}\leq b_{2}\\&\quad \quad \quad\quad \quad \quad \vdots \\&\quad \quad \quad \,\,\,\quada_{m1}x_{1}+a_{m2}x_{2}+\cdots+a_{mn}x_{n}\leq b_{m}\\&\quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad x_{1},x_{2},\cdots,x_{n}\geq 0\end{aligned}$$其中，$x_{1},x_{2},\cdots,x_{n}$表示决策变量；$c_{1},c_{2},\cdots,c_{n}$是目标函数的系数；$a_{i1},a_{i2},\cdots,a_{in}$（$i$=1,2,...,m）是限制条件的系数，$b_{1},b_{2},\cdots,b_{m}$是限制条件右侧的常数。

线性规划中的单纯形法求解问题线性规划是运筹学中的一个重要分支，它的应用范围非常广泛，包括经济、工程、网络、交通等领域。

在实际问题中，我们通常会需要求解一个线性规划问题，而单纯形法是解决线性规划问题的一种常用方法。

1. 线性规划线性规划是一类优化问题，通常在最小化或最大化某个线性函数的同时，满足一组线性约束条件。

一个线性规划问题可以表示为：$$\begin{array}{lll}\textrm{min/max} & c^Tx & \\ \textrm{s.t.} & Ax &\leq b \\ & x &\geq 0\end{array}$$其中，$c$ 是一个 $n$ 维列向量，$A$ 是一个 $m\times n$ 的矩阵，$b$ 是一个 $m$ 维列向量，$x$ 是一个 $n$ 维列向量，代表问题的决策变量。

我们称 $Ax\leq b$ 是问题的约束条件，称 $x\geq0$ 是问题的非负性条件。

线性规划问题的求解可以分为两种基本方法，分别为单纯形法和内点法。

其中，单纯形法是一种经典的方法，应用广泛，是大多数线性规划软件的基础算法之一。

2. 单纯形法基本思想单纯形法的基本思想是通过对问题中的决策变量进行调整，使得目标函数值不断减小（最小化问题）或增大（最大化问题），并且在满足约束条件的前提下，最终找到最优解。

单纯形法的具体步骤如下：步骤1：初始化。

我们从一组基本解开始，即 $m$ 个基本变量和 $n-m$ 个非基本变量构成的向量 $x$。

在最初的阶段，我们需要选择一组基变量，并计算出它们的取值。

这个基变量集合构成了问题的起始基。

步骤2：检查最优性。

首先，我们需要对当前解进行检验，判断它是否为最优解。

如果是最优解，则停止算法；否则，进行下一步。

步骤3：选择进入变量。

我们需要选择一个非基变量，使得将它加入到基变量集合后，目标函数值有最大的增长量。

如果这个增长量为负数，则问题无界。

实验一、用C语言解线性方程组一、实验名称：用C语言解线性方程组。

二、实验原理：用初等行变化的方法将线性方程组的增广矩阵化简成最简型；从最简型中可以看出线性方程组解的情况。

三、实验工具：计算机和Microsoft Visual C++ 6.0软件。

四、实验原程序代码如下：#include<stdio.h>#include<math.h>#include<stdlib.h>#define MAXR 20#define MAXC 40float M[MAXC];float M_B[MAXR][MAXC];void f1(int m,int n){int i,j,r=0,c=0;float x0;printf("\n以下过程是将矩阵化为行阶梯型\n");printf("\n输出初始增广矩阵!\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%8.2f",M_B[i][j]); /*原始增广矩阵*/printf("\n");}printf("按任一健继续...\n");getchar();while(c<n){for(i=r;i<m;i++)if(fabs(M_B[i][c])>=0.0001)break;if(i<m){if(i!=r)for(j=0;j<n;j++){x0=M_B[i][j];M_B[i][j]=M_B[r][j];M_B[r][j]=x0;}x0=M_B[r][c];for(j=0;j<n;j++)M_B[r][j]/=x0;{x0=M_B[i][c];for(j=0;j<n;j++)M_B[i][j]-=x0*M_B[r][j];}r++;for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%8.2f",M_B[i][j]);printf("\n");}printf("按任一健继续...\n");getchar();}c++;if(r==m)break;}printf("\n矩阵的行阶梯型如上!\n");printf("\n以下过程是将行阶梯型化为行最简型\n"); while(r){r--;for(j=0;j<n-1;j++)if(fabs(M_B[r][j])>=0.0001)break; c=j;for(i=0;i<r;i++){x0=M_B[i][c];for(j=0;j<n;j++)M_B[i][j]-=x0*M_B[r][j];}for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%8.2f",M_B[i][j]);printf("\n");}printf("按任一健继续...\n");getchar();}float M[MAXC]={0};int l1,l2;{ for(l2=0;l2<n;l2++)if(M_B[l1][l2]!=0){M[l2]=1;break;}}if(M[n-1]=1){printf("该方程无解!");return;}for(l1=0;l1<m;l1++){for(l2=0;l2<n;l2++){if(M_B[l1][l2]!=0){M[l2]=M_B[l1][n-1];}}} printf("输出线性方程组的解:");for(l2=0;l2<n-1;l2++)printf("x%d(l2+1)=\n",M[l2]);printf("行最简型即为所求!按任一健退出...\n");getchar();}void main (void){int p,q,m,n;printf("\n 请输入线性方程组的行数m和列数n:");scanf("%d %d",&m,&n);printf("\n现在输入系数矩阵A和向量b:");for(p=1;p<=m;p++){printf("\n请输入a%d1--a%d%d系数和向量b%d: \n",p,p,n,p);/*实现将每一行中的系数和向量一次性输入，数之间用空格格开，输完后回车确定*/for(q=1;q<=n+1;q++) /*将刚才输入的数存入数组*/scanf("%f",&M_B[p-1][q-1]);}f1(m,n+1);}五、实验心得对于第一个实验，虽然实验原理很明了，但是用计算机用C语言来实现还是一件十分困难的事情，实验能够进行的前提是必须理解实验的原理即初等行变换的精髓，理解实验原理以后就要明确实验的各个步骤如何去实现，想明白这些以后再尝试编写程序，当然其中会遇到很多困难，但是要有耐心有细心，就可以编写出自己的程序来完成这个实验。

C语言解线性方程的四种方法C语言解线性方程的四种方法发了好几天编了个解线性方程组的小程序，可第一次实战就大败而归。

经过半天的调试，仍找不出纠正的方法。

因为并不是算法的问题，而是因为自己对编译器处理浮点函数的方法不是很理解。

明明D=0的方阵解出来不等于0了，跟踪调试发现，计算过程程序对数据进行了舍去处理，导致最终结果不对。

不过如果没有浮点型的话，这个程序应该算不错了。

复制代码代码如下:#include#include#include#defineNUM100voidprint(void)/使用说明/{clrscr();printf("\n\n\n\n\n\t\t\t\tIntroduction\n");printf("\t--------------------------------------------------------------\n");printf("\tThisprogramwasdesignforcomputelinearequations. \n");printf("\tThewayofuseitisverysimple.\n");printf("\tFirst:Inputthenumberoftheequation;(Input0toexit)\ n");printf("\tSecond:Inputthecoefficientofeveryeqution;\n");printf("\tThird:Inputtheconstantofeveryeqution;\n");printf("\tLast:Chosethewayyouwantusetosolvetheequtions;\ n");printf("\tThat''sall,inputanykeytorunit...\n");printf("\t-------------------------By__TJX------------------------------\n");getch();}voidchose(void)/选择计算方法/{clrscr();fflush(stdin);printf("\n\n\n\n\n\t\tIntroduction\n");printf("\t\tChosetheway,please.\n");printf("\t\ta:Gausseliminant.\n");printf("\t\tb:Gauss_ydeliminant.\n");printf("\t\tc:Iterativeway.\n");printf("\t\td:Cramerway.\n");printf("\t\te:exit.\n");printf("\t\tBy__TJX\n");printf("\t\tPleasechoosenumber:\n");}voidinput(doublea1,doubleb1[],intnum)/数据输入/ {inti,j,t;doublep;charde1,de2;do{printf("Pleaseinputarraya[%d][%d]:\n",num,num);printf("Warn:Thefirstnumberofthearraymustn''tcontainzero!\ n");for(i=1;i<=num;i++){printf("Pleaseinputarraya[%d][]:\n",i);for(j=1;j<=num;j++){t=0;if(i==1&&j==1){do{if(t==0){scanf("%lf",&a1[i][j]);t++;}else{printf("Theinputisinvalid,pleaseinputagain:\n");scanf("% f",&a1[i][j]);}}while(a1[i][j]==0);}elsescanf("%lf",&a1[i][j]);}}printf("\nPleasecheckthevalueofarraya[%d][%d],pressYtoinp utagain.\n",num,num);do{de1=getch();}while(de1!=''y''&&de1!=''Y''&&de1!=''n''&&de1!=''N'');}while(de1==''y''||de1==''Y'');do{printf("Pleaseinputarrayb[%d]:\n",num);p=b1+1;for(i=1;i<=num;i++)scanf("%lf",p++);printf("\nPleasecheckthevalueofarrayb[%d],pressYtoinputag \n",num);do{de2=getch();}while(de2!=''y''&&de2!=''Y''&&de2!=''n''&&de2!=''N'');}while(de2==''y''||de2==''Y'');}intmax(doublet1,doublex1[],intn)/迭代子函数/{inti,temp=0;for(i=1;i<=n;i++)if(fabs(x1[i]-t1[i])>1e-2){temp=1;break;}/printf("%d",temp);/returntemp;}intddcompute(doublea1,doubleb1[],doublex1[],intn)/迭代法计算/{doublet;inti,j,k=0;doublesum1=0.0,sum2=0.0;t=(double)malloc(nsizeof(double));printf("\nPleaseInputTheInitialValueofx:\n");for(i=1;i<=n;i++)scanf("%lf",&x1[i]);do{k++;for(i=1;i<=n;i++)t[i]=x1[i];for(i=1;i<=n;i++){sum1=0.0;sum2=0.0;for(j=1;j<=i-1;j++)sum1=sum1+a1[i][j]x1[j];/printf("sum1=%0.4f",sum1);/for(j=i+1;j<=n;j++)sum2=sum2+a1[i][j]t[j];/printf("sum2= %0.4f",sum2);}/if(a1[i][i]==0||fabs(sum1)>1e+12||fabs(sum2)>1e+12){printf("\nWarning:Theseequtionscan''tbesolvebythisway!\n PressanyKeytocontinue...");getch();free(t);return0;}x1[i]=(b1[i]-sum1-sum2)/a1[i][i];}}while(max(t,x1,n));/for(i=1;i<=n;i++){if(i%3==0)printf("\n");printf("%.4f",x1[i]);}/free(t);return1;}intgscompute(doublea1,doubleb1[],doublex1[],intn)/高斯消元法计算/{inti,j,k;doublem,sum;for(k=1;k<=n-1;k++)for(i=k+1;i<=n;i++){if(a1[k][k]==0){printf("\nTheseequtionscan''tbesolveisthisw \nPressanyKeytocontinue...");getch();return0;}if((m=0-a1[i][k]/a1[k][k])==0){i++;continue;}else{for(j=k+1;j<=n;j++)a1[i][j]=a1[i][j]+a1[k][j]m;b1[i]=b1[i]+b1[k]m;}}/yixiajisuanxzhi/x1[n]=b1[n]/a1[n][n];for(i=n-1;i>=1;i--){sum=0.0;for(j=n;j>=i+1;j--)sum=sum+a1[i][j]x1[j];x1[i]=(b1[i]-sum)/a1[i][i];}return1;}intgs_ydcompute(doublea1,doubleb1[],doublex1[],intn)/高斯_约当法计算/{inti,j,k;doublem,sum;for(k=1;k<=n;k++){i=1;while(i<=n){if(a1[k][k]==0){printf("\nTheseequtionscan''tbesolveisthisw ay.\nPressanyKeytocontinue...");getch();return0;}if(i!=k){if((m=0-a1[i][k]/a1[k][k])==0){i++;continue;}else{for(j=k+1;j<=n;j++)a1[i][j]=a1[i][j]+a1[k][j]m;b1[i]=b1[i]+b1[k]m;}i++;}elsei++;}}/yixiajisuanxzhi/for(i=n;i>=1;i--)x1[i]=b1[i]/a1[i][i];return1;}doublecomputed(doublea,inth,intl,intc1,intn)/计算系数行列式D值/{inti,j,p=1;doublesum=0.0;if(h==n)sum=1.0;else{i=++h;c1[l]=0;for(j=1;j<=n;j++)if(c1[j])if(a[i][j]==0)p++;else{sum=sum+a[i][j]computed(a,i,j,c1,n)pow(-1,1+p);p++;}c1[l]=1;}returnsum;}voidncompute(doublea,doubleb[],doublex[],intn,intc,double h)/克莱姆法计算/{inti,j;doublet[NUM];for(j=1;j<=n;j++){for(i=1;i<=n;i++){t[i]=a[i][j];a[i][j]=b[i];}x[j]=computed(a,0,0,c,n)/h;for(i=1;i<=n;i++)a[i][j]=t[i];}}main(){doublex[NUM];doubleb[NUM];inti,j=2,n=0;intc;doublehe;charm,decision;doublea;a=(double)malloc(NUMsizeof(double));for(i=0;ia[i]=(double)malloc(NUMsizeof(double));print();do{clrscr();do{if(n>=NUM)printf("nistoolarge,pleaseinputagain:\n");elseprintf("Pleaseinputthetotalnumberoftheequationsn(n scanf("%d",&n);}while(n>NUM);if(n==0){for(i=1;ifree(a);exit(1);}input(a,b,n);c=(int)malloc((n+1)sizeof(int));memset(c,1,(n+1)sizeof(int));he=computed(a,0,0,c,n);if(fabs(he)>1e-4)Other:chose();do{m=getche();}while(m!=''a''&&m!=''b''&&m!=''A''&&m!=''B''&&m!=''c'' &&m!=''C''&&m!=''d''&&m!=''D''&&m!=''e''&&m!=''E'');switch(m){case''a'':;case''A'':j=gscompute(a,b,x,n);break;case''b'':;case''B'':j=gs_ydcompute(a,b,x,n);break;case''c'':;case''C'':j=ddcompute(a,b,x,n);break;case''d'':;case''D'':j=1;ncompute(a,b,x,n,c,he);break;case''e'':;case''E'':j=2;break;default:j=2;break;}if(j==1){clrscr();printf("\n\n\n\n");printf("D=%.4f\n",he);for(i=1;i<=n;i++){if(i%5==0)printf("\n");printf("%.4f",x[i]);}}elseif(j==0){printf("\nTheseequtionscan''tbesolveisthisway.\nPleasechos etheotherway.");gotoOther;}else{for(i=1;ifree(a);free(c);exit(1);}}elseprintf("\n\n\tD=%.4f\nThislinearequationshasn''taccurat eanswer!",he);printf("\nDoyouwanttocontinue?(Y/N)\n");do{decision=getchar();}while(decision!=''y''&&decision!=''Y''& &decision!=''n''&&decision!=''N'');}while(decision==''y''||decision==''Y'');for(i=1;ifree(a);free(c);}如对本文有所疑问，请点击进入脚本之家知识社区提问。

单纯形法解线性规划，注释很清楚了：#include<stdio.h>#include<math.h>#include<iostream.h>float matrix[100][100],x[100]; /* 记录总方程的数组,解的数组 */int a[100]; /* 记录基础,非基础的解的情况,0:非基础,1:基础 */int m,n,s,type; /* 方程变量,约束数,求最大最小值的类型,0:最小 1:最大 */ int indexe,indexl,indexg; /* 剩余变量,松弛变量,人工变量 */void Jckxj(){int i,j;for(i=0;i<n;i++)for(j=0;j<s;j++)if(matrix[i][j]==1&&a[j]==1){x[j]=matrix[i][s];j=s;}for(i=0;i<s;i++)if(a[i]==0) x[i]=0;}int Rj(){int i;for(i=0;i<s;i++)if(fabs(matrix[n][i])>=0.000001)if(matrix[n][i]<0) return 0;return 1;}int Min(){int i,temp=0;float min=matrix[n][0];for(i=1;i<s;i++)if(min>matrix[n][i]){min=matrix[n][i];temp=i;}return temp;}void JustArtificial(){int i;for(i=m+indexe+indexl;i<s;i++)if(fabs(x[i])>=0.000001){printf("No Answer\n");return;}}int Check(int in){int i;float max1=-1;for(i=0;i<n;i++)if(fabs(matrix[i][in])>=0.000001&&max1<matrix[i][s]/matrix[i][in]) max1=matrix[i][s]/matrix[i][in];if(max1<0)return 1;return 0;}int SearchOut(int *temp,int in){int i;float min=10000;for(i=0;i<n;i++)if(fabs(matrix[i][in])>=0.000001&&(matrix[i][s]/matrix[i][in]>=0)&&mi n>matrix[i][s]/matrix[i][in]){min=matrix[i][s]/matrix[i][in];*temp=i;}for(i=0;i<s;i++)if(a[i]==1&&matrix[*temp][i]==1) return i;}void Mto(int in,int temp){int i;for(i=0;i<=s;i++)if(i!=in)matrix[temp][i]=matrix[temp][i]/matrix[temp][in]; matrix[temp][in]=1;}void Be(int temp,int in){int i,j;float c;for(i=0;i<=n;i++){c=matrix[i][in]/matrix[temp][in];if(i!=temp)for(j=0;j<=s;j++)matrix[i][j]=matrix[i][j]-matrix[temp][j]*c;}}void Achange(int in,int out){int temp=a[in];a[in]=a[out];a[out]=temp;}void Print(){int i,j,k,temp=0;for(i=0;i<n;i++){for(k=temp;k<s;k++)if(a[k]==1){printf("X%d ",k);temp=k+1;k=s;}for(j=0;j<=s;j++)printf("%8.2f",matrix[i][j]);printf("\n");}printf("Rj ");for(j=0;j<=s;j++)printf("%8.2f",matrix[n][j]);printf("\n");}void InitPrint(){int i;printf("X");for(i=0;i<s;i++)printf(" a%d",i);printf(" b\n");Print();printf("\n");}void Result(){int i;printf(" (");for(i=0;i<s;i++)printf("%8.2f",x[i]);printf(" ) ");if(type==1)printf(" Zmax=%f\n\n",matrix[n][s]);else printf(" Zmin=%f\n\n",matrix[n][s]);}void PrintResult(){if(type==0) printf("The Minimal :%f\n",-matrix[n][s]);else printf("The Maximum :%f\n",matrix[n][s]);}void Merge(float nget[][100],float nlet[][100],float net[][100],float b[]){int i,j;for(i=0;i<n;i++){for(j=m;j<m+indexe;j++)if(nget[i][j-m]!=-1) matrix[i][j]=0;else matrix[i][j]=-1;for(j=m+indexe;j<m+indexe+indexl;j++)if(nlet[i][j-m-indexe]!=1) matrix[i][j]=0;else matrix[i][j]=1;for(j=m+indexe+indexl;j<s;j++)if(net[i][j-m-indexe-indexl]!=1) matrix[i][j]=0;else matrix[i][j]=1;matrix[i][s]=b[i];}for(i=m;i<m+indexe+indexl;i++)matrix[n][i]=0;for(i=m+indexe+indexl;i<s;i++)matrix[n][i]=100;matrix[n][s]=0;}void ProcessA(){int i;for(i=0;i<m+indexe;i++)a[i]=0;for(i=m+indexe;i<s;i++)a[i]=1;}void Input(float b[],int code[]){int i=0,j=0;printf("The equator Variable and Restrictor\n"); /* 输入方程变量和约束数 */cin>>m>>n;for(i=0;i<n;i++){printf("Input b[] and Restrictor code 0:<= 1:= 2:>=\n"); /* 输入方程右边的值,code的值 */cin>>b[i]>>code[i];printf("The XiShu\n");for(j=0;j<m;j++)cin>>matrix[i][j]; /* 输入方程 */}printf("The Type 0:Min 1:Max \n"); /* 输入求最大值还是最小值 */do{cin>>type;if(type!=0&&type!=1) printf("Error,ReInput\n");}while(type!=0&&type!=1);printf("The Z\n"); /* 输入z */for(i=0;i<m;i++)cin>>matrix[n][i];if(type==1)for(i=0;i<m;i++)matrix[n][i]=-matrix[n][i];}void Xartificial(){int i,j,k;if(indexg!=0){for(i=m+indexe+indexl;i<s;i++){for(j=0;j<n;j++)if(matrix[j][i]==1){for(k=0;k<=s;k++)matrix[n][k]=matrix[n][k]-matrix[j][k]*100;j=n;}}}}void Process(float c[][100],int row,int vol){int i;for(i=0;i<n;i++)if(i!=row) c[i][vol]=0;}void Sstart(float b[],int code[]){int i;float nget[100][100],nlet[100][100],net[100][100]; /* 剩余变量数组,松弛变量数组,人工变量数组 */indexe=indexl=indexg=0;for(i=0;i<n;i++){if(code[i]==0){nlet[i][indexl++]=1; Process(nlet,i,indexl-1);}if(code[i]==1){ net[i][indexg++]=1; Process(net,i,indexg-1); }if(code[i]==2){net[i][indexg++]=1;nget[i][indexe++]=-1;Process(net,i,indexg-1); Process(nget,i,indexe-1);}}s=indexe+indexl+indexg+m;Merge(nget,nlet,net,b); /* 合并 */ProcessA(); /* 初始化a[] */InitPrint(); /* 初始化打印 */Xartificial(); /* 消去人工变量 */}void Simplix() /* 单纯型算法 */{int in,out,temp=0;while(1){Jckxj(); /* 基础可行解 */Print(); /* 打印 */Result(); /* 打印结果 */if(!Rj()) in=Min(); /* 求换入基 */else {if(indexg!=0) JustArtificial(); /* 判断人工变量 */ PrintResult(); /* 打印最后结果 */return;}if(Check(in)){ /* 判断无界情况 */printf("No Delimition\n");return;}out=SearchOut(&temp,in); /* 求换出基 */Mto(in,temp); /* 主元化1 */Be(temp,in); /* 初等变换 */Achange(in,out); /* 改变a[]的值 */}}void main(){int code[100]; /* 输入符号标记 */float b[100]; /* 方程右值 */Input(b,code); /* 初始化 */Sstart(b,code); /* 化标准型 */Simplix(); /* 单纯型算法 */}。

程序源代码：#include<stdio.h>#include<math.h>#define MAX_N 100#define M 1000000.0;int m, n;double A[MAX_N][MAX_N], C[MAX_N], b[MAX_N], seta[MAX_N], CZ[MAX_N]; int num[MAX_N];int GetOutCow() //求换出基{int i,k;int flag;double min = 0;for (i = 0; i < m; i ++){if (b[i] >= 0)flag = 1;else{flag = 0;break;}}if (flag == 1)return -1;for (i = 0; i < m; i ++){if (b[i] < 0 && min > b[i]){min = b[i];k = i;}}return k;}int GetInCow(int p) //求换入基{int i, j;int flag = 0;double min;for (j = 0; j < n; j ++){if (A[p][j] >= 0)flag = 1;else{flag = 0;break;}}if (flag == 1){printf("\n原线性规划问题无可行解!\n");return -1;}for (j = 0; j < n; j ++){if (A[p][j] < 0)seta[j] = CZ[j] / A[p][j];elseseta[j] = M;}min = M;for (j = 0; j < n; j ++){if (min >= seta[j]){min = seta[j];i = j;}}num[p] = i + 1;return i;}void change(int p, int q) //计算新的单纯形表{int i, j;double temp1, temp2, temp3;temp1 = A[p][q];for (i = 0; i < m; i ++){if (i != p){if (A[i][q] != 0){temp2 = A[i][q] / temp1;for (j = 0; j < n; j ++)A[i][j] = A[i][j] - A[p][j] * temp2;b[i] = b[i] - b[p] * temp2;}}}temp3 = CZ[q] / temp1;for (i = 0; i < n; i ++)CZ[i] = CZ[i] - A[p][i] * temp3;for (j = 0; j < n; j ++)A[p][j] = A[p][j] / temp1;b[p] = b[p] / temp1;}void print1(){int i;printf("\n--------------------------------------------------------------------------\n");printf("\t");for(i = 1; i <= n; i ++)printf("X(%d)\t", i);printf("RHS\n");printf("--------------------------------------------------------------------------\n");printf("\t");for (i = 0; i < n; i ++){printf("%.3lf\t", -C[i]);}printf("\n--------------------------------------------------------------------------\n"); }void print2(){int i, j;printf("\n--------------------------------------------------------------------------\n");for (i = 0; i < m; i ++){printf("x(%d)\t", num[i]);for(j = 0; j < n; j ++)printf("%.3lf\t", A[i][j]);printf("%.3lf\n", b[i]);}printf("--------------------------------------------------------------------------\n");printf("cj-zj\t");for (i = 0; i < n; i ++)printf("%.3lf\t", CZ[i]);printf("\n--------------------------------------------------------------------------\n"); }void Input(){int i, j;printf("请输入约束条件的个数：\n");scanf("%d", &m);printf("请输入变量的个数：\n");scanf("%d", &n);printf("请输入方程组的系数矩阵A(%d行%d列):\n", m, n);for (i = 0; i < m; i ++){for (j = 0; j < n; j ++){scanf("%lf", &A[i][j]);}}printf("\n请输入初始基变量的数字代码num矩阵:\n");for (i =0; i < m; i ++)scanf("%d", &num[i]);printf("\n请输入方程组右边的值矩阵b:\n");for (i = 0; i < m; i ++)scanf("%lf", &b[i]);printf("\n请输入目标函数各个变量的系数所构成的系数阵C:\n");for (i = 0; i < n; i ++)scanf("%lf", &C[i]);}void main(){int i, j;int p, q;double z = 0;Input();for (i = 0; i < m; i ++){b[i] = -b[i];for (j = 0; j < n; j ++)A[i][j] = -A[i][j];}for (i = 0; i < n; i ++){CZ[i] = -C[i];}print1();print2();while(1){p = GetOutCow(b);if(p == -1){printf("\n所得解已经是最优解!\n");for (i = 0; i < m; i ++)z += b[i] * C[num[i] - 1];for(i = 0; i < m; i ++)printf("x(%d) = %.3lf\t", i + 1, b[i]);printf("z = %.3lf\n", z);break;}q = GetInCow(p);if (q == -1)break;change(p, q);print2();}}运行实例先将其化为标准型运行结果：请输入约束条件的个数：2请输入变量的个数：5请输入方程组的系数矩阵A(2行5列):3 1 1 -1 0-1 4 1 0 -1请输入初始基变量的数字代码num矩阵:4 5请输入方程组右边的值矩阵b:1 2请输入目标函数各个变量的系数所构成的系数阵C:1 1 1 0 0-------------------------------------------------------------------------- X(1) X(2) X(3) X(4) X(5) RHS -------------------------------------------------------------------------- -1.000 -1.000 -1.000 0.000 0.000-------------------------------------------------------------------------- -------------------------------------------------------------------------- x(4) -3.000 -1.000 -1.000 1.000 0.000 -1.000 x(5) 1.000 -4.000 -1.000 0.000 1.000 -2.000 -------------------------------------------------------------------------- cj-zj -1.000 -1.000 -1.000 0.000 0.000-------------------------------------------------------------------------- -------------------------------------------------------------------------- x(4) -3.250 0.000 -0.750 1.000 -0.250 -0.500 x(2) -0.250 1.000 0.250 0.000 -0.250 0.500 -------------------------------------------------------------------------- cj-zj -1.250 0.000 -0.750 0.000 -0.250-------------------------------------------------------------------------- -------------------------------------------------------------------------- x(1) 1.000 0.000 0.231 -0.308 0.077 0.154 x(2) 0.000 1.000 0.308 -0.077 -0.231 0.538 -------------------------------------------------------------------------- cj-zj 0.000 0.000 -0.462 -0.385 -0.154-------------------------------------------------------------------------- 所得解已经是最优解!x(1) = 0.154 x(2) = 0.538 z = 0.692。

用C语言解决线性规划问题（用单纯形法解）#include<stdio.h>#include<math.h>#include<iostream.h>#define BORDER -0.00001#define M 100int main(){int k; //初始变量的个数int m; //约束条件的个数;cout<<"输入初始变量的个数"<<endl;cin>>k;cout <<"输入约束条件的个数"<<endl;cin>>m;cout<<"输入约束条件的种类"<<endl;cout<<"0 means <="<<endl;cout<<"1 means >="<<endl;cout<<"2 means ="<<endl;int NGET=0;int NLET=0;int NET =0;int I =0;//人工变量；int *code=new int[m]; //the array of the >= <= =;for(int i=0;i<m;i++){cin>>code[i];if(code[i]==0)NGET++;if(code[i]==1)NLET++;I++ ;if(code[i]==2)NET++;I++ ;}int n; //变量总和；n=k+2*NLET+NGET+NET;float *Index=new float[n+1]; //目标函数的系数;float *c=new float[n+1];int NTYPE;for(i=0;i<n+1;i++)Index[i]=0.0;//为语法要求定初值；cout<<"输入目标函数的系数"<<endl;for(i=0;i<k;i++)cin>>Index[i];for(i=k+NGET+NLET;i<n;i++)//人工变量所在的列；Index[i]=-M; //the initionalization of indexes of manul variable;cout<<"输入所求函数的类型是求最大还是最小"<<endl;cout<<"0 means min"<<endl;cout<<"1 means max"<<endl;cin>>NTYPE;if(NTYPE) //the initionalization of the c[i];{for(i=0;i<n+1;i++)c[i]=-Index[i];//一般情况下只要将目标函数系数的相反数输入；}if(!NTYPE){for(i=0;i<n+1;i++)if(i<k+NGET+NLET)c[i]=Index[i];else c[i]=-Index[i];}delete []Index;float **a=new float*[m+1]; //the array of all the variable to compute;for(i=0;i<m+1;i++)a[i]=new float[n+1];int INDEXG=k;int INDEXL=k+NGET;int INDEXE=k+NGET+NLET;int *ARTV=new int[I]; //保存人工变量；for(i=0;i<m;i++) //the analization of the code[](<= >= = );{if(code[i]==0){a[i][INDEXL]=1.0;INDEXL++;}if(code[i]==1){a[i][INDEXE]=1.0;INDEXE++;a[i][INDEXG]=-1.0;INDEXG++;ARTV[I]=i;I++;}if(code[i]==2){a[i][INDEXE]=1.0;INDEXE++;ARTV[I]=i;I++;}}if( (INDEXG!=k+NLET) || (INDEXL!=k+NGET+NLET) || (INDEXE!=n) )//excption {return -1;}cout<<"输入约束表达式左边的系数"<<endl;for(i=0;i<m;i++)for(int j=0;j<k;j++)cin>>a[i][j];float *b=new float[m];cout<<"输入约束表达式右边的值" <<endl;for(i=0;i<m;i++)cin>>b[i];for(i=0;i<m;i++)a[i][n]=b[i];float *temp=new float[n+1];if(I){for(i=0;i<I;i++)for(int j=0;j<n+1;j++){temp[j]=-a[ARTV[i]][j];c[j]+=M*temp[j];}}for(i=0;i<n+1;i++)a[m][i]=c[i];for(i=0;i<m+1;i++){for(int j=0;j<n+1;j++)cout<<a[i][j]<<" ";cout<<endl;}int flag=0;float temp1;float temp2;int K,J;int index;for(i=0;i<n;i++)if(a[m][i]<0)flag=1; //检验系数;while(flag) //Using a[][] to compute the result; {temp1=0;for(i=0;i<n;i++){if(temp1>a[m][i]){temp1=a[m][i];K=i;}}temp2=M;for(i=0;i<m;i++){if(a[i][K]>0&&(a[i][n]/a[i][K])<temp2){temp2=a[i][n]/a[i][K];J=i;}}if(temp2==M){cout<<"无解!"<<endl;return -1;}float temp3=a[J][K];for(i=0;i<n+1;i++){a[J][i]=a[J][i]/temp3;}for(i=0;i<m+1;i++){if(i!=J){float temp4=a[i][K];for(int j=0;j<n+1;j++){a[i][j]=a[i][j]- a[J][j]*temp4;}}cout<<endl;}flag=0;for(i=0;i<n+1;i++){if(a[m][i]<BORDER)flag=1;}cout<<"**************************************"<<endl;for(i=0;i<m+1;i++){for(int j=0;j<n+1;j++)cout<<a[i][j]<<" ";cout<<endl;}cout<<"***************************************"<<endl;getchar();}if(NTYPE)cout<<"The answer is :"<<a[m][n];if(!NTYPE)cout<<"The answer is :"<<-a[m][n];getchar();return 0;}。