Приложение Текст программы

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <string.h>

#define NMAX 20

typedef struct edge

{

char c;

int vertex1,vertex2;

}

edge;

void output_message(int n)

{

char* msg[] = {"",

/* 1 */ "Введите количество вершин (от 2 до ",

/* 2 */ "Введите ребра графа (вершины нумеруются с 1)\n",

/* 3 */ "Матрица смежности начального графа\n",

/* 4 */ "Соответствие ребер исходного графа вершинам конечного графа:\n",

/* 5 */ "Матрица смежности получившегося графа\n",

/* 6 */ "Введите номер вершины в конечном графе\n",

/* 7 */ "Номера вершин, расстояние до которых от заданной равно 2:\n",

/* 8 */ "Нужных вершин нет",

/* 9 */ "Ошибка: входной файл пуст",

/* 10 */"Ошибка: количество вершин должно быть от 2 до ",

/* 11 */"Ошибка: ребро должно содержать 2 вершины",

/* 12 */"Ошибка: номер вершины должен быть от 1 до ",

/* 13 */"Ошибка: получившийся граф не содержит вершин",

/* 14 */"Ошибка: не введен номер вершины в конечном графе",

/* 15 */"Решение прекращено",

/* 16 */"Предупреждение: было дублирование ребер (игнорировалось)\n"

};

printf("\n%s", msg[n]);

}

int get_edges_count(int* adj_matrix, int vertex_count)

{

int edges_count = 0;

int i,j;

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

{

for (j=i+1; j<vertex_count; j++)

{

if (adj_matrix[i*vertex_count+j]==1)

edges_count++;

}

}

return edges_count;

}

/****************************************************

0 - без ошибок

1 - полученный граф не содержит вершин

****************************************************/

int trans_graph(int* gr_adj_matrix, int gr_vertex_count, int** gr1_adj_matrix, int* gr1_vertex_count, edge** edges)

{

int i,j,edge_num;

*gr1_vertex_count = get_edges_count(gr_adj_matrix, gr_vertex_count);

if (*gr1_vertex_count==0)

{

return 1;

}

*edges = (edge*)malloc(sizeof(edge)*(*gr1_vertex_count));

edge_num=0;

/* составляем список ребер в начальном графе */

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

{

for (j=i+1; j<gr_vertex_count; j++)

{

if (gr_adj_matrix[i*gr_vertex_count+j]==1)

{

(*edges)[edge_num].c = 'a' + edge_num;

(*edges)[edge_num].vertex1=i;

(*edges)[edge_num++].vertex2=j;

}

}

}

*gr1_adj_matrix = (int*)malloc(sizeof(int)*(*gr1_vertex_count)*(*gr1_vertex_count));

memset(*gr1_adj_matrix,0,sizeof(int)*(*gr1_vertex_count)*(*gr1_vertex_count));

/* заполняем матрицу смежности конечного графа */

for (i=0; i<*gr1_vertex_count; i++)

{

for (j=i+1; j<*gr1_vertex_count; j++)

{

if ((*edges)[i].vertex1==(*edges)[j].vertex1 ||

(*edges)[i].vertex1==(*edges)[j].vertex2 ||

(*edges)[i].vertex2==(*edges)[j].vertex1 ||

(*edges)[i].vertex2==(*edges)[j].vertex2)

{

(*gr1_adj_matrix)[i*(*gr1_vertex_count)+j] = 1;

(*gr1_adj_matrix)[j*(*gr1_vertex_count)+i] = 1;

}

}

}

return 0;

}

/***********************************

0 - ввод завершен без ошибок

1 - ввод завершен, но было повторение ребер (игнорировалось)

2 - ошибка: входной файл пуст (ввод прекращен)

3 - ошибка: недопустимое количество вершин (ввод прекращен)

4 - ошибка: недопустимое количество вершин в ребре (ввод прекращен)

5 - ошибка: недопустимый номер вершины (ввод прекращен)

************************************/

int input_graph(int* n, int** adj_matrix)

{

int v1,v2;

int kz;

int wd;

output_message(1);

printf("%d)\n", NMAX);

if (scanf("%d", n) != 1)

return 2;

if (*n<2 || *n>NMAX)

return 3;

*adj_matrix = (int*)malloc(sizeof(int)*(*n)*(*n));

memset(*adj_matrix,0,sizeof(int)*(*n)*(*n));

wd=0;

output_message(2);

do

{

kz = scanf("%d", &v1);

if (kz==1)

{

if (v1 != -1)

{

kz = scanf("%d", &v2);

if ((kz != 1) || (v2==-1))

return 4;

if ((v1<1) || (v1>*n) || (v2<1) || (v2>*n))

return 5;

if ((*adj_matrix)[(v1-1)*(*n)+v2-1]==1)

wd=1;

(*adj_matrix)[(v1-1)*(*n)+v2-1]=1;

(*adj_matrix)[(v2-1)*(*n)+v1-1]=1;

}

else

kz = -1;

}

}

while (kz>0);

return wd;

}

void calc_distances(int vertex_count, int* adj_matrix, int** distances, int dest_vertex)

{

int i,j;

int flag;

*distances = (int*)malloc(sizeof(int)*vertex_count);

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

{

(*distances)[i]=-1;

}

(*distances)[dest_vertex-1] = 0;

flag = 1;

while (flag)

{

flag = 0;

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

{

if ((*distances)[i]>=0)

{

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

{

if ((adj_matrix[j*vertex_count+i]==1) && (((*distances)[j]>(*distances)[i]+1) || ((*distances)[j]==-1)))

{

flag = 1;

(*distances)[j] = (*distances)[i]+1;

}

}

}

}

}

}

/************************************************************/

/* Курсовая работа */

/* по алгоритмическим языкам и программированию */

/************************************************************/

void main()

{

int gr_vertex_count;

int* gr_adj_matrix;

int* gr1_adj_matrix;

int gr1_vertex_count;

int i,j;

int dest_vertex;

int* distances;

int vertex_count;

edge* edges;

int kz;

if ((kz = input_graph(&gr_vertex_count, &gr_adj_matrix)) > 1)

{

output_message(kz+7);

if (kz==3)

printf("%d\n",NMAX);

if (kz==5)

printf("%d\n",gr_vertex_count);

output_message(15);

goto exit;

}

else

{

if (kz==1)

output_message(16);

output_message(3);

printf("%3s", "");

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

{

printf("%-3d", i+1);

}

printf("\n");

printf("%2s","");

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

{

printf("---");

}

printf("\n");

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

{

printf("%-d| ", i+1);

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

{

printf("%-3d",gr_adj_matrix[i*gr_vertex_count+j]);

}

printf("\n");

}

getch();

if ((kz=trans_graph(gr_adj_matrix, gr_vertex_count, &gr1_adj_matrix, &gr1_vertex_count, &edges))>0)

{

output_message(kz+12);

output_message(15);

goto exit;

}

output_message(4);

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

{

printf("%d %d:%c (%d)\n", edges[i].vertex1+1, edges[i].vertex2+1, edges[i].c, i+1);

}

output_message(5);

printf(" ");

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

{

printf("%c ", edges[i].c);

}

printf("\n");

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

{

printf("%c ", edges[i].c);

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

{

printf("%d ", gr1_adj_matrix[i*gr1_vertex_count+j]);

}

printf("\n");

}

printf("\n");

if(get_edges_count(gr1_adj_matrix, gr1_vertex_count)==0)

{

printf("\n В Получившемс графе отсутствуют рёбра");

goto exit;

}

if (get_edges_count(gr1_adj_matrix, gr1_vertex_count)==1)

{

printf("\n Недостаточно рёбер");

goto exit;

}

output_message(6);

if (scanf("%d", &dest_vertex) != 1)

{

output_message(14);

output_message(15);

goto exit;

}

if ((dest_vertex<1) || (dest_vertex>gr1_vertex_count))

{

output_message(12);

printf("%d\n",gr1_vertex_count);

output_message(15);

goto exit;

}

calc_distances(gr1_vertex_count, gr1_adj_matrix, &distances, dest_vertex);

output_message(7);

vertex_count = 0;

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

{

if (distances[i]==2)

{

printf("%d ", i+1);

vertex_count++;

}

}

if (vertex_count==0)

output_message(8);

}

exit:

free(gr_adj_matrix);

free(gr1_adj_matrix);

free(distances);

free(edges);

getch();

}

27