import java.util.

Arrays;
import java.util.Scanner;

public class Matala {

public static void main(String[] args) {

boolean ans=false;
double RHSfinal=0;
boolean manysol=false;
boolean menovansol=false;

Scanner sc= new Scanner(System.in);

System.out.println("Please enter 0 if the function type is min and 1 if max");
int type=sc.nextInt();
System.out.println("Plese enter the number of decision variables");
int des=sc.nextInt();
System.out.println("Plese enter the number of constraint variables");
int con=sc.nextInt();

double Zfun[]=new double[des+con];

double Mat[][]=new double[con+1][des+con+1];
for (int i = 0; i < des; i++) {
System.out.println("Plese enter the Z function variable number "+(i+1));
double temp=sc.nextDouble();
Mat[0][i]=-temp;
Zfun[i]=temp;
 }

for (int i = 1; i <=con; i++) {

for (int j = 0; j < des; j++) {
System.out.println("Plese enter the coefficient of "+(j+1)+"the decision
variables of the "+(i)+ "constraint");
double temp=sc.nextDouble();
Mat[i][j]=temp;
}

System.out.println("Plese enter the RHS of " +(i)+ "constraint");

double RHS=sc.nextDouble();
Mat[i][Mat[0].length-1]=RHS;
}

int i=Mat.length-1;
int j=Mat[0].length-2;

for (int k = 0; k < con; k++) {

Mat[i][j]=1;
i--;
j--;
}

int CBindex[]=new int[con];

for (int k = des; k < Mat[0].length-1; k++) {

CBindex[k-des]=k;
}

double CB[]=new double[con];

double Btemp[][]=new double[con][con];
double B[][]=new double[con][con];
double Binverse[][]=new double[B.length][B[0].length];
double y[]=new double[con];
double A[][]=new double[con][des];
double First[][]=new double[con][des+con];
for (int k = 0; k < First.length; k++) {
for (int k2 = 0; k2 < First[0].length; k2++) {
First[k][k2]=Mat[k+1][k2];
}
}

for (int k = 0; k < A[0].length; k++) {

for (int k2 = 0; k2 < A.length; k2++) {
A[k2][k]=Mat[k2+1][k];
}
}

double Ay[]=new double[des];

double c[]=new double[des];
for (int k = 0; k < c.length; k++) {
c[k]=Mat[0][k]*(-1);
}
double CAY[]=new double[c.length];
double b[]=new double[con];
for (int k = 0; k < b.length; k++) {
b[k]=Mat[k+1][Mat[0].length-1];
}
double Base[]=new double[con];
double BA[][]=new double[Binverse.length][A[0].length];
int count=0;
while(!ans){
count++;
double max=Mat[0][0];
double min=Mat[0][0];
int index = 0;

if(type==0){
for (int k = 1; k <Mat[0].length-1; k++) {
if(Mat[0][k]>max){
index=k;
max=Mat[0][k];
}
}

else{
for (int k = 1; k <Mat[0].length-1; k++) {
if(Mat[0][k]<min){
index=k;
min=Mat[0][k];
}
}
}
min=Mat[1][Mat[0].length-1]/Mat[1][index];
if(min<0)min=Double.POSITIVE_INFINITY;
int indexRow=1;
double sum=0;
for (int k = 2; k < Mat.length; k++) {
sum=Mat[k][Mat[0].length-1]/Mat[k][index];
if(min>sum && sum>=0){
 indexRow=k;
min=sum;
}

CBindex[indexRow-1]=index;
for (int k = 0; k < CBindex.length; k++) {
CB[k]=Zfun[CBindex[k]];
}

for (int k2 = 0; k2 < B.length; k2++) {

for (int k = 0; k < B[0].length; k++) {
B[k2][k]=First[k2][CBindex[k]];
}
}

for (int k = 0; k < Btemp.length; k++) {

for (int k2 = 0; k2 < Btemp[0].length; k2++) {
Btemp[k][k2]=B[k][k2];
}
}
Binverse=invert(Btemp);

BA=multiply(Binverse,A);

for (int k = 0; k < BA.length; k++) {

for (int k2 = 0; k2 < BA[0].length; k2++) {
Mat[k+1][k2]=BA[k][k2];
}
}

for (int k = 0; k < Binverse.length; k++) {

for (int k2 = 0; k2 < Binverse[0].length; k2++) {
Mat[k+1][k2+des]=Binverse[k][k2];
}
}
y=multiplyWithForLoops(Binverse,CB);
Ay=multiplyWithForLoops(A,y);

for (int k = 0; k < CAY.length; k++) {

CAY[k]=Ay[k]-c[k];
}

double sum1=0;
for (int k = 0; k < b.length; k++) {
sum1+=b[k]*y[k];
}
RHSfinal=sum1;
Mat[0][Mat[0].length-1]=RHSfinal;

boolean boolCAY=true;
boolean booly=true;
boolean boolbB=true;

int k;
if(type==0){
for (k = 0; k < CAY.length; k++) {
 Mat[0][k]=CAY[k];
if(CAY[k]>0)boolCAY=false;
}
for (int j1 = k; j1 < y.length+k; j1++) {
Mat[0][j1]=y[j1-k];
if(y[j1-k]>0)booly=false;
}
Base=multiplyWithForLoops1(Binverse,b);
for (int k2 = 0; k2 < b.length; k2++) {
Mat[k2+1][Mat[0].length-1]=Base[k2];
if(Base[k2]>0)boolbB=false;
}
}
else{
for (k = 0; k < CAY.length; k++) {
Mat[0][k]=CAY[k];
if(CAY[k]<0)boolCAY=false;
}
for (int j1 = k; j1 < y.length+k; j1++) {
Mat[0][j1]=y[j1-k];
if(y[j1-k]<0)booly=false;
}
Base=multiplyWithForLoops1(Binverse,b);
for (int k2 = 0; k2 < b.length; k2++) {
Mat[k2+1][Mat[0].length-1]=Base[k2];
if(Base[k2]<0)boolbB=false;
}
}

if(boolCAY && booly && boolbB)ans=true;

}
boolean isBase=false;
for (int k = 0; k < Mat[0].length-1; k++) {
for (int k2 = 0; k2 < CBindex.length; k2++) {
if(k==CBindex[k2])isBase=true;
}
if(!isBase && Mat[0][k]==0)manysol=true;
isBase=false;
}
for (int k = 0; k < Base.length; k++) {
if(Base[k]==0)menovansol=true;
}
if(manysol) System.out.println("There are many solutions to this function");
else if(menovansol)System.out.println("The solution is menovan");
else{
System.out.println("Z value is " +RHSfinal);
System.out.println(Arrays.toString(Base));
System.out.println("B Matrix: ");
for (int k = 0; k < B.length; k++) {
for (int k2 = 0; k2 < B[0].length; k2++) {
System.out.print(B[k][k2]+" ");
}
System.out.println();
}

System.out.println("B^-1 Matrix: ");

for (int k = 0; k < Binverse.length; k++) {
for (int k2 = 0; k2 < Binverse[0].length; k2++) {
System.out.print(Binverse[k][k2]+" ");
}
System.out.println();
}
 }
System.out.println(count);
}

public static double[][] multiply(double[][] a, double[][] b) {

int m1 = a.length;
int n1 = a[0].length;
int m2 = b.length;
int n2 = b[0].length;
if (n1 != m2) throw new RuntimeException("Illegal matrix dimensions.");
double[][] c = new double[m1][n2];
for (int i = 0; i < m1; i++)
for (int j = 0; j < n2; j++)
for (int k = 0; k < n1; k++)
c[i][j] += a[i][k] * b[k][j];
return c;
}

public static double[] multiplyWithForLoops1(double[][] matrix, double[] vector) {

int rows = matrix.length;
int columns = matrix[0].length;

double ans[]=new double[rows];

for (int i = 0; i < rows; i++) {

double sum=0;
for (int j = 0; j < columns; j++) {
sum=sum+vector[j]*matrix[i][j];
}
 ans[i]=sum;
}
return ans;

public static double[] multiplyWithForLoops(double[][] matrix, double[] vector) {

int rows = matrix.length;
int columns = matrix[0].length;

double ans[]=new double[columns];

for (int i = 0; i < columns; i++) {

double sum=0;
for (int j = 0; j < rows; j++) {
sum=sum+vector[j]*matrix[j][i];
}
ans[i]=sum;
}
return ans;

public static double[][] invert(double a[][])

{
int n = a.length;
double x[][] = new double[n][n];
double b[][] = new double[n][n];
int index[] = new int[n];
for (int i=0; i<n; ++i)
 b[i][i] = 1;

// Transform the matrix into an upper triangle

gaussian(a, index);

// Update the matrix b[i][j] with the ratios stored

for (int i=0; i<n-1; ++i)
for (int j=i+1; j<n; ++j)
for (int k=0; k<n; ++k)
b[index[j]][k]
-= a[index[j]][i]*b[index[i]][k];

// Perform backward substitutions

for (int i=0; i<n; ++i)
{
x[n-1][i] = b[index[n-1]][i]/a[index[n-1]][n-1];
for (int j=n-2; j>=0; --j)
{
x[j][i] = b[index[j]][i];
for (int k=j+1; k<n; ++k)
{
x[j][i] -= a[index[j]][k]*x[k][i];
}
x[j][i] /= a[index[j]][j];
}
}
return x;
}

// Method to carry out the partial-pivoting Gaussian

// elimination. Here index[] stores pivoting order.
public static void gaussian(double a[][], int index[])
{
int n = index.length;
double c[] = new double[n];

// Initialize the index

for (int i=0; i<n; ++i)
index[i] = i;

// Find the rescaling factors, one from each row

for (int i=0; i<n; ++i)
{
double c1 = 0;
for (int j=0; j<n; ++j)
{
double c0 = Math.abs(a[i][j]);
if (c0 > c1) c1 = c0;
}
c[i] = c1;
}

// Search the pivoting element from each column

int k = 0;
for (int j=0; j<n-1; ++j)
{
double pi1 = 0;
for (int i=j; i<n; ++i)
{
double pi0 = Math.abs(a[index[i]][j]);
pi0 /= c[index[i]];
 if (pi0 > pi1)
{
pi1 = pi0;
k = i;
}
}

// Interchange rows according to the pivoting order

int itmp = index[j];
index[j] = index[k];
index[k] = itmp;
for (int i=j+1; i<n; ++i)
{
double pj = a[index[i]][j]/a[index[j]][j];

// Record pivoting ratios below the diagonal

a[index[i]][j] = pj;

// Modify other elements accordingly

for (int l=j+1; l<n; ++l)
a[index[i]][l] -= pj*a[index[j]][l];
}
}
}
}