Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

КУРСОВАЯ РАБОТА

по дисциплине «Исследование операций»

Тема: «Методы решения задач целочисленного программирования»



Оглавление

• Введение
• Глава 1. Метод ветвей и границ
• 1.1 Пример задачи целочисленного программирования
• 1.2 Общий алгоритм методов решения задач целочисленного программирования
• 1.3 Метод ветвей и границ
• 1.4 Алгоритм метода ветвей и границ
• Глава 2. Описание программного продукта
• Заключение
• Список литературы
• Листинг

Введение

Целочисленное линейное программирование ориентировано на решение задач линейного программирования, в которых все или некоторые переменные должны принимать целочисленные (или дискретные) значения. Несмотря на интенсивные исследования, проводимые на протяжении последних десятилетий, известные вычислительные методы Решения задач Целочисленного Линейного программирования далеко от совершенства.

В данной курсовой работе будет рассмотрен один из целочисленных методов - метод ветвей и границ. Впервые, он был предложен Ленд и Дойг в 1960 г.

Данная тема является чрезвычайно актуальной, ведь метод ветвей и границ в связи с простотой сущности алгоритма используется при работе на некоторых ЭВМ, а решения задач всегда востребованы как в экономической отрасли, так и других, смежных с ней.

Примером таких задач могут быть задания расчета количества работающих людей или машин на предприятии, расчет необходимых цельных деталей и т.д.

Цель курсовой работы изучить раздел целочисленного линейного программирования, методы целочисленного программирования, построить алгоритм для решения задач и запрограммировать программный продукт, реализующий метод ветвей и границ.

численный программирование задача builder

Глава 1. Метод ветвей и границ

1.1 Пример задачи целочисленного программирования

Рассмотрим сначала простую практическую задачу, которая сводится к ЦЛП. Для удобства задачи, в которых все переменные должны быть целочисленными, называются полностью целочисленными, а задачи, в которых лишь некоторые переменные должны принимать целочисленные значения, - частично целочисленными.

Пример: Оценивается пять проектов с точки зрения их возможного финансирования на предстоящий трехлетний период. Следующая таблица содержит ожидаемую прибыль от реализации каждого проекта и распределение необходимых капиталовложений по годам.

Предполагая, что каждый утвержденный проект будет реализован на трехлетний период. Необходимо определить совокупность проектов, которой соответствует минимум суммарной прибыли.

Задача сводится к решению типа «Да - Нет» относительно каждого проекта. Определим двоичные переменные Xj:



Задача ЦЛП будет записана следующим образом:

Оптимальным целочисленным планом (полученным с помощью программы Tora) является х1=х2=х3=х4=1, х5=0 с Z=95 (млн. долл.). Это решение означает, что необходимо выбрать для финансирования все проекты, кроме пятого.

Интересно сравнивать решение данной задачи ЦЛП с решением «обычной» задачи ЛП с теми же ограничениями, но без условия целочисленности переменных. Задача линейного программирования получается в результате замены условия Xj=0 или 1на ограничение 0?Xj?1

для всех j. Эта задача имеет решение при х1=0.5789, х2=х3=х4=1, х5=0.7368 и z=108.68 (млн. долл.). Такое решение с точки зрения целочисленной задачи лишено смысла, так как две переменные принимают дробное значение. Можно было бы попытаться округлить полученный результат, что привело бы к х1=х5=1. Полученное при этом решение является не допустимым, так как нарушаются ограничения задачи . Более существенным в этой ситуации является то, что округление применять нельзя, т.к. Хj представляет решение «типа да - нет», для которого дробные значения лишены смысла.

1.2 Общий алгоритм методов решения задач целочисленного программирования

Методы решения задач целочисленного линейного программирования основаны на использовании вычислительных возможностей методов линейного программирования. Обычно алгоритм целочисленного программирования включает три шага.

Шаг 1. «Ослабление» пространства допустимых решений задачи целочисленного линейного программирования путем замены любой двоичной переменной с непрерывным ограничением 0?y?1 и отбрасывания требования целочисленности для всех остальных переменных. В результате получается обычная задача линейного программирования.

Шаг 2. Решение задачи линейного программирования и определение ее оптимального решения.

Шаг 3. Имея полученное (непрерывное) оптимальное решение, добавляем специальные ограничения, которые итерационным путем изменяют пространство допустимых решений задачи линейного программирования таким образом, чтобы, в конечном счете, получилось оптимальное решение, удовлетворяющее требованиям целочисленности.

Разработаны два общих метода генерирования специальных ограничений, о которых идет речь при реализации шага 3.

1. Метод ветвей и границ.

2. Метод отсекающих плоскостей.

Хотя ни один из перечисленных методов не дает надежных результатов при решении задачи целочисленного линейного программирования, опыт вычислений свидетельствует, что метод ветвей и границ более успешно решает задачу, чем метод отсекающих плоскостей.

1.3 Метод ветвей и границ

Рассмотрим следующую задачу целочисленного линейного программирования. Максимизировать при ограничениях



На рис.1 пространство допустимых решений задачи целочисленного линейного программирования представлено точками. Соответствующая начальная задача линейного программирования (обозначим ее ЛП0) получается путем отбрасывания условия целочисленности. Ее оптимальным решением будет =3.75, =1.25, z=23.75.

Рис.1. Пространство допустимых решений

Так как оптимальное решение задачи ЛП0 не удовлетворяет условия целочисленности, метод ветвей и границ изменяет пространство решений задачи линейного программирования так, что в конечном счете получается оптимальное решение задачи целочисленного линейного программирования. Для этого сначала выбирается одна из целочисленных переменных, значение которой в оптимальном решении задачи ЛП0 не является целочисленным. Например, выбирая (=3.75), замечаем, что область 3 ? ?4 пространства допустимых решений задачи ЛП0 не содержит целочисленных значений переменной и , следовательно, может быть исключена из рассмотрения, как бесперспективная. Это эквивалентно замене исходной задачи ЛП0 двумя новыми задачами линейного программирования ЛП1 и ЛП2, которые определяются следующим образом:

Пространство допустимых решений ЛП1 = пространство допустимых решений ЛП0 + (), пространство допустимых решений ЛП2 = пространство допустимых решений ЛП0 + ().

На рис.2 изображены пространства допустимы решений задач ЛП1 И ЛП2 . Оба пространства содержат все допустимые решения исходной задачи ЦЛП. Это обозначает, что задачи ЛП1 и ЛП2 «не потеряют» решения начальной задачи ЛП0.

Рис.2. Пространства допустимы решений задач ЛП1 И ЛП2

Если продолжим разумно исключать из рассмотрения области, не содержащие целочисленных решений (такие, как ), путем введения надлежащих ограничений, то в конечном счете получим задачу линейного программирования, оптимальное решение которой удовлетворяет требованиям целочисленности. Другими словами, будем решать задачу ЦЛП путем решения последовательности непрерывных задач линейного программирования.

Новые ограничения и взаимоисключаемы, так что задачи ЛП1 и ЛП2 необходимо рассматривать как независимые задачи линейного программирования, что и показано на Рис.3. Дихотомизация задач ЛП - основа концепции ветвления в методе ветвей и границ. В этом случае называется переменной ветвления.

Рис.3. Деление основной задачи на подзадачи

Оптимальное решение задачи ЦЛП находятся в пространстве допустимых решений либо в ЛП1, либо в ЛП2. Следовательно, обе подзадачи должны быть решены. Выбираем сначала задачу ЛП1 (выбор произволен), имеющую дополнительное ограничение ?3.

Максимизировать при ограничениях

Оптимальным решением задачи ЛП1 является , и . Оптимальное решение задачи ЛП1 удовлетворяет требованию целочисленности переменных и . В этом случае говорят что задача прозондирована. Это означает, что задача ЛП1 не должна больше зондироваться, так как она не может содержать лучшего решения задачи ЦЛП.

Мы не можем в этой ситуации оценить качество целочисленного решения, полученного из рассмотрения задачи ЛП1, ибо решение задачи ЛП2 может привести к лучшему целочисленному решению (с большим решением в целевой функции z). Пока мы можем лишь сказать, что значение является нижней границей оптимального (максимального) значения целевой функции исходной задачи ЦЛП. Это значит, что любая нерассмотренная подзадача, которая не может привести к целочисленному решению с большим значением целевой функции, должна быть исключена, как бесперспективная. Если же нерассмотренная подзадача может привести к лучшему целочисленному решению, то нижняя граница должна быть надлежащим образом изменена.

При значении нижней границы исследуем ЛП2. Так как в задачи ЛП0 оптимальное значение целевой функции равно 23.75 и вес ее коэффициенты являются целыми числами, то невозможно получить целочисленное решение задачи ЛП2, которое будет лучше имеющегося. В результате мы отбрасываем подзадачу ЛП2 и считаем ее прозондированной.

Реализация метода ветвей и границ завершена, так как обе подзадачи ЛП1 и ЛП2 прозондированы. Следовательно , мы заключаем, что оптимальным решением задачи ЦЛП является решение, соответствующей нижней границе, а именно , и .

Если бы мы выбрали в качестве ветвлении переменную то ветвления и скорость нахождения оптимального решения были бы другими Рис.4.



Рис.4. Дерево ветвлений решений

1.4 Алгоритм метода ветвей и границ

Предположим, что рассматривается задача максимизации. Зададим нижнюю границу оптимального значения целевой функции z задачи ЦЛП равной -?. Положим i=0.

Шаг 1. (Зондирование и определение границы). Выбираем i-ю подзадачу линейного программирования ЛПi для исследования. Решаем ЛПi и зондируем ее, при этом возможна одна из трех ситуаций.

А) Оптимальное значение целевой функции задачи ЛПi не может улучшить текущей нижней границы.

B) ЛПi приводит к лучшему допустимому целочисленному решению, чем текущая нижняя граница.

С) ЛПi не имеет допустимых решений.

Возможны два случая.

А) Если задача ЛПi прозондирована, нижняя граница изменяется только при условии, что найдено лучшее решение задачи ЦЛП. Если все подзадачи прозондированы, необходимо закончить вычисления: оптимальным решением задачи ЦЛП является то, которое соответствует текущей нижней границе, если такая существует. Иначе положить i=i+1 и повторить шаг 1.

B) Если задача ЛПi не прозондирована, переходим к шагу 2 для выполнения ветвления.

Шаг 2. (Ветвление).Выбираем одну из целочисленных переменных , оптимальное значение которой в оптимальном решении задачи ЛПi не является целым числом. Исключаем из пространства допустимых решений область путем формирования двух подзадач ЛП, которые соответствуют ограничениям и .

Положим i=i+1 и переходим к шагу 1.



Глава 2. Описание программного продукта

Для разработки программного продукта, использовался язык программирования C++. Среда разработки - C++ Builder 6.0 .

Для запуска программного продукта достаточно запустить Kursovik.exe. Перед пользователем появится окно программы (Рис.5).

Рис.5. Главная форма ввода данных

Далее следует форма с добавленными базисными переменными. Рис.6

Рис.6.Форма с преобразованиями

Так как в столбцах базисных переменных отсутствуют отрицательные числа, будет произведен расчет симплекс методом, а так же предложены два варианта в виде кнопок для продолжении вычислений Рис.7.

Рис.7.Форма с возможностью ветвления

В данной форме происходит разветвление алгоритма и отсекание плоскости возможных решений. На переменную х1 накладываются ограничения. При нажатии на кнопку х1=>3 произойдет вызов формы Рис.8, с измененной симплекс таблицей.

Рис.8. Форма с симплекс таблицей, с ограниченной переменой

При нажатии на кнопку поиск произойдет расчет таблицы методом искусственного базиса, так как в базисных элементах присутствуют отрицательные числа. Рис.9

Рис.9 Демонстрация завершения решения

Так как в этой задачи нас не устраивают ответы, данная задача считается прозондированной и мы продолжаем цикл, возвращаемся к началу решений Рис.7 и кликаем по кнопке x1<=2. Происходит вызов с измененной симплекс таблицей, в которой на х1 наложены ограничения.Рис.10

Рис.10. Форма с другим ветвлением решения

Далее при нажатии на кнопку произойдет расчет таблицы симплекс методом, и снова будет предоставлены варианты с наложенными ограничениями на х1,х2. Рис11.



Рис.11. Ветвление второй переменной

Последнее ветвление будет предоставлено для переменной х3.Рис.12

Рис.12.Ветвление третей переменной

При проходе методом по обеим ветвям, решения будут найдены.Рис.13

Рис.13.Возможные решения

Так как нам необходимо максимизировать функцию мы выбираем наибольшее значение функции Z. Z=32 и ему соответствуют переменные х1=2, х2=2, х3=0.



Заключение

В ходе выполнения курсовой работы был изучен один из алгоритмов целочисленного линейного программирования.

Для реализации изученного алгоритмы был выбран язык программирования С++, в среде разработки С++ Builder 6. Данная среда разработки была выбрана из-за содержания специальных компонентов, упрощающих работу с данными и программированием алгоритма. Приведен пример задачи целочисленного линейного программирования. Описан общий алгоритм методов решения задач целочисленного линейного программирования. Определен метод ветвей и границ, а так же расписан его алгоритм. Для каждого ветвления алгоритма создана специальная форма с измененными параметрами, что позволяет наглядно увидеть проводимые расчеты и улучшить понимание работы метода ветвей и границ.

В ходе написания были реализованы симплекс метод и метод искусственного базиса, так как они были необходимы для правильного расчета таблиц. Курсовая работа выполнена, поскольку, реализованы все поставленные цели.

Список литературы

1. Алесинская Т.В. Учебное пособие по решению задач по курсу "Экономико-математические методы и модели". Таганрог: Изд-во ТРТУ, 2012, 153 с.

2. Волков И.К., Загоруйко Е.А. Исследование операций: Учеб. для вузов / Под ред. В.С. Зарубина, А.П. Крищенко. - М.: Изд-во МГТУ им. Н.Э. Баумана, 2010. - 436 с. (Сер. Математика в техническом университете; Вып. ХХ).

3. Гончаренко В.М. «Математические методы и модели операций. Руководство к решению задач». М., Финансовая Академия, 2006

4. Исследование операций - Косоруков О.А. - Учебник 2003 г.

5. Месхи Б.Ч. , Соболь Б.В. , Каныгин Г.И. (Феникс 2009 г)

6. Н.Ш. Крамер, Б.А. Путко, 2012г.

7. Т.Л. Партыка, И.И. Попов. Математические методы: уч. - М.: Форум, 2009. - 464с. - (Проф. Образование).

8. Таха Х., Введение в исследование операций 2001г.

9. Шикин Е. В., Шикина Г. Е. Исследование операций Учебник 2006



Листинг

Unit1.cpp

#include <vcl.h>

#pragma hdrstop

#include "Unit2.h"

#include "Unit1.h"

#include "Unit3.h"

#include "Unit4.h"

#include "Unit5.h"

#include "Unit6.h"

#include "Unit8.h"

#include "Unit7.h"

#include <math.h>

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

#pragma package(smart_init)

#pragma resource "*.dfm"

#define M 99999

TForm1 *Form1;

double mass[10][6];

double x[5];

extern double x2[6];

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

Form1->StringGrid1->Cells[0][0]="";

Form1->StringGrid1->Cells[0][1]="x5";

Form1->StringGrid1->Cells[0][2]="x6";

Form1->StringGrid1->Cells[0][3]="x7";

Form1->StringGrid1->Cells[0][4]="F";

Form1->StringGrid1->Cells[1][0]="x1";

Form1->StringGrid1->Cells[2][0]="x2";

Form1->StringGrid1->Cells[3][0]="x3";

Form1->StringGrid1->Cells[4][0]="x4";

Form1->StringGrid1->Cells[5][0]="x5";

Form1->StringGrid1->Cells[6][0]="x6";

Form1->StringGrid1->Cells[7][0]="Св.чл";

Form1->StringGrid1->Cells[8][0]="Оц.зн.";

Label4->Caption="Найдено решение";

Label4->Visible=False;

Label6->Visible=False;

Label7->Visible=False;

}

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

void __fastcall TForm1::Button3Click(TObject *Sender)

{

if (CheckBox1->Checked){

for (int i=1;i<Form1->StringGrid1->ColCount-1;i++){

for(int j=1;j<Form1->StringGrid1->RowCount;j++){

mass[i][j]=StrToFloat(Form1->StringGrid1->Cells[i][j]);

}

}

CheckBox1->Checked=False;

}

double min = 0;

for (int i = 1; i <( StringGrid1->ColCount - 6); i++){

if ((StringGrid1->Cells[i][StringGrid1->RowCount-1] * -1) > min)

min = StrToFloat(StringGrid1->Cells[i][StringGrid1->RowCount-1]) * -1;

}

int mainColumn = 0;

for (int i = 1; i < StringGrid1->ColCount - 6; i++){

if (StringGrid1->Cells[i][StringGrid1->RowCount-1] == (min * -1))

mainColumn = i;

}

Edit1->Text = FloatToStr(mainColumn);

for(int i = 1; i < StringGrid1->RowCount - 1; i++){

if (StringGrid1->Cells[mainColumn][i] != 0)

StringGrid1->Cells[StringGrid1->ColCount-1][i] = FloatToStr(StrToFloat(StringGrid1->Cells[StringGrid1->ColCount-2][i]) / StrToFloat(StringGrid1->Cells[mainColumn][i]));

else

StringGrid1->Cells[StringGrid1->ColCount-1][i] = 0;

}

for(int i = 1; i < StringGrid1->RowCount - 1; i++)

if (StringGrid1->Cells[StringGrid1->ColCount-1][i] != 0)

min = StrToFloat(StringGrid1->Cells[StringGrid1->ColCount-1][i]);

for (int i = 1; i < StringGrid1->RowCount - 1; i++){

if (StringGrid1->Cells[StringGrid1->ColCount-1][i] != 0)

if ((StrToFloat(StringGrid1->Cells[StringGrid1->ColCount-1][i]) < min))

min = StrToFloat(StringGrid1->Cells[StringGrid1->ColCount-1][i]);

}

int mainRow = 0;

for(int i = 1; i < StringGrid1->RowCount - 1; i++){

if (StringGrid1->Cells[StringGrid1->ColCount-1][i] != 0)

if (StringGrid1->Cells[StringGrid1->ColCount-1][i] == min)

mainRow = i;

}

Edit2->Text = FloatToStr(mainRow);

Edit3->Text = StringGrid1->Cells[mainColumn][mainRow];

StringGrid1->Cells[0][mainRow] = "x"+IntToStr(mainColumn);

for(int i = 1; i < StringGrid1->RowCount; i++){

for(int j = 1; j < StringGrid1->ColCount-1; j++){

if (i != mainRow)

if (j != mainColumn){

StringGrid1->Cells[j][i] = FloatToStr(StrToFloat(StringGrid1->Cells[j][i]) - (StrToFloat(StringGrid1->Cells[j][mainRow]) * StrToFloat(StringGrid1->Cells[mainColumn][i]) / StrToFloat(StringGrid1->Cells[mainColumn][mainRow])));

}

}

}

double mainElement = StringGrid1->Cells[mainColumn][mainRow]*1;

for(int i = 1; i < StringGrid1->ColCount-1; i++){

StringGrid1->Cells[i][mainRow] =FloatToStr(StrToFloat(StringGrid1->Cells[i][mainRow]) / mainElement);

}

x[StrToInt(ComboBox1->Text)] = StrToFloat(StringGrid1->Cells[7][mainRow]);

ComboBox1->Text = IntToStr(StrToInt(ComboBox1->Text) + 1);

int flag=0;

for (int i = 1; i<StringGrid1->ColCount-1;i++){

if (StringGrid1->Cells[i][StringGrid1->RowCount-1]<0){flag=1;}

}

for (int i = 1; i<StringGrid1->RowCount-1;i++){

if (StringGrid1->Cells[StringGrid1->ColCount-1][i]<0){flag=0;}

}

for(int i = 1; i < StringGrid1->RowCount;i++){

if (i != mainRow)

StringGrid1->Cells[mainColumn][i] = "0";

}

if (!flag){Button3->Enabled=False;

Label4->Visible=True;

Form1->Button1->Visible=True;

Form1->Button4->Visible=True;

Form1->Button1->Caption="X1<=" + FloatToStr(floor(StrToFloat (x[1])));

Form1->Button4->Caption="X1=>" + FloatToStr(ceil(StrToFloat (x[1])));

//Form1->Label5->Caption="X1=" +FloatToStr(x[1])+" X2="+FloatToStr(x[2])+"X3="+FloatToStr(x[3]);

//Label5->Visible=True;

Label6->Visible=True;

Label7->Visible=True;

}

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

void __fastcall TForm1::Button2Click(TObject *Sender)

{

Form1->StringGrid1->Cells[1][1]=3;

Form1->StringGrid1->Cells[2][1]=2;

Form1->StringGrid1->Cells[3][1]=8;

Form1->StringGrid1->Cells[4][1]=1;

Form1->StringGrid1->Cells[5][1]=0;

Form1->StringGrid1->Cells[6][1]=0;

Form1->StringGrid1->Cells[7][1]=11;

Form1->StringGrid1->Cells[1][2]=2;

Form1->StringGrid1->Cells[2][2]=0;

Form1->StringGrid1->Cells[3][2]=1;

Form1->StringGrid1->Cells[4][2]=0;

Form1->StringGrid1->Cells[5][2]=1;

Form1->StringGrid1->Cells[6][2]=0;

Form1->StringGrid1->Cells[7][2]=5;

Form1->StringGrid1->Cells[1][3]=3;

Form1->StringGrid1->Cells[2][3]=3;

Form1->StringGrid1->Cells[3][3]=1;

Form1->StringGrid1->Cells[4][3]=0;

Form1->StringGrid1->Cells[5][3]=0;

Form1->StringGrid1->Cells[6][3]=1;

Form1->StringGrid1->Cells[7][3]=13;

Form1->StringGrid1->Cells[1][4]=-11;

Form1->StringGrid1->Cells[2][4]=-5;

Form1->StringGrid1->Cells[3][4]=-4;

Form1->StringGrid1->Cells[4][4]=0;

Form1->StringGrid1->Cells[5][4]=0;

Form1->StringGrid1->Cells[6][4]=0;

Form1->StringGrid1->Cells[7][4]=0;

}

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

void __fastcall TForm1::Button1Click(TObject *Sender)

{

//Значения от х0 до х3

for (int i=1;i<StringGrid1->ColCount-5;i++){

for (int j=1;j<StringGrid1->RowCount-1;j++){

Form2->StringGrid1->Cells[i][j]=mass[i][j];

}}

for (int i=1;i<StringGrid1->ColCount;i++){

for (int j=1;j<StringGrid1->RowCount;j++){

if (j==StringGrid1->RowCount-1){j+=1; //Целевая строка

Form2->StringGrid1->Cells[i][j]=mass[i][j-1];} //***************

if (i==StringGrid1->ColCount-2){ //Свободные члены

Form2->StringGrid1->Cells[i+1][j]=mass[i][j];}//***************

if (i==StringGrid1->ColCount-1){} ; //Остальные значения

//забиваем базисные переменные 1 и 0 от х4 до х7

for (int i=4;i<StringGrid1->ColCount-1;i++){

for (int j=1;j<StringGrid1->RowCount;j++){

if (i-3==j)Form2->StringGrid1->Cells[i][j]="1";

else Form2->StringGrid1->Cells[i][j]="0";

Form2->StringGrid1->Cells[1][Form2->StringGrid1->RowCount-2]="1";

Form2->StringGrid1->Cells[2][Form2->StringGrid1->RowCount-2]="0";

Form2->StringGrid1->Cells[3][Form2->StringGrid1->RowCount-2]="0";

Form2->StringGrid1->Cells[8][Form2->StringGrid1->RowCount-2]=FloatToStr(floor(x[1]));

Form2->Show();

}

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

void __fastcall TForm1::Button5Click(TObject *Sender)

{

Form8->Show();

}

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

void __fastcall TForm1::Button4Click(TObject *Sender)

{

//Значения от х0 до х3

for (int i=1;i<StringGrid1->ColCount-5;i++){

for (int j=1;j<Form3->StringGrid1->RowCount-1;j++){

Form3->StringGrid1->Cells[i][j]=mass[i][j];

}}

for (int i=1;i<StringGrid1->ColCount;i++){

for (int j=1;j<Form3->StringGrid1->RowCount;j++){

if (j==StringGrid1->RowCount-1){j+=1; //Целевая строка

Form3->StringGrid1->Cells[i][j]=mass[i][j-1];} //***************

if (i==StringGrid1->ColCount-2){ //Свободные члены

Form3->StringGrid1->Cells[i+2][j]=mass[i][j];}//***************

if (i==StringGrid1->ColCount-1){} ; //Остальные значения

//забиваем базисные переменные 1 и 0 от х4 до х7

for (int i=4;i<StringGrid1->ColCount;i++){

for (int j=1;j<StringGrid1->RowCount;j++){

if (i-3==j)Form3->StringGrid1->Cells[i][j]="1";

else Form3->StringGrid1->Cells[i][j]="0";

}

}

Form3->StringGrid1->Cells[1][Form3->StringGrid1->RowCount-2]="1";

Form3->StringGrid1->Cells[2][Form3->StringGrid1->RowCount-2]="0";

Form3->StringGrid1->Cells[3][Form3->StringGrid1->RowCount-2]="0";

Form3->StringGrid1->Cells[9][Form3->StringGrid1->RowCount-2]=FloatToStr(ceil(x[1]));

//Строка R1

Form3->StringGrid1->Cells[7][Form3->StringGrid1->RowCount-2]="-1";

Form3->StringGrid1->Cells[8][Form3->StringGrid1->RowCount-2]="1";

Form3->StringGrid1->Cells[8][Form3->StringGrid1->RowCount-1]=M;

Form3->Show();

}

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

Размещено на Allbest.ru

...