finished first algo
This commit is contained in:
nihonium
parent
4f48405b54
commit
16d8843135
GPG key ID:
0924047F4136012C
12 changed files with 252 additions and 189 deletions
|
|
@ -16,7 +16,10 @@ warshall_run: warshall
|
|||
build_topological: topological.c
|
||||
$(CC) $(CFLAGS) topological.c -o topological
|
||||
topological_run: topological
|
||||
cat topological.data | ./topological
|
||||
@printf '===Без циклов:===\n'
|
||||
cat topological_good.data | ./topological
|
||||
@printf "\n===С циклом:===\n"
|
||||
cat topological_bad.data | ./topological
|
||||
|
||||
build_dijkstra: dijkstra.c
|
||||
$(CC) $(CFLAGS) dijkstra.c -o dijkstra
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/*O(n*log(n) + n), сортировка плюс проход по массиву заявок */
|
||||
/* O(n*log(n) + n), сортировка плюс проход по массиву заявок */
|
||||
|
||||
/* Структура для хранения зявки */
|
||||
/* Структура для хранения заявки */
|
||||
typedef struct application {
|
||||
int begin;
|
||||
int end;
|
||||
} app;
|
||||
|
||||
int vector_compare(const void *a, const void *b);
|
||||
app* solve(app* vector, unsigned int* NUM);
|
||||
int solve(app *vector, unsigned int N);
|
||||
|
||||
int main() {
|
||||
/* Число заявок */
|
||||
|
|
@ -26,13 +26,8 @@ int main() {
|
|||
/* Сортируем заявки по времени окончания */
|
||||
qsort(vector, N, sizeof(app), vector_compare);
|
||||
|
||||
/* Указатель на vector заменится, N изменится */
|
||||
vector = solve(vector, &N);
|
||||
|
||||
printf("Решение:\nКоличество выполненных заявок:%d\n", N);
|
||||
for (unsigned int i = 0; i < N; i++) {
|
||||
printf("%i %i\n", vector[i].begin, vector[i].end);
|
||||
}
|
||||
int result = solve(vector, N);
|
||||
printf("Количество выполненных заявок:%d\n", result);
|
||||
|
||||
free(vector);
|
||||
}
|
||||
|
|
@ -41,21 +36,16 @@ int vector_compare(const void *a, const void *b) {
|
|||
return ((const app *)a)->end - ((const app *)b)->end;
|
||||
}
|
||||
|
||||
/* Учитываем, что время не может быть отрицательным, тем самым
|
||||
избавляясь от надобности создавать три указателя или же
|
||||
прибегать к сложной сортировке */
|
||||
|
||||
app *solve(app *vector, unsigned int *N) {
|
||||
int solve(app *vector, unsigned int N) {
|
||||
/* Сохраняем начальное значение N */
|
||||
unsigned int N_init = *N;
|
||||
unsigned int result = N;
|
||||
/* Конец очередной заявки */
|
||||
int end = vector[0].end;
|
||||
for (unsigned int i = 1; i < N_init; i++) {
|
||||
for (unsigned int i = 1; i < N; i++) {
|
||||
if (end > vector[i].begin) {
|
||||
/* Удаляем заявки, время начала которых раньше времени конца */
|
||||
vector[i].begin = vector[i].end = -1;
|
||||
/* Изменяем количество заявок */
|
||||
(*N)--;
|
||||
/* Удаляем заявки, время начала которых раньше времени конца
|
||||
Изменяем счетчик заявок */
|
||||
(result)--;
|
||||
}
|
||||
else {
|
||||
/* Иначе, обновляем значение очередного конца */
|
||||
|
|
@ -63,17 +53,5 @@ app *solve(app *vector, unsigned int *N) {
|
|||
}
|
||||
}
|
||||
|
||||
app* vector_res = (app*)calloc(*N, sizeof(app));
|
||||
unsigned int j = 0;
|
||||
/* Два случая: нужные заявки в конце, нужные заявки в начале */
|
||||
for (unsigned int i = 0; i < N_init && j != *N; i++) {
|
||||
/* Если заявка не помечена недействительной, то вписываем ее в новый массив */
|
||||
if (vector[i].begin != -1) {
|
||||
vector_res[j] = vector[i];
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
||||
free(vector);
|
||||
return vector_res;
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,31 +4,51 @@
|
|||
|
||||
/* O(n^2) */
|
||||
|
||||
int* solve(int** massiv, int n, int x); // 0 вершина(можно заменить в коде)
|
||||
void route(int** massiv, int* problem, int n, int x);// для 0 вершины
|
||||
typedef struct vertex_s {
|
||||
int val;
|
||||
/* 0 - непройденная, 1 - пройденная */
|
||||
int sel;
|
||||
} vertex;
|
||||
|
||||
vertex *solve(unsigned int **adj, int n, int x); // 0 вершина(можно заменить в коде)
|
||||
void route(int **adj, vertex *res, int n, int x);// для 0 вершины
|
||||
|
||||
int main() {
|
||||
/* Количество вершин и номер нужной для отсчета вершины */
|
||||
int n;
|
||||
int x;
|
||||
|
||||
scanf("%d", &n);
|
||||
int **adj = (int**)calloc(n, sizeof(int*));
|
||||
unsigned int **adj = (unsigned int**)calloc(n, sizeof(unsigned int *));
|
||||
for (int i = 0; i < n; i++) {
|
||||
adj[i] = (int*)calloc(n, sizeof(int));
|
||||
adj[i] = (unsigned int*)calloc(n, sizeof(unsigned int));
|
||||
}
|
||||
/* В нашей матрице смежности 0 обозначает отсутствие пути из одной вершины в другую */
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
scanf("%d", &adj[i][j]);
|
||||
if (!adj[i][j])
|
||||
adj[i][j] = INT_MAX;
|
||||
}
|
||||
}
|
||||
|
||||
/* Номер вершины */
|
||||
#ifdef _DEBUG
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
printf("%d\t", adj[i][j]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
scanf("%d", &x);
|
||||
|
||||
int *res = solve(adj, n, x);
|
||||
vertex *res = solve(adj, n, x);
|
||||
|
||||
/* Вывод результата, расстояние от каждой вершины до данной с путем */
|
||||
route(adj, res, n, x);
|
||||
|
||||
/* Освобождаем память */
|
||||
for (int i = 0; i < n; i++) {
|
||||
free(adj[i]);
|
||||
}
|
||||
|
|
@ -37,60 +57,67 @@ int main() {
|
|||
free(res);
|
||||
}
|
||||
|
||||
int *solve(int **adj, int n, int x) {
|
||||
/* Пройденные вершины - 1, непройденные - 0 */
|
||||
int *vertics = (int*)calloc(n, sizeof(int));
|
||||
/* Вершины, из которых быстрее всего добраться */
|
||||
int *res = (int*)calloc(n, sizeof(int));
|
||||
vertex *solve(unsigned int **adj, int n, int x) {
|
||||
vertex *res = (vertex *)calloc(n, sizeof(vertex));
|
||||
|
||||
/* Количество пройденных вершин */
|
||||
int size = 1;
|
||||
/* Массив с длинами ребер, из которых выбираем */
|
||||
int* arr = (int*)calloc(n, sizeof(int));
|
||||
|
||||
/* Массив с длинами ребер, из которых выбираем для каждой вершины */
|
||||
unsigned int *distance = (unsigned int*)calloc(n, sizeof(unsigned int));
|
||||
|
||||
/* Начальная вершина */
|
||||
int vertic = x;
|
||||
int v = x;
|
||||
|
||||
/* Делаем начальную вершину выбранной */
|
||||
vertics[vertic] = 1;
|
||||
res[v].sel = 1;
|
||||
|
||||
/* Смотрим, как выбранная вершина соотносится с другими, заполняем массив расстояний */
|
||||
for (int i = 0; i < n; i++) {
|
||||
arr[i] = adj[vertic][i];
|
||||
res[i] = vertic;
|
||||
distance[i] = adj[v][i];
|
||||
res[i].val = v;
|
||||
}
|
||||
|
||||
/* Пока не переберем все вершины */
|
||||
while (size != n) {
|
||||
int min = INT_MAX;
|
||||
/* Минимальное расстояние до вершины, изначально - бесконечность */
|
||||
unsigned int min = INT_MAX;
|
||||
/* Номер очередной вершины */
|
||||
int k;
|
||||
for (int i = 0; i < n; i++) {
|
||||
/* Пропускаем пройденные вершины */
|
||||
if (vertics[i] == 1) {
|
||||
if (res[i].sel == 1) {
|
||||
continue;
|
||||
}
|
||||
/* Ищем вершину, до которой ближе всего (с номером k) */
|
||||
if (min > arr[i]) {
|
||||
min = arr[i];
|
||||
if (min >= distance[i]) {
|
||||
min = distance[i];
|
||||
k = i;
|
||||
}
|
||||
}
|
||||
/* Отмечаем найденную вершину "пройденной" */
|
||||
vertics[k] = 1;
|
||||
res[k].sel = 1;
|
||||
/* Смотрим, изменится ли наш массив рёбер, если будем "шагать" из выбранной вершины */
|
||||
for (int i = 0; i < n; i++) {
|
||||
/* Игнорируем пройденные вершины */
|
||||
if (vertics[i] == 1) {
|
||||
if (res[i].sel == 1) {
|
||||
continue;
|
||||
}
|
||||
/* Если из вершины k ближе до вершины i, то обновляем знaчение для i */
|
||||
if (arr[i] > min + adj[k][i]) {
|
||||
arr[i] = min + adj[k][i];
|
||||
res[i] = k;
|
||||
if (distance[i] > min + adj[k][i]) {
|
||||
distance[i] = min + adj[k][i];
|
||||
res[i].val = k;
|
||||
}
|
||||
}
|
||||
|
||||
size++;
|
||||
}
|
||||
free(vertics);
|
||||
free(arr);
|
||||
|
||||
free(distance);
|
||||
return res;
|
||||
}
|
||||
|
||||
void route(int **adj, int *res, int n, int x) {
|
||||
void route(int **adj, vertex *res, int n, int x) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
/* Игнорируем петли */
|
||||
if (i == x) {
|
||||
|
|
@ -100,17 +127,17 @@ void route(int **adj, int *res, int n, int x) {
|
|||
/* Суммарная длина */
|
||||
int sum = 0;
|
||||
/* Если есть прямой короткий путь, то выводим его */
|
||||
if (res[i] == x) {
|
||||
if (res[i].val == x) {
|
||||
sum = adj[x][i];
|
||||
printf("%d: %d-%d\n", i, i, x);
|
||||
}
|
||||
/* Иначе, последовательно идем по вершинам из res */
|
||||
else {
|
||||
printf("%d: %d-", i, i);
|
||||
while (res[w] != x) {
|
||||
sum += adj[res[w]][w];
|
||||
printf("%d-", res[w]);
|
||||
w = res[w];
|
||||
while (res[w].val != x) {
|
||||
sum += adj[res[w].val][w];
|
||||
printf("%d-", res[w].val);
|
||||
w = res[w].val;
|
||||
}
|
||||
sum += adj[x][w];
|
||||
printf("%d\n", x);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
8
|
||||
0 23 12 999 999 999 999 999
|
||||
23 0 25 999 22 999 999 35
|
||||
12 25 0 18 999 999 999 999
|
||||
999 999 18 0 999 20 999 999
|
||||
999 22 999 999 0 23 14 999
|
||||
999 999 999 20 23 0 24 999
|
||||
999 999 999 999 14 24 0 16
|
||||
999 35 999 999 999 999 16 0
|
||||
0 23 12 0 0 0 0 0
|
||||
23 0 25 0 22 0 0 35
|
||||
12 25 0 18 0 0 0 0
|
||||
0 0 18 0 0 20 0 0
|
||||
0 22 0 0 0 23 14 0
|
||||
0 0 0 20 23 0 24 0
|
||||
0 0 0 0 14 24 0 16
|
||||
0 35 0 0 0 0 16 0
|
||||
4
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Ребра */
|
||||
typedef struct edge {
|
||||
int begin;
|
||||
int end;
|
||||
|
|
@ -30,11 +31,13 @@ int main() {
|
|||
}
|
||||
/* Подсчет количества ребер в исходной матрице смежности */
|
||||
int size = count_edge(adj, n);
|
||||
/* Создаем массив с ребрами */
|
||||
Edge *vector = create_edge_vector(adj, n, size);
|
||||
/* Сортируем ребра по длине, сначала самые короткие */
|
||||
qsort(vector, size, sizeof(Edge), vector_compare);
|
||||
|
||||
int **res = solve(vector, size, n);
|
||||
/* Вывод списка имеющихся ребер по матрице смежности */
|
||||
print_edges(res, n);
|
||||
|
||||
/* Освобождаем память */
|
||||
|
|
@ -50,29 +53,34 @@ int main() {
|
|||
}
|
||||
|
||||
int **solve(Edge* vector, int size, int v) {
|
||||
/* size - ребра, v - вершины */
|
||||
/* Результирующее остовное дерево в виде матрицы смежности */
|
||||
int** res = (int**)calloc(v, sizeof(int*));
|
||||
for (int i = 0; i < v; i++) {
|
||||
res[i] = (int*)calloc(v, sizeof(int));
|
||||
}
|
||||
/* Массив с окраской каждой вершины */
|
||||
int* paint = (int*)calloc(v, sizeof(int));
|
||||
int *paint = (int*)calloc(v, sizeof(int));
|
||||
/* Количество рассмотренных вершин */
|
||||
int n = 0;
|
||||
/* Текущий цвет */
|
||||
int color = 1;
|
||||
/* Сохраненный цвет для перекрашивания (объединение двух компонент) */
|
||||
int saved_color;
|
||||
/* Пока не раскрашены все вершины */
|
||||
while (n != size ) {
|
||||
/* Проверяем на цикл */
|
||||
/* Проверяем, соединяет ли очередное ребро вершины из уже имеющейся компоненты одного цвета (цвет 0 - отсутствие цвета) */
|
||||
if ((paint[vector[n].begin] == paint[vector[n].end]) && (paint[vector[n].begin] != 0 || paint[vector[n].end] != 0)) {
|
||||
n++;
|
||||
continue;
|
||||
}
|
||||
else {
|
||||
/* Создание новой компоненты связности */
|
||||
if (paint[vector[n].begin] == 0 && paint[vector[n].end] == 0) {//обе вершины незакрашены
|
||||
/* Создание новой компоненты связности и добавление результата в результирующую матрицу смежности */
|
||||
/* Обе вершины бесцветные */
|
||||
if (paint[vector[n].begin] == 0 && paint[vector[n].end] == 0) {
|
||||
paint[vector[n].begin] = color;
|
||||
paint[vector[n].end] = color;
|
||||
|
||||
res[vector[n].begin][vector[n].end] = vector[n].len;
|
||||
/* Создаем новый цвет */
|
||||
color++;
|
||||
|
|
@ -80,10 +88,12 @@ int **solve(Edge* vector, int size, int v) {
|
|||
/* Присоединение неокрашенной вершины к существующей компоненте связности */
|
||||
else if (paint[vector[n].begin] == 0) {
|
||||
paint[vector[n].begin] = paint[vector[n].end];
|
||||
|
||||
res[vector[n].begin][vector[n].end] = vector[n].len;
|
||||
}
|
||||
else if (paint[vector[n].end] == 0) {
|
||||
paint[vector[n].end] = paint[vector[n].begin];
|
||||
|
||||
res[vector[n].begin][vector[n].end] = vector[n].len;
|
||||
}
|
||||
/* Объединение компонент связности */
|
||||
|
|
@ -91,7 +101,9 @@ int **solve(Edge* vector, int size, int v) {
|
|||
/* Сохраняем цвет той компоненты, которую будем перекрашивать */
|
||||
saved_color = paint[vector[n].end];
|
||||
paint[vector[n].end] = paint[vector[n].begin];
|
||||
|
||||
res[vector[n].begin][vector[n].end] = vector[n].len;
|
||||
|
||||
/* Перекрашиваем вторую компоненту в цвет первой */
|
||||
paint_vertices(vector, size, vector[n].end, saved_color, paint);
|
||||
}
|
||||
|
|
@ -101,12 +113,11 @@ int **solve(Edge* vector, int size, int v) {
|
|||
free(paint);
|
||||
return res;
|
||||
}
|
||||
void print_edges(int** massiv, int n) {
|
||||
printf("Решение:\n");
|
||||
void print_edges(int **adj, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = i + 1; j < n; j++) {
|
||||
if (massiv[i][j] != 0) {
|
||||
printf("%d-%d: %d\n", i, j, massiv[i][j]);
|
||||
if (adj[i][j] != 0) {
|
||||
printf("%d-%d: %d\n", i, j, adj[i][j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -146,7 +157,7 @@ int vector_compare(const void *a, const void *b) {
|
|||
|
||||
void paint_vertices(Edge* vector, int size, int need_vertix, int saved_color, int *paint) {
|
||||
for (int i = 0; i < size; i++) {
|
||||
/* Если текущая ребро выходит из нужной вершины */
|
||||
/* Если текущее ребро выходит из нужной вершины */
|
||||
if (vector[i].begin == need_vertix) {
|
||||
/* Если другой конец ребра - нужный по цвету (старый), то красим в цвет исходной вершины */
|
||||
if (paint[vector[i].end] == saved_color) {
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ typedef struct bhnode_s {
|
|||
int priority;
|
||||
/* Значение */
|
||||
Data val;
|
||||
Data to;
|
||||
|
||||
} bhnode;
|
||||
|
||||
|
|
@ -32,7 +33,7 @@ binary_heap *binary_heap_new(int maxsize) {
|
|||
void print_heap(binary_heap *bh) {
|
||||
printf("Numnodes: %d\n", bh->numnodes);
|
||||
for (int i = 1; i < bh->numnodes + 1; ++i) {
|
||||
printf("%d (priority: %d)\n", bh->body[i].val, bh->body[i].priority);
|
||||
printf("%d to %d (priority: %d)\n", bh->body[i].val, bh->body[i].to, bh->body[i].priority);
|
||||
}
|
||||
}
|
||||
void binary_heap_destroy(binary_heap *bh) {
|
||||
|
|
@ -60,7 +61,7 @@ int binary_heap_insert(binary_heap *bh, bhnode node) {
|
|||
}
|
||||
bh->body[++bh->numnodes] = node;
|
||||
for (size_t i = bh->numnodes;
|
||||
i> 1 && bh->body[i].priority > bh->body[i/2].priority;
|
||||
i> 1 && bh->body[i].priority < bh->body[i/2].priority;
|
||||
i /= 2) {
|
||||
binary_heap_swap(bh, i, i/2);
|
||||
}
|
||||
|
|
@ -78,9 +79,9 @@ void binary_heap_erase(binary_heap *bh) {
|
|||
size_t left = 2 * index;
|
||||
size_t right = left + 1;
|
||||
size_t largest = index;
|
||||
if (left <= bh->numnodes && bh->body[left].priority > bh->body[index].priority)
|
||||
if ((int) left <= bh->numnodes && bh->body[left].priority < bh->body[index].priority)
|
||||
largest = left;
|
||||
if (right <= bh->numnodes && bh->body[right].priority > bh->body[largest].priority)
|
||||
if ((int) right <= bh->numnodes && bh->body[right].priority < bh->body[largest].priority)
|
||||
largest = right;
|
||||
if (largest == index) break;
|
||||
binary_heap_swap(bh, index, largest);
|
||||
|
|
@ -92,4 +93,23 @@ void binary_heap_erase(binary_heap *bh) {
|
|||
}
|
||||
}
|
||||
|
||||
void binary_heap_recreate(binary_heap *bh) {
|
||||
size_t index = 1;
|
||||
for (;;) {
|
||||
size_t left = 2 * index;
|
||||
size_t right = left + 1;
|
||||
size_t largest = index;
|
||||
if ((int) left <= bh->numnodes && bh->body[left].priority < bh->body[index].priority)
|
||||
largest = left;
|
||||
if ((int) right <= bh->numnodes && bh->body[right].priority < bh->body[largest].priority)
|
||||
largest = right;
|
||||
if (largest == index) break;
|
||||
binary_heap_swap(bh, index, largest);
|
||||
index = largest;
|
||||
#ifdef DEBUG
|
||||
printf("###\n");
|
||||
print_heap(bh);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2,10 +2,11 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include "pqueue.c"
|
||||
|
||||
/* O(n^2), n - количество вершин, используем матрицу смежности */
|
||||
/* O(E*logV), E - количество вершин, V - число ребер, используем матрицу смежности и приоритетную очередь */
|
||||
|
||||
void solve(int **adj, int **res, int n);
|
||||
bhnode *solve(int **adj, int n);
|
||||
|
||||
int main() {
|
||||
int n;
|
||||
|
|
@ -18,23 +19,15 @@ int main() {
|
|||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
scanf("%d", &adj[i][j]);
|
||||
if (!adj[i][j])
|
||||
adj[i][j] = INT_MAX;
|
||||
}
|
||||
}
|
||||
|
||||
int **res = (int**)calloc(n, sizeof(int*));
|
||||
for (int i = 0; i < n; i++) {
|
||||
res[i] = (int*)calloc(n, sizeof(int));
|
||||
}
|
||||
|
||||
solve(adj, res, n);
|
||||
bhnode *res = solve(adj, n);
|
||||
|
||||
printf("Решение:\n");
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = i + 1; j < n; j++) {
|
||||
if (res[i][j] != 0) {
|
||||
printf("%i-%i: %i\n", i, j, res[i][j]);
|
||||
}
|
||||
}
|
||||
for (int i = 1; i < n; i++) {
|
||||
printf("%d-%d: %d\n", res[i].val, res[i].to, res[i].priority);
|
||||
}
|
||||
|
||||
/* Освобождаем память */
|
||||
|
|
@ -42,50 +35,50 @@ int main() {
|
|||
free(adj[i]);
|
||||
}
|
||||
free(adj);
|
||||
for (int i = 0; i < n; i++) {
|
||||
free(res[i]);
|
||||
}
|
||||
free(res);
|
||||
}
|
||||
|
||||
void solve(int **adj, int **res, int n) {
|
||||
/* Множество выбранных вершин, 1 - выбрано, 0 - не выбрано */
|
||||
int* set = (int *)calloc(n, sizeof(int));
|
||||
/* Выбрали первую вершину */
|
||||
set[0] = 1;
|
||||
bhnode *solve(int **adj, int n) {
|
||||
/* Приоритетная очередь */
|
||||
binary_heap *bh = binary_heap_new(n);
|
||||
|
||||
int i;
|
||||
|
||||
/* Результирующий массив */
|
||||
bhnode *res = (bhnode *)calloc(n, sizeof(bhnode));
|
||||
|
||||
/* Начинаем с нулевой вершины */
|
||||
|
||||
/* Количество выбранных вершин */
|
||||
int set_size = 1;
|
||||
while (set_size != n) {
|
||||
/* "Бесконечность" */
|
||||
int min = INT_MAX;
|
||||
/* Номер вершины */
|
||||
int k_i;
|
||||
int k_j;
|
||||
for (int i = 0; i < n; i++) {
|
||||
/* Если вершина еще не выбрана, то пропускаем её */
|
||||
if (!set[i]) {
|
||||
continue;
|
||||
}
|
||||
/* Рассматриваем выбранные вешины */
|
||||
for (int j = 0; j < n; j++) {
|
||||
/* Если вершина k_j выбрана, то пропускаем её, она уже в компоненте связности */
|
||||
if (set[j] == 1) {
|
||||
continue;
|
||||
}
|
||||
/* Выбираем кратчайшее ребро */
|
||||
if (min > adj[i][j] && adj[i][j]) {
|
||||
min = adj[i][j];
|
||||
k_i = i;
|
||||
k_j = j;
|
||||
}
|
||||
int size = 1;
|
||||
|
||||
/* Добавляем в очередь все вершины, кроме нулевой, с которой начали */
|
||||
for (i = 1; i < n; ++i) {
|
||||
binary_heap_insert(bh, (bhnode) {adj[0][i], i, 0});
|
||||
}
|
||||
|
||||
/* Пока очередь вершин не пуста */
|
||||
while (bh->numnodes) {
|
||||
bhnode current = binary_heap_fetch(bh);
|
||||
binary_heap_erase(bh);
|
||||
#ifdef _DEBUG
|
||||
printf("Extracted #%d to %d (%d)#\n", current.val, current.to, current.priority);
|
||||
#endif
|
||||
res[size++] = current;
|
||||
|
||||
/* Обновляем приоритеты в очереди */
|
||||
for (i = 1; i <= bh->numnodes; ++i) {
|
||||
if (adj[bh->body[i].val][current.val] < bh->body[i].priority) {
|
||||
#ifdef _DEBUG
|
||||
printf("Updated priority on %d (prev - to %d (%d)) to %d (%d)\n", bh->body[i].val, bh->body[i].to, bh->body[i].priority, current.val, adj[bh->body[i].val][current.val]);
|
||||
#endif
|
||||
bh->body[i].to = current.val;
|
||||
bh->body[i].priority = adj[bh->body[i].val][current.val];
|
||||
}
|
||||
}
|
||||
/* Добавляем вершину k_j в компоненту связности */
|
||||
set[k_j] = 1;
|
||||
/* Сохраняем в симметрическую матрицу результат */
|
||||
res[k_i][k_j] = adj[k_i][k_j];
|
||||
res[k_j][k_i] = adj[k_i][k_j];
|
||||
set_size++;
|
||||
/* Сортируем заново, с новыми приоритетами */
|
||||
binary_heap_recreate(bh);
|
||||
}
|
||||
free(set);
|
||||
binary_heap_destroy(bh);
|
||||
return res;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,18 +1,25 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
|
||||
/* O(n) - алгоритм Тарьяна */
|
||||
int* solve(int** massiv, int n);
|
||||
void dfs(int** massiv, int size, int* paint, int vertex, int* problem, int* len);
|
||||
|
||||
typedef struct vertex_s {
|
||||
int val;
|
||||
/* 0 - белый, 1 - серый, 2 - черный */
|
||||
int color;
|
||||
} vertex;
|
||||
|
||||
vertex *solve(int **adj, int n);
|
||||
void dfs(int **adj, int size, int v, vertex *res, int *len);
|
||||
|
||||
int main(){
|
||||
int n;
|
||||
|
||||
/* Считываем матрицу смежности */
|
||||
scanf("%d", &n);
|
||||
int **adj = (int**)calloc(n, sizeof(int*));
|
||||
int **adj = (int **)calloc(n, sizeof(int *));
|
||||
for (int i = 0; i < n; i++) {
|
||||
adj[i] = (int*)calloc(n, sizeof(int));
|
||||
adj[i] = (int *)calloc(n, sizeof(int));
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
|
|
@ -20,10 +27,11 @@ int main(){
|
|||
}
|
||||
}
|
||||
|
||||
int *res = solve(adj, n);
|
||||
vertex *res = solve(adj, n);
|
||||
|
||||
/* Выводим только номера вершин */
|
||||
for (int i = 0; i < n; ++i) {
|
||||
printf("%d ", res[i]);
|
||||
printf("%d ", res[i].val);
|
||||
}
|
||||
|
||||
/* Освобождаем память */
|
||||
|
|
@ -35,44 +43,50 @@ int main(){
|
|||
|
||||
}
|
||||
|
||||
int* solve(int** adj, int n) {
|
||||
int* res = (int*)calloc(n, sizeof(int));
|
||||
/* Список раскрасок вершин, 0 - белый, 1 - серый, 2 - черный */
|
||||
int* paint = (int*)calloc(n, sizeof(int));
|
||||
vertex *solve(int **adj, int n) {
|
||||
vertex *res = (vertex *)calloc(n, sizeof(vertex));
|
||||
|
||||
/* len можно использовать в качестве индекса, начинающегося с нуля (в отличие от n) */
|
||||
int len = n - 1;
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (paint[i] == 0) {
|
||||
dfs(adj, n, paint, i, res, &len);
|
||||
/* Запускаем обход в глубину, если вершина - белая, i - номер текущей вершины */
|
||||
if (res[i].color == 0) {
|
||||
dfs(adj, n, i, res, &len);
|
||||
}
|
||||
/* Если нашлась серая вершина на данном шаге, то граф цикличен */
|
||||
else if (paint[i] == 1) {
|
||||
else if (res[i].color == 1) {
|
||||
printf("Граф цикличен, решения не существует:\n");
|
||||
assert(0);
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
free(paint);
|
||||
return res;
|
||||
}
|
||||
void dfs(int **adj, int size, int* paint, int vertex, int* res, int* len) {
|
||||
if (paint[vertex] == 0) {
|
||||
void dfs(int **adj, int size, int v, vertex* res, int* len) {
|
||||
#ifdef _DEBUG
|
||||
printf("Current vertex is %d with color %d\n", v, res[v].color);
|
||||
#endif
|
||||
if (res[v].color == 0) {
|
||||
/* Красим белую вершину в серую */
|
||||
paint[vertex] = 1;
|
||||
res[v].color = 1;
|
||||
/* вызываем поиск в глубину для каждой вершины, в которую можем дойти из данной, рекурсивно */
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (adj[vertex][i] == 1) {
|
||||
dfs(adj, size, paint, i, res, len);
|
||||
if (adj[v][i] == 1) {
|
||||
dfs(adj, size, i, res, len);
|
||||
}
|
||||
}
|
||||
/* Заносим вершину в список для вывода */
|
||||
res[(*len)--] = vertex;
|
||||
res[(*len)--].val = v;
|
||||
#ifdef _DEBUG
|
||||
printf("Added vertex %d\n", v);
|
||||
#endif
|
||||
/* Красим вершину в черный, она обработана */
|
||||
paint[vertex] = 2;
|
||||
res[v].color = 2;
|
||||
|
||||
}
|
||||
/* Если нашлась серая вершина - граф цикличен */
|
||||
else if (paint[vertex] == 1) {
|
||||
else if (res[v].color == 1) {
|
||||
printf("Граф цикличен, решения не существует:\n");
|
||||
assert(0);
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
7
algo/first/topological_bad.data
Normal file
7
algo/first/topological_bad.data
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
6
|
||||
0 1 0 0 0 1
|
||||
1 0 0 0 0 0
|
||||
0 0 0 0 0 0
|
||||
1 0 1 0 0 0
|
||||
0 0 1 0 0 0
|
||||
0 0 0 0 0 0
|
||||
7
algo/first/topological_good.data
Normal file
7
algo/first/topological_good.data
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
6
|
||||
0 0 0 0 0 1
|
||||
1 0 0 0 0 0
|
||||
0 0 0 0 0 0
|
||||
1 0 1 0 0 0
|
||||
0 0 1 0 0 0
|
||||
0 0 0 0 0 0
|
||||
|
|
@ -3,16 +3,19 @@
|
|||
|
||||
/* O(n^3) */
|
||||
|
||||
void solve(int** adj, int n);
|
||||
void solve(int **adj, int n);
|
||||
/* Поэлементный ИЛИ над двумя строками, заменяет строку a */
|
||||
void vector_or(int **adj, int n, int a, int b);
|
||||
|
||||
int main() {
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
int **adj = (int**)calloc(n, sizeof(int*));
|
||||
int **adj = (int **)calloc(n, sizeof(int*));
|
||||
for (int i = 0; i < n; i++) {
|
||||
adj[i] = (int*)calloc(n, sizeof(int));
|
||||
}
|
||||
/* Считываем матрицу смежности. Вместо бесконечности выступает 9999 */
|
||||
|
||||
/* Считываем матрицу смежности */
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
scanf("%d", &adj[i][j]);
|
||||
|
|
@ -21,7 +24,6 @@ int main() {
|
|||
|
||||
solve(adj, n);
|
||||
|
||||
printf("Решение:\n");
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
printf("%d ", adj[i][j]);
|
||||
|
|
@ -38,14 +40,19 @@ int main() {
|
|||
}
|
||||
|
||||
void solve(int **adj, int n) {
|
||||
/* Перебираем все варианты добраться из i в j через k, если выходит короче, то перезаписываем значение i->j */
|
||||
for (int k = 0; k < n; k++) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
if (adj[i][k] + adj[k][j] < adj[i][j]) {
|
||||
adj[i][j] = adj[i][k] + adj[k][j];
|
||||
}
|
||||
int i, j;
|
||||
/* Идем по матрице, рассматриваем только ненулевые элементы и не на главной диагонали */
|
||||
for (i = 0; i < n; ++i) {
|
||||
for (j = 0; j < n; ++j) {
|
||||
if (adj[i][j] && (i != j)) {
|
||||
/* Поэлементно "ИЛИм" строки i и j, перезаписывая строку i */
|
||||
vector_or(adj, n, i, j);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vector_or(int **adj, int n, int a, int b) {
|
||||
for (int i = 0; i < n; ++i)
|
||||
adj[a][i] = adj[a][i] | adj[b][i];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,5 @@
|
|||
8
|
||||
0 23 12 9999 9999 9999 9999 9999
|
||||
23 0 25 9999 22 9999 9999 35
|
||||
12 25 0 18 9999 9999 9999 9999
|
||||
9999 9999 18 0 9999 20 9999 9999
|
||||
9999 22 9999 9999 0 23 14 9999
|
||||
9999 9999 9999 20 23 0 24 9999
|
||||
9999 9999 9999 9999 14 24 0 16
|
||||
9999 35 9999 9999 9999 9999 16 0
|
||||
4
|
||||
1 1 0 1
|
||||
1 1 0 0
|
||||
1 0 1 0
|
||||
1 0 0 0
|
||||
|
|
|
|||
Reference in a new issue