1.

#include<stdio.h>
#include<conio.h>
#define max 4
void main()
{
struct val
{
int flag,cross,cost,mark;
}

val [max][max],temp[max][max];
int i,j,k,big,c,min[max],sum=0;

clrscr();
/*val[max][max].cost={1,2,3,4,5,6,7,8,9};*/

for(i=0;i<=max;i++)
{
for(j=0;j<=max;j++)
{
val[i][j].flag=val[i][j].cross=val[i][j].cost=val[i][j].mark=0;
temp[i][j].flag=temp[i][j].cross=temp[i][j].cost=temp[i][j].mark=0;
}
}

printf ("\n Enter the cost matrix of %dx%d:",max,max);

for(i=0;i<max;i++)
{
printf ("\n\n %d row:",i+1);
for (j=0;j<max;j++)
{
scanf ("%d",&val[i][j].cost);
temp[i][j].cost=val[i][j].cost;
}
}
/*for min in row*/
for (i=0;i<max;i++)
min[i]=val[i][0].cost;
for (i=0;i<max;i++)
{
for (j=0;j<max;j++)
{
if(min[i]>=val[i][j].cost)
min[i]=val[i][j].cost;
}
for (j=0;j<max;j++)
temp[i][j].cost=temp[i][j].cost-min[i];
}
for (i=0;i<max;i++)
{
printf ("\n");
for(j=0;j<max;j++)
printf (" %d ",temp[i][j].cost);
}
printf ("\n");
for (i=0;i<max;i++) /*for min in column*/
min[i]=temp[0][i].cost;
for(i=0;i<max;i++)
{
for (j=0;j<max;j++)
{
if (min[i]>=temp[j][i].cost)
min[i]=temp[j][i].cost;
}
for (j=0;j<max;j++)
{
temp[j][i].cost=temp[j][i].cost-min[i];
}
}
for (i=0;i<max;i++)
{
printf ("\n");
for (j=0;j<max;j++)
{
printf (" %d ",temp[i][j].cost);
}
}

for (i=0;i<max;i++) /*selecting zero from row*/
{
c=0;
for(j=0;j<max;j++)
{
if (temp[i][j].cost==0)
c++;
}
if (c==1)
{
for (j=0;j<max;j++)
if (temp[i][j].cost==0 && temp[i][j].mark==0 && temp[i][j].cross==0)
{
temp[i][j].mark=1;
for(k=0;k < max;k++)
if(temp[k][j].cost==0 && temp[k][j].mark==0)
temp[k][j].cross=1;
}
}
}
printf ("\n");
for (i=0;i<max;i++)
{
printf ("\n");
for (j=0;j<max;j++)
printf (" %d ",temp[i][j].mark);
}
for ( i=0;i<max;i++) /*selecting zero from column*/
{
c=0;
for (j=0;j<max;j++)
{
if (temp[j][i].cost==0)
c++;
}
if(c==1)
{
for (j=0;j<max;j++)
if (temp[j][i].cost==0 && temp[j][i].mark==0 && temp[j][i].cross==0)
{
temp[j][i].mark=1;
for(k=0;k<max;k++)
{
if (temp[j][k].cost==0 && temp[j][k].mark==0)
temp[j][k].cross=1;
}
}
}
}
printf ("\n");
for (i=0;i<max;i++)
{
printf ("\n");
for (j=0;j<max;j++)
printf (" %d ",temp[i][j].mark);
}
for (i=0;i<max;i++)
{
for(j=0;j<max;j++)
{
if (temp[i][j].mark==1)
sum=sum+val[i][j].cost;
}
}
printf ("\n optimum value is %d",sum);
getch();
}

2.

PROGRAM FOR SIMPLEX METHOD

#include "iostream.h"
#include "conio.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"

int varNo,conNo;
float objFunc[10];
int con[10][10],basicVar[10];

float sum[10],theta[10],z;
float calc[10][10],ratio[10];

void getData();
void show();
void compute();

void main()
{
clrscr();
getData();
compute();
}

void getData()
{

cout<<"Enter number of variables ";
cin>>varNo;
/*enter objective functions*/
cout<<"Enter the coefficient for objective function:"<<endl;
for (int i=1;i<=varNo;i++)
{
cout<<"coefficient for x"<<i<<" = ";
cin>>objFunc[i-1];
}
/*enter no of constraints*/
cout<<endl<<"Enter Number of constraints: ";
cin>>conNo;
for(i=0;i<conNo;i++)
{
cout<<endl<<"Enter coefficients for constraint "<<(i+1)<<endl;
for(int j=0;j<varNo;j++)
{
cout<<"Enter coefficient for x"<<(j+1)<<" = ";
cin>>con[i][j];
}
/*get info @ <= >= and RHS of constraints*/

cout<<endl<<"RHS information.";
cout<<endl<<"1) <= -1) >= 0) ="<<endl<<"Enter choice: ";
cin>>con[i][varNo];
cout<<"Enter the RHS value: ";
cin>>con[i][varNo+1];
clrscr();
}

show();
/* if RHS of any constraint is negative then multiply the
contraint coefficient by -1*/
for(i=0;i<conNo;i++)
if(con[i][varNo+1]<0)
for(int j=0;j<varNo+2;j++)
con[i][j]*=-1;
show();
}

void show()
{
//clrscr();
cout<<endl<<"Maximize Z = ";
for (int i=0;i<varNo-1;i++)
{
cout<<objFunc[i]<<"x"<<(i+1);
if(objFunc[i+1]>=0)
cout<<"+";
}
cout<<objFunc[i]<<"x"<<(i+1)<<endl;
/*display constraints*/
cout<<"Subject to constraints: "<<endl;
for(i=0;i<conNo;i++)
{
cout<<endl;
for(int j=0;j<varNo-1;j++)
{
cout<<con[i][j]<<"x"<<(j+1);
if(con[i][j+1]>=0)
cout<<" + ";
}
cout<<con[i][j]<<"x"<<(j+1);
if(con[i][varNo]==1)
cout<<" <= ";
else
if(con[i][varNo]<0)
cout<<" >= ";
else
cout<<" = ";

cout<<con[i][varNo+1]<<" ";
}
getch();
}

void compute()
{
int maxIndex,maxElement,minIndex,minElement;
int i,j,theta_neg=0,ratio_neg=0;
float factor,temp,temp2;

/*initialize current vector and obj[] array with coefficient
of slack variable*/
for(i=0;i<conNo;i++)
{

basicVar[i]=varNo+i;
objFunc[varNo+i]=0;
}
/*initialize calc[][] with coefficient of constraints and
RHS of constraints*/
for(i=0;i<conNo;i++)
{
for(j=0;j<varNo;j++)
{
calc[i][j]=con[i][j];
}
calc[i][varNo+i]=con[i][varNo];
calc[i][varNo+conNo]=con[i][varNo+1];
}
while(1)
{
/*calculate summation sum[] values*/
for(i=0;i<varNo+conNo;i++)
{
sum[i]=0;
theta[i]=0;
}
for(i=0;i<varNo+conNo;i++)
{

for(j=0;j<conNo;j++)
{
sum[i]+=calc[j][i]*objFunc[basicVar[j]];
}
}
/*calculate ncc values*/
theta_neg=1;
for(i=0;i<varNo+conNo;i++)
{
theta[i]=objFunc[i]-sum[i];
if(theta[i]>0)
theta_neg=0;
if(i==0)
{
maxIndex=0;
maxElement=theta[0];
}
else
{
if(theta[i]>maxElement)
{
maxIndex=i;
maxElement=theta[i];
}
}
}//end for
if(theta_neg)
{
for(i=0;i<conNo;i++)
{
if(basicVar[i]<varNo)
z+=objFunc[basicVar[i]]*calc[i][conNo+varNo];
}
for(i=0;i<conNo;i++)
{
if(basicVar[i]<varNo)
cout<<endl<<"The Value of x"<<(basicVar[i]+1)
<<"is = "<<calc[i][varNo+conNo];
}
cout<<endl<<"The Optimal Value of Z is "<<z;
getch();
exit(0);
}
/*calculate ratio*/
ratio_neg=1;
minElement=10000;
for(i=0;i<conNo;i++)
{
if(calc[i][maxIndex]==0)
ratio[i]=9999; //INFINITY
else
{
if(calc[i][varNo+conNo]==0 && calc[i][maxIndex]<0)
ratio[i]=-1; //NEGATIVE
else
ratio[i]=calc[i][varNo+conNo]/calc[i][maxIndex];
}
if(ratio[i]>=0 && ratio[i] !=9999)
ratio_neg=0;
if(i==0 && ratio[i]!=9999 && ratio[i]>=0)
{
minIndex=0;
minElement=ratio[0];
}
else
{
if(ratio[i]<minElement && ratio[i]!=9999 && ratio[i]>=0)
{
minIndex=i;
minElement=ratio[i];
}
}
}//end for
if(ratio_neg)
{
cout<<endl<<"There is unbounded solution to the problem";
getch();
exit(0);
}
/*make key element=1*/
temp2=calc[minIndex][maxIndex];
for(i=0;i<varNo+conNo+1;i++)
calc[minIndex][i]/=temp2;
/*reverse the leaving and entering variable*/
basicVar[minIndex]=maxIndex;
/*make remaining entries in key column as 0*/
for(i=0;i<conNo;i++)
{
temp=calc[i][maxIndex];
for(j=0;j<varNo+conNo+1;j++)
{
if(i==minIndex || temp==0)
break;
else
{
factor=fabs(temp/calc[minIndex][maxIndex]);
if(temp>0)
calc[i][j]=calc[i][j]-calc[minIndex][j]*factor;
else
calc[i][j]=calc[i][j]+calc[minIndex][j]*factor;
}
}
}
clrscr();
cout<<"Cj--> ";
for(i=0;i<varNo+conNo;i++)
cout<<objFunc[i]<<" ";
cout<<endl;
for (i=0;i<conNo;i++)
{
cout<<" ";
for(j=0;j<varNo+conNo;j++)
cout<<calc[i][j]<<" ";
cout<<endl;
}
cout<<"Ej=sum(Ei.Aij)--> ";
for(j=0;j<varNo+conNo;j++)
cout<<sum[j]<<" ";
cout<<endl;
cout<<"theta=Cj-Ej--> ";
for(j=0;j<varNo+conNo;j++)
cout<<theta[j]<<" ";

getch();
}//end while
}

3.A

Transportation Problem (using Column Minima Method)

#include<stdio.h>
#include<conio.h>

struct
{
int Element;
int Allocated;
int Cancelled;
}Matrix[5][5];
int Jobs,Resources,Demand[5],Capacity[5],Cost=0;

void ShowMatrix(void);
int ExitPrg(void);

void main()
{
int i,j,x=0,y=0,Exit=0;

clrscr();

printf("Total no. of destination : ");
scanf("%d",&Jobs);
printf("Total no. of sources : ");
scanf("%d",&Resources);

printf("Enter elements : \n");
for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
scanf("%d",&Matrix[i][j].Element);

printf("Enter Capacity : ");
for(i=0;i<Resources;i++)
scanf("%d",&Capacity[i]);

printf("Enter Demand : ");
for(j=0;j<Jobs;j++)
scanf("%d",&Demand[j]);

for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
{
Matrix[i][j].Allocated=0;
Matrix[i][j].Cancelled=0;
}

while(1)
{
ShowMatrix();

Exit=ExitPrg();
if(Exit==0)
{ /* column minimum alogoritham is implemented*/
/* minimum element in column */
for(j=y;j<Jobs;j++)
{
if(Demand[y]==0)
{
x=0;
y=y+1;
continue;
}
for(i=0;i<Resources;i++)
if(Matrix[i][j].Cancelled==0)
{
x=i;
break;
}
for(i=x+1;i<Resources;i++)
if(Matrix[i][j].Element<Matrix[x][y].Element && Matrix[i][j].Cancelled==0)
x=i;

if(Capacity[x]>Demand[y])
{
Matrix[x][y].Allocated=Demand[y];
Capacity[x]=Capacity[x]-Demand[y];
Demand[y]=0;
for(i=0;i<Resources;i++)
Matrix[i][y].Cancelled=1;
}
else
if(Capacity[x]<Demand[y])
{
Matrix[x][y].Allocated=Capacity[x];
Demand[y]=Demand[y]-Capacity[x];
Capacity[x]=0;
for(j=0;j<Jobs;j++)
Matrix[x][j].Cancelled=1;
}
else
{
Matrix[x][y].Allocated=Capacity[x];
Capacity[x]=0;
Demand[y]=0;
for(j=0;j<Jobs;j++)
Matrix[x][j].Cancelled=1;
for(i=0;i<Resources;i++)
Matrix[i][y].Cancelled=1;
}
break;
}
}
else
break;

}

for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Allocated!=0)
Cost=Cost+Matrix[i][j].Element*Matrix[i][j].Allocated;

printf("\n\nCost = %d",Cost);

getch();
}

void ShowMatrix()
{
int i,j;

clrscr();

printf("\n\n\t");

for(j=0;j<Jobs;j++)
printf("\tDest %d",j);

printf("\t\tCapacity\n\n");

for(i=0;i<Resources;i++)
{
printf("source %d",i);

for(j=0;j<Jobs;j++)
if(Matrix[i][j].Allocated!=0)
printf("\t%d (%d)",Matrix[i][j].Element,Matrix[i][j].Allocated);
else
if(Matrix[i][j].Cancelled==1)
printf("\t-");
else
printf("\t%d",Matrix[i][j].Element);

printf("\t\t%d\n\n",Capacity[i]);
}

printf("\nDemand\t");
for(j=0;j<Jobs;j++)
printf("\t%d",Demand[j]);

getch();
}

int ExitPrg()
{
int i,j,Exit=1;

for(i=0;i<Resources;i++)
if(Capacity[i]!=0)
{
Exit=0;
break;
}

if(Exit==1)
for(j=0;j<Jobs;j++)
if(Demand[j]!=0)
{
Exit=0;
break;
}

return(Exit);
}

3.B

Transportation Problem (using Vogel's Approximation Method)

#include<stdio.h>
#include<conio.h>

struct
{
int Element;
int Allocated;
int Cancelled;
}Matrix[5][5];
int Jobs,Resources,Demand[5],Capacity[5],Diff[10],Cost=0;

void ShowMatrix(void);
int ExitPrg(void);

void main()
{
int i,j,R1,R2,J1,J2,G,S,Exit=0,capacity=0,demand=0;
clrscr();
printf("COMPUTER APPLICATIONS IN MECHANICAL ENGG.\n\n");
printf("VOGEL'S APPROXIMATION METHOD \n\n");
printf("SUBMITTED BY:\n\n\t\t");
printf("PATIL PAWAN MADHUKAR\n\n");
printf("GUIDED BY :\n\n\t\t");
printf("PROF. K. V. NEMADE \n");
getch();
clrscr();

printf("Total no. of Jobs maximum 4 : ");
scanf("%d",&Jobs);
if(Jobs>4)
printf("JOBS SHOULD BE AT THE MAX FOUR");
else
{
printf("Total no. of Resources maximum 4 : ");
scanf("%d",&Resources);
if(Resources>4)
printf("RESOURCES SHOULD BE AT THE MAX FOUR");
else
{
printf("Enter elements : \n");
for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
scanf("%d",&Matrix[i][j].Element);
printf("Enter Capacity : ");
for(i=0;i<Resources;i++)
{
scanf("%d",&Capacity[i]);
capacity =capacity+Capacity[i];
}
printf("\n capacity %d",capacity);
printf("\n Enter Demand : ");
for(j=0;j<Jobs;j++)
{
scanf("%d",&Demand[j]);
demand = demand+Demand[j];
}
printf("demand %d",demand);
if(demand != capacity)
printf("demands and capacities are not equal");
else
{
for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
{
Matrix[i][j].Allocated=0;
Matrix[i][j].Cancelled=0;
}
while(1)
{
ShowMatrix();
Exit=ExitPrg();
if(Exit==0)
{
for(i=0;i<Resources+Jobs;i++)
Diff[i]=0;
/* Diff between two smaller job values */
for(i=0;i<Resources;i++)
{
if(Capacity[i]==0)
continue;
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Cancelled==0)
{
R1=j;
break;
}
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Element<Matrix[i][R1].Element)
{if(Matrix[i][j].Cancelled==0)
R1=j;}
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Cancelled==0 && j!=R1)
{
R2=j;
break;
}
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Element<Matrix[i][R2].Element)
{if(Matrix[i][j].Cancelled==0 && j!=R1)
R2=j; }
Diff[i]=Matrix[i][R2].Element-Matrix[i][R1].Element;
}

/* Diff between two smaller resources values */
for(j=0;j<Jobs;j++)
{
if(Demand[j]==0)
continue;
for(i=0;i<Resources;i++)
if(Matrix[i][j].Cancelled==0)
{
J1=i;
break;
}
for(i=0;i<Resources;i++)
if(Matrix[i][j].Element<Matrix[J1][j].Element )
{if(Matrix[i][j].Cancelled==0)
J1=i;
}
for(i=0;i<Resources;i++)
if(Matrix[i][j].Cancelled==0 && i!=J1)
{
J2=i;
break;
}
for(i=0;i<Resources;i++)
if(Matrix[i][j].Element<Matrix[J2][j].Element )
{if( Matrix[i][j].Cancelled==0 && i!=J1)
J2=i;
}
Diff[j+Resources]=Matrix[J2][j].Element-Matrix[J1][j].Element;
}
/* Find greater diff value */
for(i=0;i<Resources+Jobs;i++)
if(Diff[i]!=0)
{
G=i;
break;
}
for(i=G+1;i<Resources+Jobs;i++)
if(Diff[i]>Diff[G] && Diff[i]!=0)
G=i;
/* Find smaller element value */
if(G<Resources)
{
for(j=0;j<Jobs;j++)
if(Matrix[G][j].Cancelled==0)
{
S=j;
break;
}
for(j=S+1;j<Jobs;j++)
if(Matrix[G][j].Element<Matrix[G][S].Element)
{if(Matrix[G][j].Cancelled==0)
S=j;
}
}
else
{
for(i=0;i<Resources;i++)
if(Matrix[i][G-Resources].Cancelled==0)
{
S=i;
break;
}
for(i=S+1;i<Resources;i++)
if(Matrix[i][G-Resources].Element<Matrix[S][G-Resources].Element)
{if(Matrix[i][G-Resources].Cancelled==0)
S=i;
}
}
if(G<Resources)
{
if(Capacity[G]>Demand[S])
{
Matrix[G][S].Allocated=Demand[S];
Capacity[G]=Capacity[G]-Demand[S];
Demand[S]=0;
for(i=0;i<Resources;i++)
Matrix[i][S].Cancelled=1;
}
else
if(Capacity[G]<Demand[S])
{
Matrix[G][S].Allocated=Capacity[G];
Demand[S]=Demand[S]-Capacity[G];
Capacity[G]=0;
for(j=0;j<Jobs;j++)
Matrix[G][j].Cancelled=1;
}
else
{
Matrix[G][S].Allocated=Capacity[G];
Capacity[G]=0;
Demand[S]=0;
for(j=0;j<Jobs;j++)
Matrix[G][j].Cancelled=1;
for(i=0;i<Resources;i++)
Matrix[i][S].Cancelled=1;
}
}
else
{
if(Capacity[S]>Demand[G-Resources])
{
Matrix[S][G-Resources].Allocated=Demand[G-Resources];
Capacity[S]=Capacity[S]-Demand[G-Resources];
Demand[G-Resources]=0;
for(i=0;i<Resources;i++)
Matrix[i][G-Resources].Cancelled=1;
}
else
if(Capacity[S]<Demand[G-Resources])
{
Matrix[S][G-Resources].Allocated=Capacity[S];
Demand[G-Resources]=Demand[G-Resources]-Capacity[S];
Capacity[S]=0;
for(j=0;j<Jobs;j++)
Matrix[S][j].Cancelled=1;
}
else
{
Matrix[S][G-Resources].Allocated=Capacity[S];
Capacity[S]=0;
Demand[G-Resources]=0;
for(j=0;j<Jobs;j++)
Matrix[S][j].Cancelled=1;
for(i=0;i<Resources;i++)
Matrix[i][G-Resources].Cancelled=1;
}
}
}
else
break;

} /*for jobs mre than 4*/
} /*for resources more than 4*/
} /*for demand & capacity unequal*/
}
for(i=0;i<Resources;i++)
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Allocated!=0)
Cost=Cost+Matrix[i][j].Element*Matrix[i][j].Allocated;
printf("\n\nCost = %d",Cost);
getch();
}

void ShowMatrix()
{
int i,j;
clrscr();
printf("\n\n\t");
for(j=0;j<Jobs;j++)
printf("\tJob %d",j);
printf("\t\tCapacity\tDiff\n\n");
for(i=0;i<Resources;i++)
{
printf("Resource %d",i);
for(j=0;j<Jobs;j++)
if(Matrix[i][j].Allocated!=0)
printf("\t%d (%d)",Matrix[i][j].Element,Matrix[i][j].Allocated);
else
if(Matrix[i][j].Cancelled==1)
printf("\t-");
else
printf("\t%d",Matrix[i][j].Element);
printf("\t\t%d\t\t%d\n\n",Capacity[i],Diff[i]);
}
printf("\nDemand\t");
for(j=0;j<Jobs;j++)
printf("\t%d",Demand[j]);
printf("\n\nDiff\t");
for(j=Resources;j<Resources+Jobs;j++)
printf("\t%d",Diff[j]);
getch();
}

int ExitPrg()
{
int i,j,Exit=1;
for(i=0;i<Resources;i++)
if(Capacity[i]!=0)
{
Exit=0;
break;
}
if(Exit==1)
for(j=0;j<Jobs;j++)
if(Demand[j]!=0)
{
Exit=0;
break;
}
return(Exit);
}

3.C

Transportation Problem (using NW Rule)

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
int cost,i,j,msizerow,msizecol,matrix[10][10],r=0,c=0,p,supply[10],demand[10];
int value[10][10],max,rpos,cpos,path[25][2],rpre,cpre;
void firstiteration();
void main ( )
{ clrscr( );
for ( i=0;i<10;i++)
for ( j=0;j<10;j++)
value[i][j] = 0;
printf("Enter the Size of the Matrix(Rows): ");
scanf("%d",&msizerow);
printf("Enter the Size of the Matrix(Columns): ");
scanf (d",&msizecol);
printf("Enter Cost Matrix\n");
for(r = 0; r<msizerow; r++)
for(c=0; c<msizecol;c++)
{ printf("Enter %d row %d col: ",r+1,c+1);
scanf("%d",&matrix[r][c]); }
printf("\nEnter the Supply:\n");
for (r=0;r<msizerow;r++)
{ printf("%d: ",r+1);
scanf("%d",&supply[r]); }
printf("\nEnter the Demand:\n");
for (c=0;c<msizecol;c++)
{ printf("%d: ",c+1);
scanf("%d",&demand[c]); }
firstiteration();
getch();
}
void firstiteration()
{ c = 0;r = 0; cost=0;
do
{ if(demand[c]!=0)
{ if (demand[c]<supply[r])
{ value[r][c]=demand[c];
supply[r]-=demand[c];
demand[c]=0;
if(c==msizecol-1) c=0;
else c++;}
else
{ if (demand[c]= =supply[r])
{value[r] [c] =supply[r];
demand[c] = 0;
supply[r]=0;
if(c==msizecol-1) c=0;
else c++;
if(r==msizerow-1) r=0;
else r++; }
else
{ value[r][c]=supply[r];
demand[c]-=supply[r];
supply[r]=0;
if(r==msizerow-1) r=0;
else r++; } } }
else
{ if(c==msizecol-1)
c=0;
else c++; }
} while (demand [msizecol-1]!=0);
printf("\n");
for(r = 0; r<msizerow; r++)
for(c=0; c<msizecol;c++)
printf("Value[%d] [%d] = %d\n",r+1,c+1,value[r][c]);
for(r=0; r<msizerow;r++)
for(c=0; c<msizecol;c++)
cost+=matrix[r][c]*value[r][c];
printf("\nCost = %d\n",cost); }

4.

Job Scheduling Problem

#include<iostream.h>
#include<math.h>
#include<conio.h>
#include<stdio.h>
#include<string.h>
#define mmax 2 //no of machines
#define jmax 4 //no of jobs
void main()
{
struct job // structure for job details
{
int marked,value[mmax] /*time req on both machines */,mno;
}
j[jmax];
int m-0,sum,l,min,i,k,temp[jmax],mac[mmax][jmax],n=0;

clrscr();
for(i=0;i<jmax;i++)
{
j[i].marked=0;
for(k=0;k<mmax;k++)
mac[k][i]=0;
}
cout<<"Enter the Array:\n";
for(i=0;i<jmax;i++)
{
cout<<"\n"<<"job"<<i+1<<"\n";
for(k=o;k<mmax;k++)
{
cin>>j[i].value[k];
}
}
min=j[0].value[0];
for(l=0;l<jmax;l++)
{
for(i=0;i<jmax;i++)//check for the min time job and delete the row
{
for(k=0;k<mmax;k++)
{
min=j[i].value[k];
}
}
}
for(i=0;i<jmax;i++)
{
for(k=0;k<mmax;k++)
{
if(min==j[i].value[k]&&j[i].marked!=1)
{
j[i].marked=1;
mac[k][n++]=i+1; //enter the sequenced job in array
temp[m++]=i+1;
cout<<i<<" "<<k;
}
}
}
for(i=0;i<jmax;i++)
if(j[i].marked!=1)
min=j[i].value[0];
}
m=0;
for(i=0;i<mmax-1;i++)
{
for(k=0;k<jmax;k++)
{
if(mac[i][k]>0)
{
temp[m++]=mac[i][k];
}
}
}
for(i=1;i<mmax;i++) //invert the seq array
{
for(k=jmax-1;k>=0;k--)
{
if(mac[i][k]!=0)
temp[m++]=mac[i][k];
}
}
for(i=0;i<mmax;i++) //printing of output
{
cout<<"\n Machine "<<i+1<<">>";
for(k=0;k<jmax;k++)
cout<<" "<<mac[i][k];
}
sum=0;
for(i=0;i<jamx;i++)
cout<<"\n"<<temp[i];
m=0;
for(i=0;i<jmax;i++)
{
printf("\n %3d",sum);
sum=sum+j[temp[i]-1].value[0];
printf("%3d",sum);
if(m<sum)
m=sum;
printf("%3d",m);

m=m+j[temp[i]-1].value[1];
printf("%3d",m);
}
/*cout<<"\n\n";
sum=0;
for(i=o;i<jmax;i++)
{
printf("\n%3d",sum);
sum=sum+j[temp[i]-1].value[1];
cout<<" "<<sum;
}*/
getch();
}

Previous << Home >> Next