nihonium/mipt_clang
Archived
1
0
Fork 0
Code Releases Activity

algo

Browse source
This commit is contained in:
nihonium 2022-04-08 12:14:50 +03:00
parent b0ec253b30
commit adba0bfac6
Signed by: nihonium
GPG key ID: 0924047F4136012C
10 changed files with 466 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

79
algo/first/application_select.c Normal file
View file

@ -0,0 +1,79 @@
#include <stdio.h>
#include <stdlib.h>
/*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 main() {
/* Число заявок */
unsigned int N;
scanf("%d", &N);
app* vector = (app*)calloc(N, sizeof(app));
/* Считываем информацию о заявках, начало-конец */
for (unsigned int i = 0; i < N; i++) {
scanf("%d %d", &vector[i].begin, &vector[i].end);
}
/* Сортируем заявки по времени окончания */
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);
}
free(vector);
}
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) {
/* Сохраняем начальное значение N */
unsigned int N_init = *N;
/* Конец очередной заявки */
int end = vector[0].end;
for (unsigned int i = 1; i < N_init; i++) {
if (end > vector[i].begin) {
/* Удаляем заявки, время начала которых раньше времени конца */
vector[i].begin = vector[i].end = -1;
/* Изменяем количество заявок */
(*N)--;
}
else {
/* Иначе, обновляем значение очередного конца */
end = vector[i].end;
}
}
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;
}

15
algo/first/application_select.data Normal file
View file

@ -0,0 +1,15 @@
# 1
5
1 2
3 6
3 4
5 7
1 7
# 2
3
1 5
2 3
3 4

120
algo/first/dijkstra.c Normal file
View file

@ -0,0 +1,120 @@
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
/* O(n^2) */
int* solve(int** massiv, int n, int x); // 0 вершина(можно заменить в коде)
void route(int** massiv, int* problem, int n, int x);// для 0 вершины
int main() {
int n;
int x;
scanf("%d", &n);
int **adj = (int**)calloc(n, sizeof(int*));
for (int i = 0; i < n; i++) {
adj[i] = (int*)calloc(n, sizeof(int));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &adj[i][j]);
}
}
/* Номер вершины */
scanf("%d", &x);
int *res = solve(adj, n, x);
route(adj, res, n, x);
for (int i = 0; i < n; i++) {
free(adj[i]);
}
free(adj);
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));
/* Количество пройденных вершин */
int size = 1;
/* Массив с длинами ребер, из которых выбираем */
int* arr = (int*)calloc(n, sizeof(int));
/* Начальная вершина */
int vertic = x;
/* Делаем начальную вершину выбранной */
vertics[vertic] = 1;
for (int i = 0; i < n; i++) {
arr[i] = adj[vertic][i];
res[i] = vertic;
}
while (size != n) {
int min = INT_MAX;
int k;
for (int i = 0; i < n; i++) {
/* Пропускаем пройденные вершины */
if (vertics[i] == 1) {
continue;
}
/* Ищем вершину, до которой ближе всего (с номером k) */
if (min > arr[i]) {
min = arr[i];
k = i;
}
}
/* Отмечаем найденную вершину "пройденной" */
vertics[k] = 1;
/* Смотрим, изменится ли наш массив рёбер, если будем "шагать" из выбранной вершины */
for (int i = 0; i < n; i++) {
/* Игнорируем пройденные вершины */
if (vertics[i] == 1) {
continue;
}
/* Если из вершины k ближе до вершины i, то обновляем знaчение для i */
if (arr[i] > min + adj[k][i]) {
arr[i] = min + adj[k][i];
res[i] = k;
}
}
size++;
}
free(vertics);
free(arr);
return res;
}
void route(int **adj, int *res, int n, int x) {
for (int i = 0; i < n; i++) {
/* Игнорируем петли */
if (i == x) {
continue;
}
int w = i;
/* Суммарная длина */
int sum = 0;
/* Если есть прямой короткий путь, то выводим его */
if (res[i] == 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];
}
sum += adj[x][w];
printf("%d\n", x);
}
printf("Расстояние: %d\n###\n", sum);
}
}

10
algo/first/dijkstra.data Normal file
View file

@ -0,0 +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
4

91
algo/first/prim.c Normal file
View file

@ -0,0 +1,91 @@
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
/* O(n^2), n - количество вершин, используем матрицу смежности */
void solve(int **adj, int **res, int n);
int main() {
int n;
scanf("%d", &n);
int **adj = (int**)calloc(n, sizeof(int*));
for (int i = 0; i < n; i++) {
adj[i] = (int*)calloc(n, sizeof(int));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &adj[i][j]);
}
}
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);
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 = 0; i < n; i++) {
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;
/* Количество выбранных вершин */
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;
}
}
}
/* Добавляем вершину 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++;
}
free(set);
}

6
algo/first/prim.data Normal file
View file

@ -0,0 +1,6 @@
5
0 9 75 0 0
9 0 95 19 42
75 95 0 51 66
0 19 51 0 31
0 42 66 31 0

78
algo/first/topological.c Normal file
View file

@ -0,0 +1,78 @@
#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);
int main(){
int n;
scanf("%d", &n);
int **adj = (int**)calloc(n, sizeof(int*));
for (int i = 0; i < n; i++) {
adj[i] = (int*)calloc(n, sizeof(int));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &adj[i][j]);
}
}
int *res = solve(adj, n);
for (int i = 0; i < n; ++i) {
printf("%d ", res[i]);
}
/* Освобождаем память */
for (int i = 0; i < n; i++) {
free(adj[i]);
}
free(adj);
free(res);
}
int* solve(int** adj, int n) {
int* res = (int*)calloc(n, sizeof(int));
/* Список раскрасок вершин, 0 - белый, 1 - серый, 2 - черный */
int* paint = (int*)calloc(n, sizeof(int));
int len = n - 1;
for (int i = 0; i < n; i++) {
if (paint[i] == 0) {
dfs(adj, n, paint, i, res, &len);
}
/* Если нашлась серая вершина на данном шаге, то граф цикличен */
else if (paint[i] == 1) {
printf("Граф цикличен, решения не существует:\n");
assert(0);
}
}
free(paint);
return res;
}
void dfs(int **adj, int size, int* paint, int vertex, int* res, int* len) {
if (paint[vertex] == 0) {
/* Красим белую вершину в серую */
paint[vertex] = 1;
/* вызываем поиск в глубину для каждой вершины, в которую можем дойти из данной, рекурсивно */
for (int i = 0; i < size; i++) {
if (adj[vertex][i] == 1) {
dfs(adj, size, paint, i, res, len);
}
}
/* Заносим вершину в список для вывода */
res[(*len)--] = vertex;
/* Красим вершину в черный, она обработана */
paint[vertex] = 2;
}
/* Если нашлась серая вершина - граф цикличен */
else if (paint[vertex] == 1) {
printf("Граф цикличен, решения не существует:\n");
assert(0);
}
}

7
algo/first/topological.data Normal file
View 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

51
algo/first/warshall.c Normal file
View file

@ -0,0 +1,51 @@
#include <stdio.h>
#include <stdlib.h>
/* O(n^3) */
void solve(int** adj, int n);
int main() {
int n;
scanf("%d", &n);
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]);
}
}
solve(adj, n);
printf("Решение:\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", adj[i][j]);
}
printf("\n");
}
/* Освобождаем память */
for (int i = 0; i < n; i++) {
free(adj[i]);
}
free(adj);
}
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];
}
}
}
}
}

9
algo/first/warshall.data Normal file
View file

@ -0,0 +1,9 @@
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