Geum.ru

Методические указания и примеры выполнения задания №6 " Моделирование процессов принятия решений"

Вид материалаМетодические указания

Содержание


ЦЕЛЬ: Выбрать спортсмена для эстафеты по его личныл характеристикам. ОГРАНИЧЕНИЯ
ТИП: Исходный текст программы ( Реализовано на С++ )
Подобный материал:
1   2   3   4   5   6   7   8   9   10

ЦЕЛЬ: Выбрать спортсмена для эстафеты по его личныл характеристикам.

ОГРАНИЧЕНИЯ:

АЛЬТЕРНАТИВЫ:

ТИП:


Исходный текст программы ( Реализовано на С++ ):


//--------------------------------------------------------------------------

#include

#include

#include

#include

#include

//--------------------------------------------------------------------------


int PRes[3]={0,0,0};

int PDir[3]={0,0,0};

double M[100];

double mx,dx,sx,kg,pp;

int Ready=80;

int MinAge=18, MaxAge=35;

int MinInterrupt=1, MaxInterrupt=31;

int knowlege;

int kn;

int Number,Num,UnReady;

int P[3];

int Result[100][2];

double win[3][3];

double Risk[3][3];

double K[3][3]={{0.95,0.85,0.13},

{0.09,0.93,0.95},

{0.10,0.14,0.90}};

//--------------------------------------------------------------------------

void About()

{

clrscr();

cout<<" "<
cout<<" Лабораторная работа №6 "<
cout<<" по моделированию "<
cout<<" Тема : "<
cout<<" Моделирование процессов принятия решений "<
cout<<" "<
cout<<" Выполнила:студентка гр.ЭВМд-31 "<
cout<<" Батанова В.А. "<
cout<<"Цель : какого спортсмена(замена) поставить в "<
cout<<" эстафету на Олимпийских играх 2000г. "<
cout<<"Ограничения :-специализация спортсмена "<
cout<<" -подготовка спортсмена "<
cout<<"Альтернативы: "<
cout<<" - спринтер(короткий спринт-100,200) "<
cout<<" - спринтер2(длинный спринт-200,400) "<
cout<<" - стайер (400,800) "<
cout<<" Тип "<
cout<<" - однокритериальная "<
cout<<" - в условиях неопределенности "<
cout<<" - статическая "<
cout<<" "<
cout<<" Для продолжения - 'Enter' "<
getch();

}

//--------------------------------------------------------------------------

void WinMatrice()

{

gotoxy(1,1); cout<<" Матрица выигрышей :";

gotoxy(2,2); cout<<" 4*100м 4*200м 4*400м ";

gotoxy(1,4); cout<<"Спринтер";

gotoxy(1,5); cout<<"Спринтер2";

gotoxy(1,6); cout<<"Стайер ";


for (int i=0;i<3;i++)

for (int j=0;j<3;j++)

{gotoxy(12+12*j,4+i);

cout<
}

cout<
}

//--------------------------------------------------------------------------

void RiskMatrice()

{

gotoxy(2,10); cout<<" Матрица рисков :";

for (int i=0;i<3;i++)

for (int j=0;j<3;j++)

{

gotoxy(12+12*j,12+i);

cout<
}

cout<
}

//--------------------------------------------------------------------------

int ReadKey()

{

int key;

gotoxy(1,23);

cout<<"Продолжение-'Enter',выход-'Esc'";

key=getch();

return key;

}

//--------------------------------------------------------------------------

void GenerateP()

{int points[3];

int temp;

for (int i=0;i<3;i++)

points[i]=random(100)+1;

for (i=0;i<3;i++)

for (int j=0;j<2;j++)

if (points[j+1]

{temp=points[j+1];

points[j+1]=points[j];

points[j]=temp;

}

int s=0;

for (i=0;i<3;i++)

{

P[i]=points[i]-s;

s=P[i]+s;

}

P[3]=100-s;


}

//--------------------------------------------------------------------------

void MakeWinMatrice()

{

GenerateP();

for (int i=0;i<3;i++)

for (int j=0;j<3;j++)

win[i][j]=((double)(P[j]))*K[i][j];

for (i=0;i<4;i++)

{double age=(double)(MinAge+random(MaxAge-MinAge));

double expirience;

if (age<30) expirience=age*0.4;

else expirience=(40-age)*0.5;

for (int j=0;j<0;j++)

win[i][j]=win[i][j]+expirience;

}

}

//--------------------------------------------------------------------------

int finddirec()

{

int max,Index;

max=P[0];Index=0;

for (int i=0;i<3;i++)

if (P[i]>max) { max=P[i]; Index=i; };

return Index+1;

}

//--------------------------------------------------------------------------

int FindOptimum()

{

int Cmp1,Cmp2;

int ind;

double max[3];

double min;

for (int j=0;j<3;j++)

{ max[j]=win[0][j];

for (int i=0;i<3;i++)

if (win[i][j]>max[j]) max[j]=win[i][j];

}

for (j=0;j<3;j++)

for (int i=0;i<3;i++)

Risk[i][j]=max[j]-win[i][j];

for (int i=0;i<3;i++)

{ max[i]=Risk[i][0];

for (int j=0;j<3;j++)

if (Risk[i][j]>max[i]) max[i]=Risk[i][j];

}

min=max[0]; ind=0;

for (i=0;i<3;i++)

if (max[i]
M[Num]=min;

if (knowlege>=40)

{int ZRisk[3];

int NumberOfZero;

int MinSumIndex;

NumberOfZero=0;

int dir=finddirec()-1;

for (int i=0;i<3;i++)

if (Risk[i][dir]<0.1)

{ZRisk[NumberOfZero]=i;

NumberOfZero++;

}

if (NumberOfZero>1)

{int MinRiskIndex=ZRisk[0];

double sum=0;

for (int i=0;i<3;i++)

sum=sum+Risk[ZRisk[0]][i];

double sum1;

for (i=0;i
{sum1=0;

for (int j=0;j<3;j++)

sum1=sum1+Risk[ZRisk[i]][j];

if (sum
{sum=sum1;

MinRiskIndex=ZRisk[i];

}

}

ind=MinSumIndex;

}

if (NumberOfZero==1) ind=ZRisk[0];

}

//--------------------------------------------

return ind+1;

}

//--------------------------------------------------------------------------

double FindM()

{

double m;

double pi;

int cmp;

m=0;

for (int i=0;i
{pi=0;

cmp=(int)(M[i]*100);

for (int j=0;j<10000;j++)

if (cmp==j) pi=pi+1/((double)(Num));

m=m+M[i]*pi;

}

return m;

}

//--------------------------------------------------------------------------

double FindD()

{

double d;

double pi;

int cmp;

d=0;

for (int i=0;i
{pi=0;

cmp=(int)(M[i]*100);

for (int j=0;j<10000;j++)

if (cmp==j) pi=pi+1/((double)(Num));

d=d+(M[i]-mx)*(M[i]-mx)*pi;

}

return d;

}

//--------------------------------------------------------------------------

void WriteToFile()

{

ofstream fout("Komanda.txt");

fout<<"Результаты моделирования : "<
fout<<"Количество проведенных опытов "<
fout<<"Результаты :"<
for (int i=0;i
{ fout<<"Преимущественное направление "<
switch(Result[i][0]){

case 1:fout<<"- 4*100м"<
case 2:fout<<"- 4*200м"<
case 3:fout<<"- 4*400"<
}

fout<<"Будет взят спортсмен - ";

switch(Result[i][1]){

case 1:fout<<"спринтер(короткий спринт)"<
case 2:fout<<"спринтер2(дальний спринт)"<
case 3:fout<<"стайер"<
}

fout<
}

fout<<"Расчетный коэффициэнт готовности 0.80"<
double q=((double)(Num-UnReady))/((double)(Num));

fout<<"Реальный коэффициэнт готовности "<
kg=q;

pp=((double)kn)/((double)Num);

fout<<"Процент попадания "<

q=((double)(PRes[0]))/((double)(Num));

fout<<"Вероятность взятия"<
fout<<"- спринтера "<
q=((double)(PRes[1]))/((double)(Num));

fout<<"- спринтера2 "<
q=((double)(PRes[2]))/((double)(Num));

fout<<"- стайера "<
fout<<"Вероятность преимущественного "<
fout<<"вида эстафеты "<
q=((double)(PDir[0]))/((double)(Num));

fout<<"- 4*100м "<
q=((double)(PDir[1]))/((double)(Num));

fout<<"- 4*200м "<
q=((double)(PDir[3]))/((double)(Num));

fout<<"- 4*400м "<
mx=FindM();

fout<<"Mатематическое ожидание Fopt "<
dx=FindD();

fout<<"Дисперсия Fopt "<
sx=sqrt(dx);

fout<<"Среднеквадратическое отклонение Fopt "<
fout.close();

}

//--------------------------------------------------------------------------

void main()

{

char path[12];

About();

clrscr();

cout<<" Отчет о спортсменах будет помещен"<
cout<<" в файл 'Komanda.txt' текущего каталога "<
cout<<"Продолжение 'Enter'"<
getch();

int key;

int r;

randomize();

knowlege=0;

kn=0;

Num=0;

UnReady=0;

do

{

clrscr();

r=random(100)+1;

if (r<=Ready)

{

MakeWinMatrice();

WinMatrice();

int Res=FindOptimum();

int Dir=finddirec();

Result[Num][0]=Dir;

Result[Num][1]=Res;

PRes[Res-1]=PRes[Res-1]+1;

PDir[Dir-1]=PDir[Dir-1]+1;

Num++;

RiskMatrice();

cout<
cout<<"Преимущественный вид эстафеты :"<
switch(Dir){

case 1:cout<<"- 4*100м "<
case 2:cout<<"- 4*200м "<
case 3:cout<<"- 4*400м "<
}

cout<<"Будет взят спортсмен - ";

switch(Res){

case 1:cout<<" спринтер(короткий спринт) "<
case 2:cout<<" спринтер2(дальний спринт) "<
case 3:cout<<" стайер "<
}

gotoxy(60,2); cout<<"Испытание №"<
if (Dir==1&&Res==1) kn++;

if (Dir==2&&Res==4) kn++;

if (Dir==3&&Res==3) kn++;

if ((Dir==1&&Res==1)||

(Dir==2&&Res==4)||

(Dir==3&&Res==3))

knowlege=knowlege+2;

else knowlege--;

if (knowlege<0) knowlege=1;

if (knowlege>100) knowlege=knowlege-2;

}

else

{

UnReady++;

clrscr();

cout<<"Тренер не готов решить задачу"<
}

key=ReadKey();

}

while(key!=27&&Num<100);

WriteToFile();

getch();

}

//--------------------------------------------------------------------------


Модель процесса составления расписания уроков.


ЦЕЛЬ: Составить оптимальное расписание уроков.

ОГРАНИЧЕНИЯ:

АЛЬТЕРНАТИВЫ:

ТИП:


Исходный текст программы ( Реализовано на С++ ):


#include

#include

#include

#include


const int maxinfo=100;

float info[5];

int kol_ur;

float sr[6];

// структура об учителе

struct uch {

char pred[40]; // предмет

int vozrast; // возраст учителя (опыт)

int stazh; // стаж работы (опыт преподавания)

int gotov; // готовность к уроку (%) (min 10%, зависит от различных факторов)

int otnosh; // отношение учителя к данному классу (по 5-й шкале)

float sred;

};

struct uch a[6];


void main()

{

window(1,1,80,25);

textbackground(0);

textcolor(15);

clrscr();

printf(" Лабораторная работа №6\n");

printf(" по дисциплине \"Моделирование\"\n");

printf(" выполнил студент группы ЭВМд-32 Власов И.В.\n");

printf(" руководитель Куцоконь Н.С.\n");

printf(" \n");

printf(" Задача: смоделировать человека-оператора принимающего решение.\n");

printf(" Постановка задачи: составить расписание уроков на неделю для \n");

printf(" одного класса, с учетом готовности учителя преподать максималь-\n");

printf(" ное количество информации в данный момент. \n");

printf(" Цель: получение учениками максимального количества информации.\n");

printf(" Тип задачи: однокритериальная,динамическая. \n");

printf(" \n");

printf(" Результаты программы будут занесены в файл joy6.dat. \n");

getch();


strcpy(a[0].pred," учитель физики ");

strcpy(a[1].pred," учитель математики ");

strcpy(a[2].pred," учитель литературы ");

strcpy(a[3].pred," учитель рус. языка ");

strcpy(a[4].pred," учитель ин. языка ");

strcpy(a[5].pred," учитель химии ");


randomize();

a[0].vozrast = random(31)+25;

do {

a[0].stazh = random(31)+25;

}

while(a[0].stazh>=a[0].vozrast);

a[1].vozrast = random(31)+25;

do {

a[1].stazh = random(31)+25;

}

while(a[1].stazh>=a[1].vozrast);

a[2].vozrast = random(31)+25;

do {

a[2].stazh = random(31)+25;

}

while(a[2].stazh>=a[2].vozrast);

a[3].vozrast = random(31)+25;

do {

a[3].stazh = random(31)+25;

}

while(a[3].stazh>=a[3].vozrast);

a[4].vozrast = random(31)+25;

do {

a[4].stazh = random(31)+25;

}

while(a[4].stazh>=a[4].vozrast);

a[5].vozrast = random(31)+25;

do {

a[5].stazh = random(31)+25;

}

while(a[5].stazh>=a[5].vozrast);


FILE *f;

f = fopen("joy6.dat","w");


for(int n=0;n<5;n++)

{

switch(n) {

case 0: fprintf(f,"\n Понедельник \n"); break;

case 1: fprintf(f,"\n Вторник \n"); break;

case 2: fprintf(f,"\n Среда \n"); break;

case 3: fprintf(f,"\n Четверг \n"); break;

case 4: fprintf(f,"\n Пятница \n");break;

}


clrscr();

for(int j=0;j<6;j++)

{

clrscr();

fprintf(f,"--------------------------------------------------------\n");


fprintf(f," %s \n",a[j].pred);


a[j].gotov = random(91)+10;

a[j].otnosh = random(5)+1;


info[0] = maxinfo * a[j].vozrast/55;

fprintf(f," %f - процент информации; %d - возраст (в годах)\n",info[0],a[j].vozrast);

info[1] = maxinfo * (a[j].vozrast-a[j].stazh)/(a[j].vozrast-25);

fprintf(f," %f - процент информации; %d - стаж работы (в годах)\n",info[1],a[j].vozrast-a[j].stazh);

info[2] = maxinfo * a[j].gotov/100;

fprintf(f," %f - процент информации; %d - готовность к уроку(в процентах)\n",info[2],a[j].gotov);

info[3] = maxinfo * a[j].otnosh/5;

fprintf(f," %f - процент информации; %d - отношение учителя к классу (по 5-й шкале)\n",info[3],a[j].otnosh);

a[j].sred=0;

for(int i=0;i<4;i++)

a[j].sred=a[j].sred+info[i];

a[j].sred=a[j].sred/4;

fprintf(f,"\n %f \n",a[j].sred);

}

fprintf(f,"--------------------------------------------------------\n");


switch(n) {

case 0: printf(" Понедельник \n");

fprintf(f," Понедельник \n"); break;

case 1: printf(" Вторник \n");

fprintf(f," Вторник \n"); break;

case 2: printf(" Среда \n");

fprintf(f," Среда \n"); break;

case 3: printf(" Четверг \n");

fprintf(f," Четверг \n"); break;

case 4: printf(" Пятница \n");

fprintf(f," Пятница \n");break;

}


for(j=0;j<6;j++)

{

sr[j] = a[j].sred;

}

int k;

for(j=0;j<6;j++)

{

float min;

for(int i=0;i<6;i++)

{

if(sr[i]!=0) { min=sr[i]; k=i;break;}

}

for(i=0;i<6;i++)

{

if(min>sr[i] && sr[i]!=0)

{

min = sr[i];

k=i;

}

}

sr[k]=0;

for(i=0;i<6;i++)

{

if(min==a[i].sred)

{

printf(" %d-й урок - %f процентов - %s\n",j+1,min,a[i].pred);

fprintf(f," %d-й урок - %f процентов - %s\n",j+1,min,a[i].pred);

}

}

}

fprintf(f,"--------------------------------------------------------\n");

getch();

}

}


Выбор экономичного пути на заданном рельефе.


ЦЕЛЬ: Выбор наиболее экономичного пути в зависемости от рельефа заданной местности.

ОГРАНИЧЕНИЯ:

АЛЬТЕРНАТИВЫ:

ТИП:


Исходный текст программы ( Реализовано на С++ ):


#include "States.h"

#include

#include

//Коды направлений

#define Left 1

#define Right 2

#define Up 3

#define Down 4


TState::TState(int x1, int x2, int x3, int x4, int x5,int x6)

{

X=x1;

Y=x2;

XOld=x3;

YOld=x4;

Price=x5;

H=x6;

}


bool operator==(const TState & st1,const TState & st2)

{

return (st1.X == st2.X)&&(st1.Y == st2.Y);

}


int TState::Cena (int step){

switch (step){

case 0:return 1;

case 1:return 2;

case 2:return 4;

case 3:return 6;

case 4:return 8;

case -1:return 3;

case -2:return 5;

case -3:return 7;

default:return 9;

}

}


int TState::PriceStep (int Direction){

int Price=0;

switch (Direction){

case 1:if (abs(Board[X-1][Y]-Board[X][Y])>4)return Price=0;

Price=Cena (Board[X][Y]-Board[X-1][Y]);

break;

case 2:if (abs(Board[X+1][Y]-Board[X][Y])>4)return Price=0;

Price=Cena (Board[X][Y]-Board[X+1][Y]);

break;

case 3:if (abs(Board[X][Y-1]-Board[X][Y])>4)return Price=0;

Price=Cena (Board[X][Y]-Board[X][Y-1]);

break;

case 4:if (abs(Board[X][Y+1]-Board[X][Y])>4)return Price=0;

Price=Cena (Board[X][Y]-Board[X][Y+1]);

break;

}

return Price;

}


int TState::NumChildren()

{

int num=0;

if((X-1>=0) && PriceStep(Left)!=0) num++;

if((X+1<10) && PriceStep(Right)!=0) num++;

if((Y-1>=0) && PriceStep(Up)!=0) num++;

if((Y+1<10) && PriceStep(Down)!=0) num++;

return num;

}


TState TState::ChildState(int ind)

{

int num=0;


if((X-1>=0) && PriceStep(Left)!=0) num++;

if(num==ind) return TState(X-1,Y,X,Y,Price+PriceStep(Left),

abs((XEnd-(X-1))+(YEnd-Y))*5);


if((X+1<10) && PriceStep(Right)!=0) num++;

if(num==ind) return TState(X+1,Y,X,Y,Price+PriceStep(Right),

abs((XEnd-(X+1))+(YEnd-Y))*5);


if((Y-1>=0) && PriceStep(Up)!=0) num++;

if(num==ind) return TState(X,Y-1,X,Y,Price+PriceStep(Up),

abs((XEnd-X)+(YEnd-(Y-1)))*5);


if((Y+1<10) && PriceStep(Down)!=0) num++;

if(num==ind) return TState(X,Y+1,X,Y,Price+PriceStep(Down),

abs((XEnd-X)+(YEnd-(Y+1)))*5);


return TState();

}


Модель задачи коммивояжёра.