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

СОДЕРЖАНИЕ

• ВВЕДЕНИЕ
• 1. ПОСТАНОВКА ЗАДАЧИ
• 2. АНАЛИЗ ЗАДАЧИ
• 2.1 Определение исходных данных и результатов решения задачи
• 2.2 Алгоритм расчета сетевого графика табличным методом
• 2.3 Описание метода решения задачи на математическом языке
• 3. АЛГОРИТМ РЕШЕНИЯ ЗАДАЧИ
• 3.1 Общий алгоритм решения задачи
• 3.2 Структура программы
• 4. НАБОР ТЕСТОВ
• 5. ТЕКСТ ПРОГРАММЫ НА ЯЗЫКЕ С++
• 6. РЕЗУЛЬТАТ ПРОГРАММЫ
• ЗАКЛЮЧЕНИЕ
• СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

ВВЕДЕНИЕ

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

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

Сетевое Планирование и Управление включает три основных этапа:

· Структурное планирование;

· Календарное планирование;

· Оперативное управление.

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

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

Календарное планирование предусматривает построение календарного графика, определяющего моменты начала и окончания каждой работы и другие временные характеристики сетевого графика.

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

В ходе оперативного управления используются сетевой и календарный графики для составления периодических отчетов о ходе выполнения проекта. При этом сетевая модель может подвергаться оперативной корректировке, вследствие чего будет разрабатываться новый календарный план остальной части проекта.[12]

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

1. ПОСТАНОВКА ЗАДАЧИ

Дан сетевой график. Рассчитать табличным способом его параметры, а именно: время раннего и позднего начала работ, время раннего и позднего окончания работ, полный и частный (свободный) резерв работ. Рассчитать траекторию и длину критического пути.

2. АНАЛИЗ ЗАДАЧИ

2.1 Определение исходных данных и результатов решения задачи.

Сетевой график (модель) представляет собой графическое изображение последовательности технологического процесса, показывающее взаимосвязь и взаимозависимость отдельных его этапов, выполнение которых обеспечивает достижение конкретных целей.[9]

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

Граф, все ребра которого ориентированные, называется ориентированным графом (или орграфом).[10]

Орграф в ЭВМ представляется с помощью матрицы весов W =[wij], где wij - вес ребра, соединяющего вершины i, j = 1,2, ... , m. Веса несуществующих ребер полагаются равными ? или 0 в зависимости от задачи. Матрица весов является простым обобщением матрицы смежности.[1]

Основными понятиями сетевых моделей являются понятия события и

работы.

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

По своей физической природе работы можно рассматривать как:

· Действие: разработка чертежа, изготовление детали, заливка фундамента бетоном, изучение конъюнктуры рынка;

· Процесс: старение отливок, выдерживание вина, травление плат;

· Ожидание: ожидание поставки комплектующих, пролеживание детали в очереди к станку.

По количеству затрачиваемого времени работа может быть:

· Действительной, т.е. требующей затрат времени;

· Фиктивной, т.е. формально не требующей затрат времени и представляющей связь между какими-либо работами, например: передача измененных чертежей от конструкторов к технологам; сдача отчета о технико-экономических показателях работы цеха вышестоящему подразделению.

По количеству затрачиваемых ресурсов, работа может быть:

· Действительной, т.е. требующей затрат ресурсов;

· Фиктивной, т.е. формально не требующей затрат ресурсов;

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

На сетевом графике работы изображаются стрелками, которые соединяют вершины, изображающие события. Начало и окончание любой работы описываются парой событий, которые называются начальным и конечным событиями. Поэтому для идентификации конкретной работы используют код работы (i,j), состоящий из номеров начального (i-го) и конечного (j-го) событий (см.рис.1)

Рисунок 1-Работа

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

Источник орграфа - это вершина, от которой достижимы все остальные вершины.[8]

Сток орграфа - это вершина, достижимая из всех других вершин.[8]

Так же с понятием сетевого графика(модели) связано понятие пути.

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

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

Путь, предшествующий событию -- путь от исходного события сети до данного события;[7]

Путь, следующий за событием -- путь, соединяющий событие с завершающим событием;[7]

Путь между событиями i и j -- путь, соединяющий какие-либо два события i и j, из которых ни одно не является исходным или завершающим событием сетевого графика;

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

При построении сетевого графика необходимо следовать следующим правилам:

· каждая операция должна быть представлена только одной стрелкой;

· между одними и теми же событиями не должно быть параллельных работ, т.е. работ с одинаковыми кодами;

· не должно быть стрелок, направленных справа налево;

· номер начального события должен быть меньше номера конечного события;

· не должно быть висячих событий (т.е. не имеющих предшествующих событий), кроме исходного;

· не должно быть тупиковых событий (т.е. не имеющих последующих событий), кроме завершающего;

· не должно быть циклов;

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

2.2 Алгоритм расчета сетевого графика табличным методом

Заполнение таблицы расчета осуществляется в следующей последовательности.

Первый этап - переносятся исходные данные с сетевого графика в таблицу, заполняются первые три графы таблицы. Работы заносятся в порядке возрастания номеров начальных событий, а для одинаковых начальных событий сортируются по возрастанию номеров конечных событий. [5]

Второй этап - рассчитываются ранние параметры работ, заполняются 4 и 5 графы таблицы, расчет ведется от исходного события к завершающему.

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

На этом этапе мы определяем длину критического пути. Она принимается равной максимальному значению времени раннего окончания всех работ, входящих в завершающее событие.[5]

Третий этап - рассчитываются поздние параметры работ, заполняются 6 и 7 графы. Расчет ведется, начиная с работ, входящих в завершающее событие. Поздний срок окончания этих работ равен максимальному сроку из ранних окончаний работ, входящих в завершающее событие. Позднее окончание других работ принимается равным наименьшему значению из поздних начал последующих работ.

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

Четвертый этап - рассчитываются полные и свободные(частные) резервы работ, заполняются 8 и 9 графы таблицы.

В результате расчета получается информация о продолжительности критического пути его траектории, критических работах (работы, имеющие нулевые резервы).[5]

2.3 Описание метода решения задачи на математическом языке

Существуют следующие показатели сетевого графика:

1. t(i-j)-продолжительность работы (здесь i и j-- номера соответственно начального и конечного событий, т. е. i -j -- код рассматриваемой работы).

2. t^рн(i-j)-ранее начало - самое раннее время начала работы, определяется продолжительностью самого длинного пути от начального события до предшествующего события данной работы. Расчет ведется по формуле:

Для исходного события t^рн(I) принимаем равным 0.

Для последующих

t^рн(i-j) = ? max t(i-j) [ (i*-(i-j)) ],

где t(i-j) - продолжительность работ,

[(i*-(i-j))] -событий от исходного события до данного события,

i* -исходное событие.

3. t^ро(i-j)-ранее окончание-время окончания работы, если она начата в ранний срок. Определяется суммой раннего начала и продолжительности рассматриваемой работы. Расчет ведется по формуле:

t^ро(i-j)= t^рн(i-j)+ t(i-j),

где

t(i-j)-продолжительность данной работы,

t^рн(i-j)-ранее начало данной работы,

Максимальное t^рн(i-j*) является длиной критического пути.(t [Lкр]),где

j*-завершающее событие.

4. t^по(i-j)-позднее окончание работы - время окончания работы, если она начата в поздний срок. Определяется разностью продолжительности критического пути и максимальной продолжительности пути от завершающего события всей модели до конечного события рассматриваемой работы. Расчет ведется по формуле:

Для работы с конечным событием t^по(i-j*) принимаем равным t [Lкр],где

t [Lкр]-длина критического пути.

Для последующих

t^по(i-j)= min_(k){ t^пн(i-k)},

где

k-следующее событие,

t^пн(i-j)-позднее начало данной работы.

5. t^пн(i-j) -позднее начало работы - самое позднее время начала работы, которое не вызовет задержки окончания выполнения работ, определяется разностью продолжительности критического пути и самого длинного пути от предшествующего события данной работы до конечного события. Расчет ведется по формуле:

t^пн(i-j) = t^по(i-j)-t(i-j),

где

t^по(i-j)-позднее окончание данной работы,

t(i-j)-продолжительность данной работы.

6. R(i-j)-общий запас времени - количество времени, на которое можно перенести начало работы или увеличить её продолжительность без изменения общего срока. Определяется как разность между поздним и ранним окончанием рассматриваемой работы. Определяется по формуле:

R(i-j) = t^по(i-j) - t^ро(i-j)= t^пн(i-j)- t^рн(i-j),

где

t^по(i-j)-позднее окончание данной работы,

t^ро(i-j)-позднее начало данной работы,

t^пн(i-j)-позднее начало данной работы,

t^рн(i-j)-ранее начало данной работы.

7. r(i-j) Частный запас времени - количество времени, на которое можно перенести начало работы или увеличить её продолжительность без изменения раннего начала последующих работ. Определяется разностью между ранним началом последующей работы и ранним окончанием рассматриваемой работы. Определяется по формуле:

r(i-j) = t^рн(k-j) - t^ро(i-j),

где

t^рн(k-j)- раннего начала последующей работы,

t^ро(i-j)- продолжительность данной работы.

табличный сетевой график математический

3. АЛГОРИТМ РЕШЕНИЯ ЗАДАЧИ

3.1 Общий алгоритм решения задачи

1. При запуске программы пользователю предлагается открыть текстовый файл, в котором находиться матрица весов:

А) Выполняется проверка на правильность введенной в текстовый документ матрицы. Матрица должна быть квадратной и иметь диагональный вид. Элемент матрицы W=[ij] должен соответствовать весу ребра, соединяющего i-е и j-е событие, причем тогда элемент W =[ji] должен равняться 0, т.к. граф ориентирован. Веса несуществующих ребер полагаются равными 0.

Б) Если условия ввода выполнены, то происходит вывод матрицы весов в соответствующее окно и прорисовка таблицы.

В) Если условия ввода не выполнены, то выводиться информационное окно с просьбой повторить ввод или исправить матрицу весов.

2. После прорисовки таблицы пользователь должен нарисовать граф:

А) На рабочей области пользователь щелчком мыши устанавливает точки. С установкой последней точки в рабочей области, автоматически нарисуется данный граф.

В) Если пользователь не нарисовал граф, то программа предложит пользователю нарисовать граф.

4. Нажав кнопку расчёта сетевого графика, пользователь запускает алгоритм поиска критического пути и сопутствующих данных, который работает следующим образом:

4.1. В таблицу решения заносится информация из матрицы весов (число работ, время работ).

4.2. Определяются начальные этапы. Если в матрице весов столбец не содержит данные длительности операции, значит, этим этапом не завершается ни один вид работ, то есть он начальный.

4.3. Для всех начальных этапов, найденных по исходной таблице заносятся значения раннего начала работ равные 0 и время раннего окончания работ 0 + продолжительность работ.

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

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

4.6. Определяются конечные этапы. Если в матрице весов строка не содержит данные длительности операции, значит, этим этапом не начинается ни один вид работ, то есть он конечный.

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

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

4.9. Выделяются записи, имеющие значение общего и частного резерва, равное 0, и помечаются *. Такие виды работ входят в критический путь.

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

5. Результаты метки выводятся на экран. Выводиться длина критического пути и его траектория, которая на рисунке графа окрашивается в синий цвет.

3.2 Структура программы

Программа состоит из 15 элементов.

- 1 объекта Form.

- 1 объекта Button находящихся в раскладке Standard;

- 1 объекта Memo находящихся в раскладке Standard;

- 1 объекта Image находящегося в раскладке Additional;

- 5 объекта Label находящегося в раскладке Additional;

- 1 объекта StringGrid находящегося в раскладке Additional;

- 1 объекта StatusBar находящегося в раскладке Win32;

- По 1-му объекту SaveDialog, PrinterSetupDialog, PrintDialog1, OpenDialog находящегося в раскладке Dialog;

Взаимосвязь функций

4. НАБОР ТЕСТОВ

Выходные данные:

5. ТЕКСТ ПРОГРАММЫ НА ЯЗЫКЕ С++

#include <vcl.h>

#pragma hdrstop

#include <iostream.h>

#include <fstream.h>

#include <stdio.h>

#include <math.h>

#include <memory.h>

#include "windows.h"

#include <stdio.h>

#include "Unit1.h"

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

#pragma package(smart_init)

#pragma link "Excel_2K_SRVR"

#pragma resource "*.dfm"

TForm1 *Form1;

int C,M,N,strok=0;int **Matrix;float* X;float* Y;double* mark;

bool fot=true;

struct point{

float X, Y;

}p[100];

struct Put{

int Nach,Kon,Ves;

}e[100];

struct Min{

int mm,ch;

}m[100];

void MIN(TStringGrid* GRID,int i)

{

m[i].mm=999999;

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

if ((e[j].Nach==i)&&(m[i].mm>StrToInt(GRID->Cells[5][j])))

{

m[i].mm=StrToInt(GRID->Cells[5][j]);

m[i].ch=strok;

}

}

const float M_RAD_CONV=M_PI/180.0;

float GetAngle(float x1, float y1, float x2, float y2)

{

float res=0;

if(y1==y2)

{

if(x2>=x1)

res=0;

if(x2<x1)

res=M_PI;

}else

if(x1==x2)

{

if(y2==y1)

res=0;

if(y2>y1)

res= 90.0*M_RAD_CONV;

if(y2<y1)

res= 270.0*M_RAD_CONV;

}

else

{

res=atan2(y2-y1,x2-x1);

if(res<0)

{

res=res*-1;

res=M_PI-res+M_PI;

}

}

return res;

}

void DrawArrow(TCanvas* Canvas,float x1, float y1, float x2, float y2, int radius)

{

int ArrowCone=30;

int ArrowConeLength=10;

float angle=GetAngle(x2,y2,x1,y1);

x2=cos(angle)*radius+x2;

y2=sin(angle)*radius+y2;

x1=cos(angle+M_PI)*radius+x1;

y1=sin(angle+M_PI)*radius+y1;

Canvas->MoveTo(x2,y2);

Canvas->LineTo(x1,y1);

float tangle=angle+(M_PI-ArrowCone*M_RAD_CONV);

int tx=cos(tangle)*ArrowConeLength+x1;

int ty=sin(tangle)*ArrowConeLength+y1;

Canvas->LineTo(tx,ty);

tangle=angle+(M_PI+ArrowCone*M_RAD_CONV);

tx=cos(tangle)*ArrowConeLength+x1;

ty=sin(tangle)*ArrowConeLength+y1;

Canvas->MoveTo(x1,y1);

Canvas->LineTo(tx,ty);

}

struct Node {

Node(int _id):

id(_id),

countConnections(0),

connections(new Node*[100]),

weightConnections(new int[100])

{}

~Node(){

delete[] connections;

delete[] weightConnections;

}

int id;

Node **connections;

int *weightConnections;

int countConnections;

void connect(Node *node, int weight){

connections[countConnections] = node;

weightConnections[countConnections++] = weight;

}

};

int **countWork;

int **workTime;

void getCountWork(Node *node, int count){

for(int i=0;i<node->countConnections;i++)

if((node->id != node->connections[i]->id) &&

((countWork[node->id][node->connections[i]->id] == -1) ||

(count > countWork[node->id][node->connections[i]->id])))

{

countWork[node->id][node->connections[i]->id] = count;

getCountWork(node->connections[i], count+1);

}

}

void getWorkTime(Node *node, int time){

for(int i=0;i<node->countConnections;i++)

if((node->id != node->connections[i]->id) &&

((workTime[node->id][node->connections[i]->id] == -1) ||

(time > workTime[node->id][node->connections[i]->id])))

{

workTime[node->id][node->connections[i]->id] = time;

getWorkTime(node->connections[i], time+node->weightConnections[i]);

}

}

void work(int **matrix, int countMatrix){

Node **nodes;

nodes = new Node*[countMatrix];

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

nodes[i] = new Node(i);

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

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

{

if(matrix[i][j])

{

nodes[i]->connect(nodes[j], matrix[i][j]);

}

}

countWork = new int*[countMatrix];

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

countWork[i] = new int[countMatrix];

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

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

countWork[i][j] = -1;

workTime = new int*[countMatrix];

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

workTime[i] = new int[countMatrix];

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

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

workTime[i][j] = -1;

getCountWork(nodes[0], 0);

getWorkTime(nodes[0], 0);

}

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

srand(time(NULL));

}

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

void __fastcall TForm1::Button3Click(TObject *Sender)

{

if (N==NULL)

{

ShowMessage("Откройте фаил");return;

}

bool inb=false;

for (int f=0 ; f<N; f++)

if ((p[f].X==NULL)||(p[f].Y==NULL))

{

inb=false;

}

else

{

inb=true;

}

if (inb==false)

{

ShowMessage("Нарисуйте граф");return;

}

for (int f=0 ; f<strok-1; f++)

{StringGrid1->RowCount=StringGrid1->RowCount+1;}

int hod=1;

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

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

{if (Matrix[i][j]!=0)

{

e[hod].Nach=i;e[hod].Kon=j;e[hod].Ves=Matrix[i][j];

StringGrid1->Cells[1][hod]=FloatToStr(e[hod].Nach)+"-"+FloatToStr(e[hod].Kon);

StringGrid1->Cells[2][hod]=e[hod].Ves;

hod++;}

}

int y=1,l=1;

work(Matrix,N);

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

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

{

if(countWork[i][j] > -1)

{

StringGrid1->Cells[0][l]=countWork[i][j];l++;

}

if(workTime[i][j] > -1)

{

StringGrid1->Cells[3][y]=workTime[i][j]; y++;

}

}

for (int f=1 ; f<strok+1; f++)

{

StringGrid1->Cells[4][f]=StrToInt(StringGrid1->Cells[2][f])+StrToInt(StringGrid1->Cells[3][f]);

}

int max=StrToInt(StringGrid1->Cells[4][1]);

for (int f=2 ; f<strok; f++)

{if (StrToInt(StringGrid1->Cells[4][f])>StrToInt(StringGrid1->Cells[4][f+1]))

{

}

else

{

max=StrToInt(StringGrid1->Cells[4][f+1]);

}

}

for (int f=strok ; f>=1; f--)

{

if (e[f].Kon==N-1)

{

StringGrid1->Cells[6][f]=max;

StringGrid1->Cells[5][f]=StrToInt(StringGrid1->Cells[6][f])-StrToInt(StringGrid1->Cells[2][f]);

}

else

{

for (int i=f+1 ; i<=strok;i++)

if (e[f].Kon==e[i].Nach)

{

MIN(StringGrid1,e[f].Kon);

StringGrid1->Cells[6][f]=m[e[f].Kon].mm;

StringGrid1->Cells[5][f]=StrToInt(StringGrid1->Cells[6][f])-StrToInt(StringGrid1->Cells[2][f]);break;

}

}

}

for (int f=1 ; f<strok+1; f++)

{

StringGrid1->Cells[7][f]=StrToInt(StringGrid1->Cells[5][f])-StrToInt(StringGrid1->Cells[3][f]);

}

for (int f=strok ; f>=1; f--)

{

if (e[f].Kon==N-1)

{

StringGrid1->Cells[8][f]=StrToInt(StringGrid1->Cells[6][f])-StrToInt(StringGrid1->Cells[4][f]);

}

else

{

for (int i=f+1 ; i<=strok;i++)

if (e[f].Kon==e[i].Nach)

{

StringGrid1->Cells[8][f]=StrToInt(StringGrid1->Cells[3][i])-StrToInt(StringGrid1->Cells[4][f]);break;

}

}

}

for (int f=1 ; f<=strok; f++)

if ((StrToInt(StringGrid1->Cells[7][f])==0)&&(StrToInt(StringGrid1->Cells[7][f])==0))

StringGrid1->Cells[9][f]="*";

for (int f=1 ; f<=strok; f++)

if ((StringGrid1->Cells[9][f]=="*")&&(Label2->Caption==""))

{

Label2->Caption=FloatToStr(e[f].Nach)+"-"+FloatToStr(e[f].Kon);

Image1->Canvas->Pen->Color=clBlue;

DrawArrow(Image1->Canvas,p[e[f].Kon].X,p[e[f].Kon].Y,p[e[f].Nach].X,p[e[f].Nach].Y,10);

}

else

{

if ((StringGrid1->Cells[9][f]=="*")&&(Label2->Caption!=""))

{

Label2->Caption=Label2->Caption+"-"+FloatToStr(e[f].Kon);

DrawArrow(Image1->Canvas,p[e[f].Kon].X,p[e[f].Kon].Y,p[e[f].Nach].X,p[e[f].Nach].Y,10);

}

}

Label4->Caption=max;

Button3->Enabled = false;

}

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

int y=0;

void __fastcall TForm1::Image1MouseDown(TObject *Sender,

TMouseButton Button, TShiftState Shift, int X, int Y)

{

if (N==NULL)

{

ShowMessage("Откройте фаил");return;

}

if (y==N)

{

ShowMessage("Вы привысили колличество точек");return;

}

if (Button == mbLeft)

{

p[y].X=X;

p[y].Y=Y;

Image1->Canvas->Ellipse(p[y].X-10,p[y].Y-10,p[y].X+10,p[y].Y+10);

Image1->Canvas->Font->Color=clRed;

Image1->Canvas->Font->Size=10;

TFontStyles tFontStyle;

Image1->Canvas->Font->Name="Times";

Image1->Canvas->TextOutA(p[y].X-4,p[y].Y-7,StrToInt(y));

y++;

}

if (y==N)

{

for (int f=0 ; f<N; f++)

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

{

if ((f!=j) && (Matrix[f][j]!=0))

{

DrawArrow(Image1->Canvas,p[j].X,p[j].Y,p[f].X,p[f].Y,10);

}

}

}

}

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

void __fastcall TForm1::N2Click(TObject *Sender)

{

FILE *open = fopen("Matrix.txt","r");

if(open==NULL)

{Memo1->Lines->Add("Фаил с матрицей не существует");}

else

{Memo1->Lines->LoadFromFile("Matrix.txt");}

}

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

void __fastcall TForm1::Exit1Click(TObject *Sender)

{

Close();

}

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

void __fastcall TForm1::New1Click(TObject *Sender)

{

Memo1->Clear();

}

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

void __fastcall TForm1::MOpenClick(TObject *Sender)

{

if (OpenDialog1->Execute())

Memo1->Lines->LoadFromFile(OpenDialog1->FileName);

StatusBar1->Panels->Items[0]->Text=OpenDialog1->FileName;

FILE *open = fopen(OpenDialog1->FileName.c_str(),"rb+");

if(open==NULL)

{ShowMessage("Фаил с матрицей не существует");return;}

fscanf(open,"%d %d",&N, &M);

if(N<=0)

{

ShowMessage("Отрицательное значение N");return;

}

if(M<=0)

{

ShowMessage("Отрицательное значение M");return;

}

int i,j,t;

Matrix = new int*[N];

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

{Matrix[i] = new int[M];}

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

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

{

fscanf(open,"%d",&t);

Matrix[i][j]=t;

if (Matrix[i][j]!=0)

{strok++;}

}

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

{

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

{

if(Matrix[i][j]!=0 && Matrix[j][i]!=0)

{ShowMessage("Неправильно задана матрица");return;}

}

}

fclose(open);

}

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

void __fastcall TForm1::Save1Click(TObject *Sender)

{

if (SaveDialog1->Execute())

Memo1->Lines->SaveToFile(SaveDialog1->FileName);

StatusBar1->Panels->Items[0]->Text=SaveDialog1->FileName;

}

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

void __fastcall TForm1::Print1Click(TObject *Sender)

{

if(PrintDialog1->Execute())

{TPrinter *Prntr = Printer();

Prntr->Orientation = poLandscape;

Form1->Print();}

}

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

void __fastcall TForm1::PrintSetup1Click(TObject *Sender)

{

if (PrinterSetupDialog1->Execute())

Form1->Print();

}

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

void __fastcall TForm1::FormCreate(TObject *Sender)

{

StringGrid1->RowHeights[0]=35;

StringGrid1->Cells[0][0]="Число предшествующих работ";

StringGrid1->Cells[1][0]="Шифр работ i-j ";

StringGrid1->Cells[2][0]="Время работы t.ij";

StringGrid1->Cells[3][0]="Ранее начало t.ij";

StringGrid1->Cells[4][0]="Ранее окончание t.ij";

StringGrid1->Cells[5][0]="Позднее начало t.ij";

StringGrid1->Cells[6][0]="Позднее окончание t.ij";

StringGrid1->Cells[7][0]="Общий резерв R.ij";

StringGrid1->Cells[8][0]="Частный резерв r.ij";

StringGrid1->Cells[9][0]="Критические работы *";

Image1->Canvas->MoveTo(0,0);

Image1->Canvas->LineTo(0,Image1->Height);

Image1->Canvas->LineTo(Image1->Width,Image1->Height);

Image1->Canvas->LineTo(Image1->Width,0);

Image1->Canvas->LineTo(0,0);

}

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

void __fastcall TForm1::StringGrid1DrawCell(TObject *Sender, int ACol,

int ARow, TRect &Rect, TGridDrawState State)

{

TStringGrid *SG=(TStringGrid *)Sender;

TCanvas *C=SG->Canvas;

C->FillRect(Rect);

::DrawText(C->Handle,SG->Cells[ACol][ARow].c_str(),SG->Cells[ACol][ARow].Length(),

&Rect,DT_CENTER|DT_WORDBREAK);

}

6. РЕЗУЛЬТАТ ПРОГРАММЫ

Вывод: Результаты машинного вычисления равны вычислениям приведенными в П5.Программа была протестирована на других примерах, на которых также не было обнаружено ошибок.

ЗАКЛЮЧЕНИЕ

При выполнении курсовой работы были закреплены знания практической реализации графа в ЭВМ.

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

СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ

1. Методические указания к выполнению курсовой работы

2. Березин Б.И., Березин С.Б. Начальный курс С и C++. -- М.: ДИАЛОГ-МИФИ, 1996.

3. Ляхович В.Ф. Руководство к решению задач по основам информатики и вычислительной техники. -- М.: Высшая школа, 1994.

4. Подбельский В.В., Фомин С.С. Программирование на языке Си. -- М.: Финансы и статистика, 1999

5. Евстигнеев В.А., Касьянов В.Н. Теория графов: алгоритмы обработки деревьев. --- Новосибирск: Наука, 1994.

6. Уилсон Р. Введение в теорию графов. --- М.: Мир, 1977.

7. Голубков Е.П. Использование системного анализа в принятии плановых решений. М.: Экономика, 2009.- 160 с.

8. Зыков А.А. Основы теории графов. М.: Наука, 2009. - 384с.

9. Кук Д., Бейз Г. Компьютерная математика: Пер. с англ. М.: Наука, 2009.- 384 с.

10. Браверман Э.М. Математические модели планирования и управления в экономических системах. М.: Наука, 2009. - 366 с.

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