线性规划之单纯形解法Java实现

##单纯形法

理解完这个算法后大家也可以打一下，打码过程中，会有很多很多的错误要排查，编码一小时，排错三小时，不过从中可以练习到蛮多的（运行截图在文末）

• 输入线性规划标准型的数据（n个变量，m个约束条件）

  • C //价值系数向量
  • X //决策变量向量
  • A //工艺系数矩阵
  • b //资源常数
  • yita //检验数
  • theta //b除以换入变量在每行的系数，即单纯形表最右端参数

• 找基可行解

  • 简单的拿最后m个决策变量，后期可优化

• 判断是否最优解:计算并判断是否每一个检验数yita都小于等于0

  • 是
    • 输出最优解:max z = CX
  • 否
    • 确定换入变量
      • 检验数大于0中，检验数最大的非基变量
    • 确定换出变量
      • 计算theta
      • 判断是否线性规划结果为无界解：theta的系数是否均小于或等于0
        • 是
          • 终止运算，输出结果为无界解
        • 否
          • 取theta[i]中大于0且最小的行所对应的基变量作为换出变量
    • 旋转运算
      • 换入变量的所对应的方程中左右两边同除换入变量的系数
      • 再次循环，重新判断是否最优解

所有函数

• void inputNums() //输入数据
• void findBasedVariables() //找基变量
• bool isOptimum() //是否最优解
• int getVariableIn() //确定换入变量
• int getVariableOut() //确定换出变量
• void updateVectors() //更新旋转运算后的矩阵
• private static void printVector() //输出系数矩阵
• void printOptimun() //输出最优解

先在main函数中写好主要逻辑，再具体实现

public static void main(String[] args) {
		//输入数据，为了简单起见，我们的数据直接在代码中敲入，这个函数等测试完后加
		inputNums(); 
		//找初始基变量
		findBasedVariables();
		//判断是否最优解
		while (!isOptimum()) {
			//找换入变量
			idxOfIn = getVariableIn();
			printVector();
			//找换出变量
			idxOfOut = getVariableOut();
			//如果idxOfOut返回-1，则该线性规划问题有无界解
			if(idxOfOut == -1)
				return;
			//旋转运算，更新矩阵
			updateVectors();
			printVector();
			System.out.println("\n");
		}
		//输出最优解
		printOptimum();
	}

全局变量

private static double A[][] = { { 1, 2, 1, 0, 0 }, 
									{ 2, 1, 0, 1, 0 },
									{ 4, 3, 0, 0, 1 } };// 系数矩阵
	
	private static int m = A.length; //m个方程
	private static int n = A[0].length; //n个决策变量
	
	private static double C[] = { 3, 2, 0, 0, 0 }; // 价值系数
	
	private static double b[] = { 5, 4 ,9}; // 资源常数
	
	private static double theta[] = new double[m]; //b的检验数
	
	private static int basedVar[] = new int[m]; // 基变量，存基变量的下标，从1开始标号（区别于数组存储习惯）
	
	private static double yita[] = new double[n]; //检验数，有n个决策变量的检验数
	
	private static double result = -1; //结果
	
	private static int idxOfIn = -1; //换入变量的下标
	
	private static int idxOfOut = -1; //换出变量的下标

inputNums()

// 输入数据，先在代码中写入数据，后期再加，先把初始检验数赋值为价值系数
	private static void inputNums() {
		for (int i = 0; i < yita.length; i++) {
			yita[i] = C[i]; //yita为检验数
		}
	}

findBasedVariables()

// 找基变量，简单的拿最后m个决策变量，后期可优化，存储在basedVar数组中
	private static void findBasedVariables() {
		
		//取n个决策变量的最后m个作基变量
		for (int i = 0; i < m; i++) {
			//basedVar[i] = n-i; 
			//改变存放顺序为正叙
			basedVar[m-i-1] = n-i ;
		}
		System.out.println("基变量为：");
		for (int i = 0; i < basedVar.length; i++) {
			System.out.print("x" + (basedVar[i]) + "\t");
		}
		System.out.println();
	}

isOptimum()

// 判断是否最优解，并计算检验数yita向量
	private static boolean isOptimum() {
		//换入变量代替换出变量
		if(idxOfIn != -1 && idxOfOut != -1){
			//第idxOfOut个基变量换为x idxOfIn	
			basedVar[idxOfOut] = idxOfIn+1;
		}
		//更新检验数
		for (int i = 0; i < n; i++) {
			double temp = yita[i];
			for (int j = 0; j < m; j++) {
				temp -= A[j][i] * C[basedVar[j] -1]; 
			}
			yita[i] = temp;
		}
		
		boolean hasPossitiveYita = false;
		for (int i = 0; i < yita.length; i++) {
			if(yita[i] > 0)
				hasPossitiveYita = true;
		}
		System.out.println("是否最优解：" + !hasPossitiveYita);
		return !hasPossitiveYita;
	}

getVariableIn()

// 确定换入变量，返回换入变量的下标-1
	private static int getVariableIn() {
		//遍历检验数
		int index = 0;
		System.out.println("检验数如下：");
		for (int i = 0; i < yita.length; i++) {
			 System.out.print(yita[i] + "\t");
			 if(yita[i] > yita[index]){
				 index = i;
			 }
		}
		System.out.println();
		System.out.println("换入变量是x" + (index+1));
		return index;
	}

getVariableOut()

// 确定换出变量，返回换出变量在基变量向量中的下标
	private static int getVariableOut() {
		
		System.out.println("theta：");
		for (int i = 0; i < m; i++) {
			if( Double.compare(A[i][idxOfIn], 0) != 0)
				theta[i] = b[i] / A[i][idxOfIn];
			else {
				theta[i] = 0;
			}
			System.out.print(theta[i] + "\t");
		}
		System.out.println();

		int index = 0;
		for (int i = 0; i < theta.length; i++) {
			if(theta[i] <= 0){
				System.out.println("该方程有无界解...");
				return -1;
			}else {
				if(theta[i] < theta[index])
					index = i;
			}
		}
		System.out.println("换出变量是:x" + (basedVar[index]));
		return index;
	}

updateVectors()

// 更新旋转运算后的矩阵
	private static void updateVectors() {
		//m个方程，n个变量
		//将主元系数化为1
		//防止迭代中主元的值被改变后引起 其它系数除主元的新值，将主元的原值存于temp
		double temp = A[idxOfOut][idxOfIn]; 
		for (int i = 0; i < n; i++) {
			A[idxOfOut][i] /= temp;
		}
		b[idxOfOut] /= temp;
		
		System.out.println("\n将主元系数化为1");
		printVector();
		//主元所在列其余元素系数要化为0，即：主元列中，非主元所在行均减去 主元系数分之一*A[m][n]
		for (int i = 0; i < m; i++) {
			//若是换出变量所对应行，则该行不用换算
			double temp1 = A[i][idxOfIn]/A[idxOfOut][idxOfIn]; 
			if(i != idxOfOut){
				for (int j = 0; j < n; j++) {
					A[i][j] -= A[idxOfOut][j]*temp1;
				}
				b[i] -= b[idxOfOut] * temp1;
			}
		}
		System.out.println("完成一次矩阵旋转运算...");
	}

printVector()

//输出系数矩阵
	private static void printVector() {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.print(A[i][j] + "\t");
			}
			System.out.println(b[i]);
		}
		System.out.println("-----------------------------------------------");
	}

printOptimum()

//输出最优解
	private static void printOptimum() {
		result = 0;
		for (int i = 0; i < basedVar.length; i++) {
			result += C[basedVar[i]-1] * b[i];
		}
		System.out.println("最优解：z = " + result);
	}