Geum.ru

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

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

Содержание


Цель: ограничения
Подобный материал:
1   2   3   4   5   6   7   8   9   10

ЦЕЛЬ:

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

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

ТИП:


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


#include

#include

#include

#include

#include


void main()

{ clrscr();

int kol; //Сумма котрой располагает человек

int dor; //дорога

int mass2[5][2]={{3,4},{1,4},{1,2},{1,0},{1,0}};//Массив дорог

int mass1[5]={15200,13670,19893,10574,15611};//Массив стоимости компьютера в фирмах

int mass3[5]={10,7,14,7,10};//Массив срок поставки компьютера

int mass4[5]={12,12,0,6,0};//Массив гарантий на товар

int i,ind;

int j=0;

int k=0;

int good; //Удача

int fortuna; //Фортуна

int v[5]={0,0,0,0,0}; //Общее время покупки компьютера

int rez[5]; //Номера фирм

FILE *f;

f = fopen("c:\\lab6.out", "wt");

randomize();

kol=10000+(1+random(9))*1000;

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

{if(mass1[i]
if ((j==1)&&(k==0)) {ind=i;k=1;}}

if (j==1) {cout<<"Компьютер нужно покупать в ";

switch (ind)

{

case 0:cout<<"Элкоме";break;

case 1:cout<<"Симбирск М+";break;

case 2:cout<<"Аксиоме";break;

case 3:cout<<"Ретро";break;

case 4:cout<<"Computers";break;

}

exit(1);

}

if(j==5)

{cout<<"\nCуммы не хватает на покупку\n";

exit(1);}

else cout<<"\nCумма - "<

/* Формирование дороги

Приоритеты:

трамвай+пешком - 50%

пешком - 13%

трамвай - 12%

автобус+пешком - 25%

*/

dor=1+random(99);

if (dor<50) dor=1;

else if ((dor>=50)&&(dor<63)) dor=2;

else if ((dor>=63)&&(dor<75)) dor=3;

else dor=4;

cout<<"\nДорога для человек определяется так :";

switch (dor)

{

case 1:cout<<"поедет на трамвае и пойдет пешком";break;

case 2:cout<<"пойдет пешком";break;

case 3:cout<<"поедет на трамвае";break;

case 4:cout<<"поедет на автобусе и пойдет пешком";break;

}

if (dor==2) {cout<<"\nКомпьютер нужно покупать в Аксиоме\n";exit(1);}

if (dor==3) {cout<<"\nКомпьютер нужно покупать в Элкоме\n";exit(1);}


/* Удача

Приоритеты:

1 - прочитал объявление

2 - потерял прайс

3 - не то и не другое

*/

good=1+random(2);

cout<<"\n Удача: ";

switch (good)

{

case 1:cout<<"прочитал объявление";break;

case 2:cout<<"потерял прайс";break;

case 3:cout<<"изменений нет";break;

}


/* Фортуна

Приоритеты:

1 - курс $ повысился

2 - курс $ понизился

3 - остался без изменений

*/

fortuna=1+random(2);

cout<<"\n Фортуна :";

switch (fortuna)

{

case 1:cout<<"курс $ повысился";break;

case 2:cout<<"курс $ упал ";break;

case 3:cout<<"изменений нет";break;

}


/* Средняя цена компьютера

mass1 - Первоначальная цена

mass1=mass1+50 - курс $ повысился

mass1=mass1-60 - курс $ упал

*/

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

if (fortuna!=3)

if (fortuna==1) mass1[i]=mass1[i]+50;

else mass1[i]=mass1[i]-60;


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

{if(mass1[i]
if ((j==1)&&(k==0)) {ind=i;k=1;}}

if (j==1) {cout<<"\nКомпьютер нужно покупать в ";

switch (ind)

{

case 0:cout<<"Элкоме";break;

case 1:cout<<"Симбирск М+";break;

case 2:cout<<"Аксиоме";break;

case 3:cout<<"Ретро";break;

case 4:cout<<"Computers";break;

}

exit(1);

}

if(j==5)

{cout<<"\nCуммы не хватает на покупку\n";

exit(1);}

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

cout<<"\nОкончательная цена компьютеров - "<
// Выбор фирм которые подходят по стоимости

j=0;

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

if(mass1[i]

/* Среднее время покупки компьютера (не более 15 дней)

v=v+mass3 - поставка компьютера в фирму

v=v-2 - прочитал объявление

v=v+3 - потерял прайс

*/


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

{ v[i]=mass3[i];

if (good!=3)

if (good==1) v[i]=v[i]-2;

else v[i]=v[i]+3;

}

cout<<"\n Среднее время покупки компьютера в каждой фирме:\n";

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

{ cout<
cout<<" ";}


// Принятие решения

if (j<1) cout<<"Фирмы не подходят по характеристикам";

i=0;

while(i
if (v[rez[i]]>15)

{for(int d=i;d
rez[d]=rez[d+1];

j--;}

else i++;

if (j<1) cout<<"Фирмы не подходят по характеристикам";


i=0;

while(i
if (mass4[rez[i]]<1)

{for(int d=i;d
rez[d]=rez[d+1];

j--;}

else i++;

if (j<1) cout<<"Фирмы не подходят по характеристикам";


for(i=0;i
for(int a=0;a<2;a++)

{if (mass2[rez[i]][a]==dor)

{cout<<"\nРезультат - фирма найдена - это ";

switch (rez[i])

{

case 0:cout<<"Элком";break;

case 1:cout<<"Симбирск М+";break;

case 2:cout<<"Аксиома";break;

case 3:cout<<"Ретро";break;

case 4:cout<<"Computers";break;

}


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

fprintf(f,"| Фирма | Цена | Гарантия | Срок |\n");

fprintf(f,"| | компьютера | на покупку | поставки |\n");

fprintf(f,"|(название) | (рубли) | (месяцы) | (дни) |\n");

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

fprintf(f,"| Элком | 15200 | 12 | 10 |\n");

fprintf(f,"|Симбирск М+| 13670 | 12 | 7 |\n");

fprintf(f,"| Аксиома | 19893 | 0 | 14 |\n");

fprintf(f,"| Ретро | 10574 | 6 | 7 |\n");

fprintf(f,"| Computers | 15611 | 0 | 10 |\n");

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


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

fprintf(f,"| Фирма | |\n");

fprintf(f,"| | Как добраться до фирмы |\n");

fprintf(f,"|(название) | |\n");

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

fprintf(f,"| Элком | трамвай, автобус+пешком |\n");

fprintf(f,"|Симбирск М+| трамвай+пешком,автобус+пешком |\n");

fprintf(f,"| Аксиома | трамвай+пешком, пешком |\n");

fprintf(f,"| Ретро | трамвай+пешком |\n");

fprintf(f,"| Computers | трамвай+пешком |\n");

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


fprintf(f,"Фирма, которую выбрал человек - ");

switch (rez[i])

{

case 0:fprintf(f,"Элком\n");break;

case 1:fprintf(f,"Симбирск М+\n");break;

case 2:fprintf(f,"Аксиома\n");break;

case 3:fprintf(f,"Ретро\n");break;

case 4:fprintf(f,"Computers\n");break;

}


fprintf(f,"Сумма, которой располагает человек - %2d\n",kol);


fprintf(f,"Фортуна - ");

switch (fortuna)

{

case 1:fprintf(f,"курс $ повысился (+50 р)\n");break;

case 2:fprintf(f,"курс $ упал (-60 р)\n");break;

case 3:fprintf(f,"изменений нет\n");break;

}

fprintf(f,"Цена компьютера в этой фирме - %2d\n",mass1[rez[i]]);

fprintf(f,"Удача у человека - ");

switch (good)

{

case 1:fprintf(f,"прочитал объявление( -2 дня)\n");break;

case 2:fprintf(f,"потерял прайс (+3 дня)\n");break;

case 3:fprintf(f,"изменений нет\n");break;

}


fprintf(f,"Время необходимое для покупки -%2d дней\n",v[rez[i]]);

fprintf(f,"Дорога по которой отправится человек - ");

switch (dor)

{

case 1:fprintf(f,"поедет на трамвае и пойдет пешком\n");break;

case 2:fprintf(f,"пойдет пешком\n");break;

case 3:fprintf(f,"поедет на трамвае\n");break;

case 4:fprintf(f,"поедет на автобусе и пойдет пешком\n");break;

}


exit(1);}}


fclose(f);

getch();

}


Моделирование задачи автодиллера.


ЦЕЛЬ:

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

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

ТИП:


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


K[1][0]=0.1;K[1][1]=0.15;K[1][2]=0.15;K[1][3]=0.1;

K[2][0]=0.1;K[2][1]=0.2;K[2][2]=0.95;K[2][3]=0.1;

K[3][0]=0.1;K[3][1]=0.95;K[3][2]=0.3;K[3][3]=0.1;

}

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


void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)

{

SaveToFile();

ViewGraph();

Dr->ShowModal();

if (MessageDlg("Результаты записаны в файл res.txt.\n"

"Желаете просмотреть его сейчас?",mtInformation,TMsgDlgButtons()

<< mbYes<
{

ViewRes->Res->Lines->LoadFromFile("res.txt");

ViewRes->ShowModal();

}

}

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


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


ЦЕЛЬ:

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

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

ТИП:


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


#include

#include

#include

#include

#include


int arr[20][20]={{5,1,5,1,2}, // матрица оценки подъёмов

{5,5,5,3,1},

{1,5,5,3,1},

{2,1,2,1,3},

{3,3,3,1,5}}

,arr2[20][20];

int num=5

,cash;

int x1,y1,x2,y2;

// Информация, возникающая в голове человека при оценке его

// дальнейшего пути

struct item2{

int x,y; // Текущее местоположение

int x2,y2; // Рассматриваемое (следующее)

int cas, // Оценка затраты сил на преодаление пути

sum; // Стоимость прихода в новую точку от начала

};

struct item{

item2 mem;

item *next;

};

class list{

item *SO;

item *SC;

public:

list(){ SO=SC=NULL; }

void AddOpen(item2 &s);

int AddClose();

friend void OpenCS(list &);

void FindWay();

};

void OpenCS(list &l)

{

item *go=l.SC;

item2 *New;

int way,way2;

while(go->next) go=go->next;

if((go->mem.x+1)
New = new item2;

New->x2=go->mem.x;

New->y2=go->mem.y;

New->y=go->mem.y;

New->x=go->mem.x+1;

way=way2=0;

// Вычисление оценки крутизны спуска или подъёма

way=arr[New->y][New->x]-arr[New->y2][New->x2];

way=(way<0)?1:(2+way*2);

// Оценка пути, предстоящего пройти до финиша

if((New->x)x; else

way2=New->x-x2;

if((New->y)y; else

way2=way2+New->y-y2;

New->cas=way;New->sum=way2+way;

if(way<10)l.AddOpen(*New);

}

if((go->mem.x-1)>=0){ // Смотрим слева

New = new item2;

New->x2=go->mem.x;

New->y2=go->mem.y;

New->x=go->mem.x-1;

New->y=go->mem.y;

way=way2=0;

way=arr[New->y][New->x]-arr[New->y2][New->x2];

way=(way<0)?1:(2+way*2);

if((New->x)x; else

way2=New->x-x2;

if((New->y)y; else

way2=way2+New->y-y2;

New->cas=way; New->sum=way+way2;

if(way<10) l.AddOpen(*New);

}

if((go->mem.y+1)
New = new item2;

New->sum=0; New->cas=0;

New->x2=go->mem.x;

New->y2=go->mem.y;

New->x=go->mem.x;

New->y=go->mem.y+1;

way=way2=0;

way=arr[New->y][New->x]-arr[New->y2][New->x2];

way=(way<0)?1:(2+way*2);

if((New->x)x; else

way2=New->x-x2;

if((New->y)y; else

way2=way2+New->y-y2;

New->cas=way; New->sum=way + way2;

if(way<10) l.AddOpen(*New);

}

if((go->mem.y-1)>=0){ // Смотрим вверху

New = new item2;

New->x2=go->mem.x;

New->y2=go->mem.y;

New->x=go->mem.x;

New->y=go->mem.y-1;

way=way2=0;

way=arr[New->y][New->x]-arr[New->y2][New->x2];

way=(way<0)?1:(2+way*2);

if((New->x)x; else

way2=New->x-x2;

if((New->y)y; else

way2=way2+New->y-y2;

New->cas=way; New->sum=way+way2;

if(way<10) l.AddOpen(*New);

}

}

void list::AddOpen(item2 &s)

{

int flag=0;

item *find = SC;

if(find)

while(find){

if(find->mem.x==s.x && find->mem.y == s.y)

flag=1;

find=find->next;

}

if(!flag){

item *go = new item;

go->mem.x=s.x;

go->mem.y=s.y;

go->mem.x2=s.x2;

go->mem.y2=s.y2; go->mem.sum=s.sum;

go->mem.cas=s.cas;

go->next=SO;

SO=go;

}

}

int list::AddClose()

{

item *go = SC;

item *find = SO;

int i=0,sum=9999,j=0;

if(!find) {

cout << "Путь не найден !" ;

exit(0);

}

if(find){

sum=find->mem.sum;

while(find){

if((find->mem.sum)
sum=find->mem.sum;

i=j;

}

find=find->next;

j++;

}

}

find=SO; j=0;

if(find && i)

for(j=0; j<(i-1) || (!find); j++)

find=find->next;

if(!i){

if(!SC){

SC=SO ;

SO=SO->next;

SC->next=NULL;

} else {

while (go->next) go=go->next;

go->next=SO;

SO=SO->next;

go->next->next=NULL;

}

} else

if(SC){

while (go->next) go=go->next;

go->next=find->next;

if (find->next->next) find->next=find->next->next;

else find->next=NULL;

go->next->next=NULL;

} else

if(find) {

SC=SO ;

SO=NULL;

SC->next=NULL;

} else return -1;

go=SC;

while(go){

randomize();

float ust=(random(99)+1)/10;

int err=random(99)+1;

int err2=random(99)+1;

div_t x = div(err,10);

div_t y = div(err2,10);

// if(go->mem.x==3) x.rem = 0;

if(go->mem.cas>30 && ust>4.3)

{

cout << "Лыжник доедет до пункта (" << go->mem.x << ":"

<< go->mem.y << ") а дальше ехать у него не хватит сил\n";

x2=go->mem.x;

y2=go->mem.y;

return 1;

}


if(!y.rem) {

cout << "Лыжник доехал до пункта (" << go->mem.x << ":"

<< go->mem.y << ") и у него сломались лыжи\n";

x2=go->mem.x;

y2=go->mem.y;

return 1;

}


if(!x.rem) {

cout << "Лыжник доехал до пункта (" << go->mem.x << ":"

<< go->mem.y << ") и у него кончились запасы продовольствия\n";

x2=go->mem.x;

y2=go->mem.y;

return 1;

}

if(go->mem.x == x2 && go->mem.y == y2 ) return 1;

go=go->next;

}

return 0;

}

void list::FindWay()

{

item *go=SC;

int x,y,sum=0,f,l=0;

int arrx[20],arry[20];

cout << " (" << x2 << "," << y2 << ") ";

arrx[l]=x2;arry[l]=y2; l++;

while((go->mem.x!=x2) || (go->mem.y != y2))

go=go->next;

while((go->mem.x2 != x1) || (go->mem.y2 != y1))

{

x=go->mem.x2; y=go->mem.y2;

cout << " (" << x << "," << y << ") ";

sum=sum+go->mem.sum;

arrx[l]=x;arry[l]=y;

l++;

go=SC;

while((go->mem.x!=x) || (go->mem.y!=y)) go=go->next;

}

cout << " (" << x1 << "," << y1 << ")\n ";

arrx[l]=x1;arry[l]=y1;

l++;

cout << "Стоимость пути = " << sum ;

cout << "\nX " ;

for(int k=0;k
cout.width(4);

cout << " " << k;}

cout << "\nY\n";

for(int i=0;i
cout << i << " ";

for(int j=0;j
f=1;

for(int d=0;d
if(arrx[d]==j && arry[d]==i) f=0;

}

if(!f){

cout.width(3);

cout << "*"<< arr[i][j] << " " ;

} else {

cout.width(3);

cout << " " << arr[i][j] << " " ;

}

}

cout << endl;

}

}

void Dr(int num)

{

cout << "X " ;

for(int k=0;k
cout.width(4);

cout << k;}

cout << "\nY\n";

for(int i=0;i
cout << i << " ";

for(int j=0;j
cout.width(3);

cout << arr[i][j] << " " ;

}

cout << endl;

}

}

void Find()

{

list List;

item2 one;

int flag=0;

one.x=x1; one.y=y1; one.cas=0;

one.x2=x1; one.y2=y1; one.sum=0;

if(x2>x1) cash=x2-x1; else cash=x1-x2;

if(y2>y1) cash=cash+y2-y1; else cash=cash+y1-y2;

List.AddOpen(one);

while(!flag){

flag = List.AddClose();

OpenCS(List);

}

cout << "Путь найден ! - ";

List.FindWay();

}

void main()

{

clrscr();

Dr(5);

cout << "Укажите начало пути (X,Y) :";

cin >> x1; cin >> y1;

cout << "Укажите конец пути (X,Y) :";

cin >> x2; cin >> y2;

Find();

}


Модель задачи перевозки грузов.


ЦЕЛЬ:

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

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

ТИП:


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


#include

#include

#include

#include

#include

#include

#include

#include

#include

/*

Пояснения к программе

В случае очень ценного груза больший приоритет имеет качество дороги

В случае коэф. повреждения < 15% приоритет имеет качество дороги

Если мал срок доставки(5
При прочих условиях ищется дорога с наименьшей длинной и наилучшем качеством

Если коэффициент готовности человека больше или равен 0.75,

то при прочих плохих условиях он может поехать по дороге плохого качества

*/


struct Road // структура содержащая все характеристики дороги

{ int quality; // качество дороги

int length; // длина дороги (км)

float security;// безопасность проезда по дороге(руб/км)

// затраты на безопасность составляют рубли на каждый км.

int rasresh; //0-дорога запрещена 1-дорога разрешена

};


Road RoadArray [3]; //три дороги


void main()

{

int Exit=0; //флаг выхода из моделирования

int flag=0; //выход в случае не удачной модели

float Gotov; // коэффициент готовности человека-оператора к данной работе

unsigned int Srok; // max срок доставки (в часах)

unsigned int Resurs; // ресурсы (в руб)

unsigned int Povreg; // степень повреждения (в %)

unsigned long Stoim; // стоимость груза

randomize; // генератор случайных чисел


do

{

/* Информация об авторе */

textbackground(7);

clrscr();

textattr(0x7F);

cputs("Лабораторная работа N6\n\r");

textattr(0x7E);

cputs("\"Моделирование работы\n\r");

cputs("человека-оператора\"\n\r");

textattr(0x71);

cputs("Сделал Насибулов Ш.М.\n\rЭВМд-32 1999\n\n\r");


Srok=random(20)+5; //МАХ. срок доставки груза (в часах)

Resurs=random(801)+500; //МАХ. имеющиеся ресурсы (в руб)

Povreg=random(21)+10; //МАХ. допустимая степень повреждения (в %)

Stoim=random(5000); //Стоимость перевозимого груза (в руб)

Stoim=Stoim*1000;


cout<<"МАХ. срок доставки груза (в часах): "<
cout<<"МАХ. имеющиеся ресурсы (в руб): " <
cout<<"МАХ. допустимая степень повреждения (в %): "<

cout<<"Стоимость перевозимого груза (в руб): "<

Gotov=random(500)/1000.0+0.5;

cputs("Коэффициент готовности человека-оператора к данной работе: ");

printf("%f\n\r",Gotov);


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

{

//Генерируем характеристики дорог

RoadArray[i].quality = random(3);

RoadArray[i].length = random(490)+300;

RoadArray[i].security= random(100);

RoadArray[i].security= RoadArray[i].security/100+0.5;

//В поле rasresh заносим флаг разрешения исходя из имеющихся ресурсов

if( RoadArray[i].length * RoadArray[i].security > Resurs)

RoadArray[i].rasresh=0;

else RoadArray[i].rasresh=1;

}


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

{

textcolor(4);

cout<<"Номер дороги: "<
textcolor(1);

cout<<"Качество дороги:";

if(RoadArray[i].quality==0)

cout<<"Плохое. "<<" ";

if(RoadArray[i].quality==1)

cout<<"Удовлет."<<" ";

if(RoadArray[i].quality==2)

cout<<"Хорошее."<<" ";

cout<<"Длина дороги:";

cout<
cout<<"Безопасность(руб/км):";

cout<
}


int k=0;

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

{if(RoadArray[i].rasresh==0)

{cout<
k++;

}

}


flag=0; //разрешаем моделирование


//Если у человека не хватает ресурсов, то сообщение об этом и выход из моделир.

if(k==3)

{

cout<<"Человек не готов к выполнению данной задачи(не хватает ресурсов)"<
flag=1; //не удачная модель

}


if(flag==0 && Gotov) //удачная модель (есть хотя бы одна разрешенная дорога)

{

if(k==2) //если разрешена лишь одна дорога, то в любом случае выбираем ее

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

if(RoadArray[i].rasresh==1)

{

cout<<"Человек выбрал "<
flag=1; //выходим из моделирования

}

}


if(flag==0 && Gotov) //если моделирование продолжается

{

//Если груз очень ценнен(>3000000), то больший приоритет имеет качество дороги

if(Stoim>3000000 && Povreg<15)

{

if(k==0) //все дороги разрешены (ищем дорогу с мах качеством)

{

int kac=RoadArray[0].quality;

int ind=0;

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

if(RoadArray[i].quality >kac) {kac=RoadArray[i].quality;ind=i;}

textattr(0x7E);

cout<<"Человек выбрал "<
textattr(0x71);

flag=1;

}

}

}


if(flag==0 && Gotov)//если моделирование продолжается

{

//Если мал срок доставки(5
if(Srok<10)

{

if(k==0) //все дороги разрешены (ищем дорогу с min длиной)

{

int len=RoadArray[0].length;

int ind=0;

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

if(RoadArray[i].length
textattr(0x7E);

cout<<"Человек выбрал "<
textattr(0x71);

flag=1;

}

}

}


int q0=0;

int l0=0;

int i0=0;


if(flag==0 && Gotov)//если моделирование продолжается

{

// Ищем среди всех разрешенных дорог - дорогу с наименьшей длинной и с наилучшем

// качеством

if(k==0) //разрешены 3 дороги

{ i0=0;

l0=RoadArray[0].length;

q0=RoadArray[0].quality;

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

if(RoadArray[i].length=q0)

{i0=i;

l0=RoadArray[i].length;

q0=RoadArray[i].quality;

}

textattr(0x7E);

cout<<"Человек выбрал "<
textattr(0x71);

flag=1;

}

}


if(flag==0 && Gotov)//если моделирование продолжается

{

if(k==1) //разрешены 2 дороги

{

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

{if(RoadArray[i].rasresh==1)

{

i0=i;

l0=RoadArray[i].length;

q0=RoadArray[i].quality;

break;

}

}

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

if(RoadArray[i].length=q0 && RoadArray[i].rasresh==1)

{i0=i;

l0=RoadArray[i].length;

q0=RoadArray[i].quality;

}

textattr(0x7E);

cout<<"Человек выбрал "<
textattr(0x71);

flag=1;

}

}

cputs("\n\rПовторить выполнение моделирования (Да - Enter)(Нет - Любую клавишу):");

Exit = getch();

}

while (Exit==13);

}


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


#include

#include

#include

#include

#include

#include

struct way{

int from; //путь из from в to

int to;

};

struct item // элемент списка

{ way del; // удаляемый путь

int value; // оценка стоимости

item * next; // указатель на след. элемент

item * negnext; // указатель на след. элемент (не)

item * prev; // указатель на пред. элемент

};


struct List{ // Элемент списка (хранит путь)

way road;

List *next;

};


// определение класса для работы с деревом поиска

class Graph {

List * First; // начало списка пути

item *Root; // корень дерева

int nmap; // размер исходной матрицы

int nduble; // размер изменяемой матрицы

unsigned Prise[9][9]; // матрица стоимостей переходов

unsigned Time[9][9]; // маирица затрат времени

unsigned map[9][9]; // исходная матрица

unsigned duble[9][9]; // изменяемая маирица (по ней находится путь)

public:

Graph();

int prived (int); // приведениематрицы

int zeros (int ,int&, int &); // оценка нулей

int del (int, int, int); // удаление строки и тсолбца

void find (); // нахождение пути

void print(); // вывод матрицы и найденного пути

void sortlist(); // сортировка пути

item* lasttwo(item *); // обработка матрицы 2х2

List* Clear(List*); // очистка списка пути

void sum();

};


// определение функций-членов класса

Graph::Graph()

{ cout<<"Введите количество магазинов (2..8)"<
do

nmap=getche()-48;

while ((nmap>8)||(nmap<2));

nduble=nmap;

randomize();

//Стоимость пути

for (int i=1; i<=nmap; i++)

for (int j=1; j<=nmap; j++)

{ if (i!=j)

Prise[i][j]=random(100);

else

Prise[i][j]=32000;

}

//Затраты времени

for (i=1; i<=nmap; i++)

for (int j=1; j<=nmap; j++)

{ if (i!=j)

Time[i][j]=random(100);

else

Time[i][j]=32000;

}

}

void Graph::sum()

{ float k1,k2;

k1=k2=1;

cout<
cin>>k1;

cout<
cin>>k2;

//нормализация

if (k1>k2)

{k2=k2/k1;

k1=1;

}

else

{k1=k1/k2;

k2=1;

}

for (int i=1; i<=nmap; i++)

for (int j=1; j<=nmap; j++)

{if (i!=j)

map[i][j]=duble[i][j]=(int)(Prise[i][j]*k1)+(int)(Time[i][j]*k2);

else map[i][j]=duble[i][j]=32000;

}

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

{map[0][i]=map[i][0]=duble[0][i]=duble[i][0]=i;

Prise[0][i]=Prise[i][0]=Time[0][i]=Time[i][0]=i;

}

Root=new item;

Root->del.from=Root->del.to=32000;

Root->next=Root->negnext=Root->prev=NULL;


}


int Graph::prived(int razm) // после работы функции в каждом

{ int i, j, delta=0, find=0; // сстолбце и строке матрицы есть

for (i=1; i<=razm; i++) // хотябы 1 нуль

{ for (j=1; j<=razm; j++) // функция возвращает стоимоссть данного

if (duble[i][j]==0) // преобразования

{ find=1;

break;

}

if (!find)

{ int min;

min=duble[i][1];

for (j=1; j<=razm; j++)

if (duble[i][j]
delta=delta+min;

for (j=1; j<=razm; j++)

duble[i][j]=duble[i][j]-min;

}

find=0;

}

for (j=1;j<=razm; j++)

{ for (i=1; i<=razm; i++)

if (duble[i][j]==0)

{ find=1;

break;

}

if (!find)

{ int min;

min=duble[1][j];

for (i=1; i<=razm; i++)

if (duble[i][j]
delta=delta+min;

for (i=1; i<=razm; i++)

duble[i][j]=duble[i][j]-min;

}

find=0;

}

return delta;

}


int Graph::zeros (int razm,int &x, int &y) // функция возвращает оценку

{ int i, j, maxprise=0; // самого дорогого нуля

x=y=100; // и помещает в x и y номер

for (i=1; i<=razm; i++) // строки и столбца с

for (j=1; j<=razm; j++) // максимальной оценкой

if (duble[i][j]==0)

{ int min, prise=0;

min=32000;

for (int k=1; k<=razm; k++)

if ((duble[i][k]
prise=prise+min;

min=32000;

for (k=1; k<=razm; k++)

if ((duble[k][j]
prise=prise+min;

if (prise>maxprise)

{ maxprise=prise;

x=duble[i][0];

y=duble[0][j];

}

}

return maxprise;

}


void Graph::print()

{

cout<
for (int i=0; i<=nmap; i++)

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

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<

}

cout<
}

cout<
for (i=0; i<=nmap; i++)

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

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<
}

cout<
}

getch();

clrscr();

cout<
for (i=0; i<=nmap; i++)

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

{ cout.flags(ios::left);

cout.width(6);

cout.fill(' ');

cout<
}

cout<
}

List *point=First;

cout<
cout<
road.from<<" ";

while (point)

{

cout<
road.to<<" ";

point=point->next;

}

}


void Graph::sortlist() // ф-я расставляет элементы

{ List *tmp,*point=First, *point1=First; // списка (путь) так, чтобы

int find=1, n=0, i=0; // поле to элеемнта

while (point) // было равно полю from

{ n++; // следующего элемента

point=point->next;

}

while (point1)

{

find=0;

point=First;

while (point)

{ if (point1->road.to==point->road.from)

{

tmp=point1;

while ((tmp->next!=point)&&(tmp))

tmp=tmp->next;

if (!tmp)

{ tmp=First;

while (tmp->next!=point1)

tmp=tmp->next;

List *tmp1=First;

if (point!=First)

while (tmp1->next!=point)

tmp1=tmp1->next;

tmp->next=point1->next;

point1->next=point;

if (tmp1==First) First=point1;

else tmp1->next=point1;

find=1;

point1=tmp;

}

else

{ tmp->next=point->next;

point->next=point1->next;

point1->next=point;

find=1;

}

break;

}

point=point->next;

}

if ((!find)&&(point1==First))

{ i++;

tmp=point=First;

while (point->next)

point=point->next;

point->next=tmp;

First=First->next;

tmp->next=NULL;

if (First)

if (i<=n) point1=First;

else point1=point->next;

}

else

point1=point1->next;

}


}


List* Graph::Clear(List*p)

{ List*point;

while (p)

{ point=p;

p=point->next;

delete point;

}

return p;

}


int Graph::del (int razm, int x, int y) // удаление строки и столбца,

{ int i, j, k; // содержащих самый дорогой нуль

for (i=1; i<=razm; i++) // также запрещается переход,

if (duble[i][0]==x) k=i; // замыкающий найденный путь

for (i=k; i
for (j=0; j<=razm; j++)

duble[i][j]=duble[i+1][j];

for (j=1; j<=razm; j++)

if (duble[0][j]==y) k=j;

for (j=k; j
for (i=0; i<=razm; i++)

duble[i][j]=duble[i][j+1];

for (i=1; i
for (j=1; j
if ((duble[i][0]==y)&&(duble[0][j]==x))

duble[i][j]=32000;

sortlist();

List *point=First;

if (point)

while (point->next)

{ if (point->road.to!=point->next->road.from) break;

point=point->next;

}

for (i=1; i
for (j=1; j
if ((duble[i][0]==point->road.to)&&(duble[0][j]==First->road.from))

duble[i][j]=32000;


return --razm;

}


item* Graph::lasttwo(item *p)

{ List *point;

item *tmp1, *tmp2;

tmp2=new item;

tmp1=new item;

p->next=tmp1;

tmp1->prev=p;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=p->value;

tmp1->del.from=duble[1][0];

tmp2->del.from=duble[2][0];

if ((duble[1][1]==0)&&(duble[2][2]==0))

{

tmp1->del.to=duble[0][1];

tmp2->del.to=duble[0][2];

}

else

{

tmp1->del.to=duble[0][2];

tmp2->del.to=duble[0][1];

}

p=p->next;

p->next=tmp2;

tmp2->prev=p;

tmp2->next=tmp2->negnext=NULL;

tmp2->value=p->value;

point=new List;

point->road.from=tmp1->del.from;

point->road.to=tmp1->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

point=new List;

point->road.from=tmp2->del.from;

point->road.to=tmp2->del.to;

t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

return p;

}


void Graph::find() // поиск пути

{ First=NULL; // рпоходит до конца по левой ветке

int maxvalue; // дерева. Запоминается путь и его

Root->value=prived(nduble); // стоимость. Все вершины с такой же

item *tmp; // или более дорогой стоимостью удаляются.

int line=1, stolb=1; // После возвращения к корню проходит по

tmp=Root; // неудаленному пути и если матрица не

while (nduble>2) // полностьью удалена, то создаеься

{ List *point; // дальнейший путь (если ст-ть созданной

item *tmp1, *tmp2; // вершины больше стоимости пути, то

tmp1=new item; // верршина удаляется и дальше не

tmp2=new item; // просматрривается). Если путь меньше

tmp->negnext=tmp2; // старого, то он запоминается. Так продолж.

tmp2->prev=tmp; // пока все вершины кроме корня не удалены

tmp2->next=tmp2->negnext=NULL;

tmp2->value=zeros(nduble,line,stolb)+tmp->value;

point=new List;

point->road.from=line;

point->road.to=stolb;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

nduble=del(nduble,line,stolb);

tmp2->del.from=-line;

tmp2->del.to=-stolb;

tmp->next=tmp1;

tmp1->prev=tmp;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=prived(nduble)+tmp->value;

tmp1->del.from=line;

tmp1->del.to=stolb;

tmp=tmp->next;

}

tmp=lasttwo(tmp);

sortlist();

maxvalue=tmp->next->value;

List *First1=First;

First=NULL;

maxvalue=tmp->value;

while ((Root->next)||(Root->negnext))

{ int i,j;

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

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

duble[i][j]=map[i][j];

nduble=nmap;

while (tmp!=Root)

{ if (tmp->next)

if (tmp->next->value>=maxvalue)

{ delete tmp->next;

tmp->next=NULL;

}

if (tmp->negnext)

if (tmp->negnext->value>=maxvalue)

{ delete tmp->negnext;

tmp->negnext=NULL;

}

if ((!tmp->next)&&(!tmp->negnext))

{ item *tmp1=tmp;

tmp=tmp->prev;

if (tmp->next==tmp1) tmp->next=NULL;

else tmp->negnext=NULL;

delete tmp1;

}

else tmp=tmp->prev;

}

if ((Root->negnext)&&(Root->negnext->value>=maxvalue))

{ delete Root->negnext;

Root->negnext=NULL;

continue;

}

Root->value=prived(nduble);

int line=1, stolb=1;

int exit;

tmp=Root;

while (nduble>2)

{ List *point;

item *tmp1, *tmp2;

exit=0;

tmp1=tmp->next;

if (tmp1)

{ zeros(nduble,line,stolb);

nduble=del(nduble,line,stolb);

prived(nduble)+tmp->value;

tmp=tmp->next;

point=new List;

point->road.from=tmp->del.from;

point->road.to=tmp->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

continue;

}

tmp2=tmp->negnext;

if (tmp2)

{ tmp=tmp->negnext;

for (i=1; i
for (j=1; j
if ((duble[i][0]==-tmp->del.from)&&(duble[0][j]==-tmp->del.to))

duble[i][j]=32000;

prived(nduble);

continue;

}

if ((!tmp->next)&&(!tmp->negnext)&&(tmp->value
{ if (tmp==Root)

{ exit=1;

break;

}

tmp1=new item;

tmp2=new item;

tmp->negnext=tmp2;

tmp2->prev=tmp;

tmp2->next=tmp2->negnext=NULL;

tmp2->value=zeros(nduble,line,stolb)+tmp->value;

nduble=del(nduble,line,stolb);

tmp2->del.from=-line;

tmp2->del.to=-stolb;

tmp->next=tmp1;

tmp1->prev=tmp;

tmp1->next=tmp1->negnext=NULL;

tmp1->value=prived(nduble)+tmp->value;

tmp1->del.from=line;

tmp1->del.to=stolb;

if (tmp1->value>=maxvalue)

{ delete tmp->next;

tmp->next=NULL;

}

else

{ point=new List;

point->road.from=tmp1->del.from;

point->road.to=tmp1->del.to;

List *t=First;

if (t)

{

while(t->next)

t=t->next;

point->next=NULL;

t->next=point;

}

else

{ First=point;

point->next=NULL;

}

}

if (tmp2->value>=maxvalue)

{ delete tmp->negnext;

tmp->negnext=NULL;

}

if ((!tmp->next)&&(!tmp->negnext))

{ exit=1;

First=Clear(First);

break;

} else

{ if (tmp->next)

{ tmp=tmp->next;

continue;

}

if (tmp->next)

tmp=tmp->next;

}

}

}

if(!exit)

{ //List *point;

tmp=lasttwo(tmp);

if (maxvalue>tmp->value)

{ First1=Clear(First1);

First1=First;

First=NULL;

sortlist();

maxvalue=tmp->value;

}

}

}

List *point;

while (First)

{ point=First;

First=point->next;

delete point;

}

First=First1;

sortlist();

print();

delete Root;

First=Clear(First);

cout<
}

void main()

{ clrscr();

randomize();

Graph a;

int kod=0;

int t=random (10);

int k=100*(exp(-t/7)+0.12*(-11.9*exp(-t/5)+exp(-12*t)*0.1+11.8*exp(-t/7)));

int l=random(100);

if (k>l)

{while (kod!=27)

{clrscr();

a.sum();

a.find();

cout<
cout<
<<"любую другую клавишу."<
kod=getch();

}

}

else

{cout<
getch();

}

}


Модель выбора оптимального маршрута движения.


#include

#include

#include

#include

#include

#include

#include

#include

//Объявление всех используемых в программе переменных

int i,j,k,l;//Переменные управления циклами

float al;//промежуточные переменные

float timm,cocl,bez,way,hh;

int num,temp;

//объявление всех матриц в том числе

//и для промежуточного использования

float mas[5][3];

float prom[5][30];

int kol[5];

float tik[4];

float tik2[5];

float mas1[5];

float mas2[4];

float risk[5][4];

float ll[5];

float speed;

float maxi;

float mini;

int moda;

int opred[5];

float disp[5];

float l0;//интенсивность забывания информации(в месяцах)

float lu1;//интенсивность восстановления знаний(в минутах)

float l1;//интенсивность забывания после восстановления

float liop;

float p0,p2;

float mytime;//время

int var;

int kolich[5];

float ver[5];

int kk;

int ujk;

void main()

{

//переопределение потокового ввода-вывода для записи в 3 файла

//в файле ddd.111 хранятся сами решения

//в матрицы рисков и выигрышей

//в коэффициент готовности и выводы по нему

ofstream f("ddd.111");

ofstream f1("ddd.222");

ofstream f2("ddd.333");

//подсчёт коэффициента готовности и вывод его в файл

randomize();

l0=0.001+random(5)/100.0;l1=0.001+random(5)/100.0;lu1=0.99;

mytime=random(12);

p0=(pow(2.17,(-l0*mytime)));

liop=((l0-lu1)*(pow(2.17,(-l1*mytime)))+(l1-l0)*(pow(2.17,(-lu1*mytime)))+(lu1-l1)*(pow(2.17,(-l0*mytime))));

p2=((lu1*l0)/((l1-lu1)*(lu1-l0)*(l0-l1)))*liop;

f2<<"Коэффициент готовности на момент времени t = "<
f2<<"составляет Кг= "<

f2<<"Это значит,что оператор с заданными характеристиками"<
f2<<"изменений знаний в период времени "<
f2<<"А именно:"<
f2<<"Интенсивность забывания единиц деятельности = "<
f2<<"Интенсивность восстановления = "<
f2<<"Интенсивность забывания после этого восстановления = "<
f2<<"в состоянии выполнить в среднем "<<(p0+p2)*100<
f2<<"oпределённых единиц деятельности из"<
f2<<"100 предъявленных ему в случайный момент времени"<
clrscr();

f<<"Файл содержащий результаты выбора решений"<
f1<<"Файл содержит распечатки матриц выйгрышей и рисков"<
//основной цикл всех расчётов

for(int kkk=1;kkk<21;kkk++)

{

kolich[0]=0;

kolich[1]=0;

kolich[2]=0;

kolich[3]=0;

kolich[4]=0;

opred[0]=0;

opred[1]=0;

opred[2]=0;

opred[3]=0;

opred[4]=0;

moda=0;

randomize();

f1<
f1<<"Кол-во машин = "<
f<<"Кол-во машин = "<
f<<"Варианты решений при 10-ти испытаниях"<
temp=0;

ujk=0;

//в этом цикле каждый раз строятся матрицы выигрышей и рисков

for(int kkkk=10;kkkk<110;kkkk=kkkk+10)

{

hh=20;

kk=random(kkkk);

ll[0]=hh;

ll[1]=kk+25;

ll[2]=kk+50;

ll[3]=kk+90;

ll[4]=kk+110;

mas[0][1]=1.0;

way=(sqrt(pow(hh,2)+pow(ll[0],2)));

mas[1][1]=way/(hh+ll[1]);

for(i=2;i<5;i++)

{

mas[i][1]=way/(mas[1][1]+2*ll[i]);

}

bez=1.0;

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

{

mas[i][0]=((bez/(kkk*((ll[4]+hh)/(hh+ll[i])))));

}

mas[4][0]=1.0;

mas[3][0]=mas[3][0];

mas[0][2]=1.0;

for(i=1;i<5;i++)

{

mas[i][2]=mas[i][1]/1.33;

}

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

{

maxi=0;

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

{

if(mas[i][j]>maxi)

{

maxi=mas[i][j];

tik[j]=maxi;

}

}

}

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

{

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

{

risk[i][j]=tik[j]-mas[i][j];

}

}

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

{

maxi=0;

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

{

if(risk[i][j]>maxi)

{

maxi=risk[i][j];

tik2[i]=maxi;

}

}

}

mini=1.0;

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

{

if(tik2[i]
{

mini=tik2[i];

var=i;

}

}

prom[0][temp]=way;

prom[1][temp]=hh+kk+25;

prom[2][temp]=hh+2*(kk+50);

prom[3][temp]=hh+2*(kk+90);

prom[4][temp]=hh+2*(kk+110);

temp++;

switch (var)

{

case 0:

{

kolich[0]++;

opred[0]=kolich[0];

break;

}

case 1:

{

kolich[1]++;

opred[1]=kolich[1];

break;

}

case 2:

{

kolich[2]++;

opred[2]=kolich[2];

break;

}

case 3:

{

kolich[3]++;

opred[3]=kolich[3];

break;

}

case 4:

{

kolich[4]++;

opred[4]=kolich[4];

break;

}

};

//вывод результатов в файл

f<
f1<
f<
f1<<"Матрица выйгрышей";

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

{

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

{

f1<<" "<
}

}

f1<
f1<<"Матрица рисков";

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

{

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

{

f1<<" "<
}

}

f1<
}

ver[0]=kolich[0]/10.0;

ver[1]=kolich[1]/10.0;

ver[2]=kolich[2]/10.0;

ver[3]=kolich[3]/10.0;

ver[4]=kolich[4]/10.0;

int maxus=0;

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

{

if(opred[h]>maxus)

{

maxus=opred[h];

moda=h;

}

}

//вывод результатов в файл

f<<"Вероятность выбора 0-го решения "<
f<<"Вероятность выбора 1-го решения "<
f<<"Вероятность выбора 2-го решения "<
f<<"Вероятность выбора 3-го решения "<
f<<"Вероятность выбора 4-го решения "<
for( h=0;h<5;h++)

{

if(opred[h]==maxus)

{

f<<"Мода "<