├── Lista 1 ├── A.c ├── B1.c ├── B2.c ├── C.c ├── D.c ├── E.c ├── F.c ├── G.c ├── H1.c ├── H2.c └── I.c ├── Lista 2 ├── A.c ├── B.c ├── C.c ├── D.c └── E.c ├── Lista 3 ├── A.c ├── B.c ├── C.c ├── D.c ├── E.c ├── F.c └── G.c ├── Lista 4 ├── A.c ├── B.c ├── C.c ├── D.c ├── E.c ├── F.c └── G.c ├── Lista 5 ├── A.c ├── B.c ├── C.c ├── D.c ├── E.c ├── F.c ├── G.c ├── H.c └── I.c ├── Lista 6 ├── A.c └── B.c ├── Lista 7 ├── A.c ├── B.c ├── C.c ├── D.c ├── E.c ├── F.c └── G.c ├── Prova 1 ├── 10pontos (3).c ├── 15pontos (2).c └── 75pontos (2).c ├── README.md └── Trabalho ├── A.c ├── Aeroporto_4.c ├── Transmissão de energia.c └── caminho_das_pontes2.c /Lista 1/A.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int main() 5 | { 6 | printf("Ola Mundo\n"); 7 | 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /Lista 1/B1.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int main() 5 | { 6 | int a, b; 7 | scanf("%d\n%d", &a, &b); 8 | printf("%d\n", a + b); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /Lista 1/B2.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int main() 5 | { 6 | int n, s = 0; 7 | scanf("%d", &n); 8 | while (n--) 9 | { 10 | int x; 11 | scanf("%d", &x); 12 | s += x; 13 | } 14 | printf("%d\n", s); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /Lista 1/C.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int main() 5 | { 6 | int n = 0, temp; 7 | while (scanf("%d", &temp) == 1) n++; 8 | printf("%d\n", n); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /Lista 1/D.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | 5 | int main() 6 | { 7 | char s[4]; 8 | int ans = 0; 9 | for (int i = 0, c = 0; scanf("%s", s) == 1; i++, c = (i % 10 == 0 ? 0 : c)) 10 | { 11 | if (strcmp(s, "sim") == 0) 12 | { 13 | c++; 14 | ans += (c == 2); 15 | } 16 | } 17 | printf("%d\n", ans); 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /Lista 1/E.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | 5 | typedef char str[101]; 6 | 7 | typedef struct Vector 8 | { 9 | int size, capacity; 10 | str *data; 11 | } Vector; 12 | 13 | Vector *newVector() 14 | { 15 | Vector *vector = (Vector *)malloc(sizeof(Vector)); 16 | vector->capacity = 16; 17 | vector->size = 0; 18 | vector->data = (str *)malloc(vector->capacity * sizeof(str)); 19 | 20 | return vector; 21 | } 22 | 23 | void deleteVector(Vector *vector) 24 | { 25 | free(vector->data); 26 | free(vector); 27 | } 28 | 29 | char *vectorSpaceToAdd(Vector *vector) 30 | { 31 | if (vector->size == vector->capacity) 32 | { 33 | vector->capacity = vector->capacity << 1; 34 | vector->data = realloc(vector->data, vector->capacity * sizeof(str)); 35 | } 36 | return vector->data[vector->size++]; 37 | } 38 | 39 | char *vectorPop(Vector *vector) 40 | { 41 | if (!vector->size) 42 | return "NULL"; 43 | return vector->data[--vector->size]; 44 | } 45 | 46 | int main() 47 | { 48 | char mode[10]; 49 | Vector *vector = newVector(); 50 | while (scanf("%s", mode) != EOF) 51 | { 52 | if (strcmp(mode, "inserir") == 0) 53 | scanf(" %[^\n]", vectorSpaceToAdd(vector)); 54 | else 55 | printf("%s\n", vectorPop(vector)); 56 | } 57 | deleteVector(vector); 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /Lista 1/F.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int countDigit(char s[], char d, int i) 5 | { 6 | if (s[i] == '\0') 7 | return 0; 8 | return (s[i] == d) + countDigit(s, d, i + 1); 9 | } 10 | 11 | int main() 12 | { 13 | char s[20]; 14 | scanf("%s", s); 15 | printf("%d\n", countDigit(s, '7', 0)); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /Lista 1/G.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | typedef struct Vector 5 | { 6 | int size, capacity; 7 | int *data; 8 | } Vector; 9 | 10 | Vector *newVector() 11 | { 12 | Vector *vector = (Vector *)malloc(sizeof(Vector)); 13 | vector->capacity = 16; 14 | vector->size = 0; 15 | vector->data = (int *)malloc(vector->capacity * sizeof(int)); 16 | 17 | return vector; 18 | } 19 | 20 | void deleteVector(Vector *vector) 21 | { 22 | free(vector->data); 23 | free(vector); 24 | } 25 | 26 | void vectorPush(Vector *vector, int n) 27 | { 28 | if (vector->size == vector->capacity) 29 | { 30 | vector->capacity = vector->capacity << 1; 31 | vector->data = realloc(vector->data, vector->capacity * sizeof(int)); 32 | } 33 | vector->data[vector->size++] = n; 34 | } 35 | 36 | void solve(Vector *v, int m, int s, int i) 37 | { 38 | if (i == v->size) 39 | return; 40 | s += v->data[i]; 41 | if (s > m) 42 | { 43 | solve(v, m, 0, i + 1); 44 | printf("%d\n", v->data[i]); 45 | } 46 | else 47 | solve(v, m, s, i + 1); 48 | } 49 | 50 | int main() 51 | { 52 | Vector *v = newVector(); 53 | for (;;) 54 | { 55 | int n; 56 | scanf(" %d", &n); 57 | if (!n) 58 | break; 59 | vectorPush(v, n); 60 | } 61 | 62 | int m; 63 | scanf(" %d", &m); 64 | solve(v, m, 0, 0); 65 | 66 | return 0; 67 | } 68 | -------------------------------------------------------------------------------- /Lista 1/H1.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | 5 | int main() 6 | { 7 | int n; 8 | scanf("%d", &n); 9 | while (n--) 10 | { 11 | char s[101]; 12 | scanf("%s", s); 13 | int sum = 0; 14 | for (int i = 0; s[i] != '\0' && i < 100; i++) 15 | sum += ('0' <= s[i] && s[i] <= '9' ? s[i] - '0' : 0); 16 | printf("%d\n", sum); 17 | } 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /Lista 1/H2.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | 5 | int main() 6 | { 7 | for (int k = 1, n; scanf("%d", &n) != EOF; k++) 8 | { 9 | char name[21]; 10 | int grade = -1; 11 | while (n--) 12 | { 13 | char s[21]; 14 | int g; 15 | scanf("%s %d", s, &g); 16 | if (grade == -1 || g < grade || (g == grade && strcmp(name, s) < 0)) 17 | { 18 | grade = g; 19 | strcpy(name, s); 20 | } 21 | } 22 | printf("Instancia %d\n", k); 23 | printf("%s\n\n", name); 24 | } 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /Lista 1/I.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | 5 | int v[1000001]; 6 | 7 | int main() 8 | { 9 | int n; 10 | scanf("%d", &n); 11 | 12 | while (n--) 13 | { 14 | int x; 15 | scanf("%d", &x); 16 | 17 | v[x]++; 18 | } 19 | int ans = 0; 20 | for (int i = 0; i < 1000001; i++) 21 | ans += v[i] > 0; 22 | printf("%d\n", ans); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /Lista 2/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void bubblesort(int *v, int size) 5 | { 6 | for (int i = 0; i < size - 1; i++) 7 | for (int j = 1; j < size; j++) 8 | if (v[j - 1] > v[j]) 9 | { 10 | int t = v[j - 1]; 11 | v[j - 1] = v[j]; 12 | v[j] = t; 13 | } 14 | } 15 | 16 | int main() 17 | { 18 | int v[1001], size; 19 | for (size = 0; scanf(" %d", v + size) == 1; size++); 20 | bubblesort(v, size); 21 | for (int i = 0; i < size; i++) 22 | printf("%d%c", v[i], (i == size - 1 ? '\n' : ' ')); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /Lista 2/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define SWAP(a, b) \ 5 | int t = a; \ 6 | a = b; \ 7 | b = t; 8 | 9 | void sort(int *v, int size) 10 | { 11 | for (int i = 0; i < size - 1; i++) 12 | { 13 | int min = i; 14 | for (int j = i + 1; j < size; j++) 15 | if (v[j] < v[min]) 16 | min = j; 17 | SWAP(v[i], v[min]); 18 | } 19 | } 20 | 21 | int main() 22 | { 23 | int v[1001], size; 24 | for (size = 0; scanf(" %d", v + size) == 1; size++); 25 | sort(v, size); 26 | for (int i = 0; i < size; i++) 27 | printf("%d%c", v[i], (i == size - 1 ? '\n' : ' ')); 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /Lista 2/C.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define SWAP(a, b) \ 5 | int t = a; \ 6 | a = b; \ 7 | b = t; 8 | 9 | void sort(int *v, int size) 10 | { 11 | for (int i = 1; i < size; i++) 12 | { 13 | for (int j = i; j > 0; j--) 14 | if (v[j - 1] > v[j]) 15 | { 16 | SWAP(v[j - 1], v[j]); 17 | } 18 | } 19 | } 20 | 21 | int main() 22 | { 23 | int v[1001], size; 24 | for (size = 0; scanf(" %d", v + size) == 1; size++); 25 | sort(v, size); 26 | for (int i = 0; i < size; i++) 27 | printf("%d%c", v[i], (i == size - 1 ? '\n' : ' ')); 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /Lista 2/D.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define SWAP(a, b) \ 5 | int t = a; \ 6 | a = b; \ 7 | b = t; 8 | 9 | void sort(int *v, int size) 10 | { 11 | for (int i = 1, j; i < size; i++) 12 | { 13 | int t = v[i]; 14 | for (j = i; j > 0 && t < v[j - 1]; j--) 15 | v[j] = v[j - 1]; 16 | v[j] = t; 17 | } 18 | } 19 | 20 | int main() 21 | { 22 | int v[50001], size; 23 | for (size = 0; scanf(" %d", v + size) == 1; size++); 24 | sort(v, size); 25 | for (int i = 0; i < size; i++) 26 | printf("%d%c", v[i], (i == size - 1 ? '\n' : ' ')); 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /Lista 2/E.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct 5 | { 6 | int key; 7 | char value[30]; 8 | } Instruction; 9 | 10 | #define T Instruction 11 | #define LESS(a, b) a.key < b.key 12 | #define SWAP(a, b) \ 13 | T t = a; \ 14 | a = b; \ 15 | b = t; 16 | 17 | void sort(T *v, int size) 18 | { 19 | for (int i = size - 1; i > 0; i--) 20 | if (LESS(v[i], v[0])) 21 | { 22 | SWAP(v[0], v[i]); 23 | } 24 | for (int i = 2, j; i < size; i++) 25 | { 26 | T t = v[i]; 27 | for (j = i; LESS(t, v[j - 1]); j--) 28 | v[j] = v[j - 1]; 29 | v[j] = t; 30 | } 31 | } 32 | 33 | char *find(T *v, int size, int key) 34 | { 35 | int l = 0, r = size - 1; 36 | while (l <= r) 37 | { 38 | int m = (l + r) / 2; 39 | if (v[m].key == key) 40 | return v[m].value; 41 | 42 | if (v[m].key > key) 43 | r = m - 1; 44 | else 45 | l = m + 1; 46 | } 47 | return "undefined"; 48 | } 49 | 50 | int main() 51 | { 52 | int n; 53 | scanf(" %d", &n); 54 | T *v = (T *)malloc(n * sizeof(T)); 55 | 56 | for (int i = 0; i < n; i++) 57 | scanf("%d %s", &v[i].key, v[i].value); 58 | 59 | sort(v, n); 60 | 61 | for (int code; scanf(" %d", &code) == 1;) 62 | printf("%s\n", find(v, n, code)); 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /Lista 3/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void printarr(int *v, int n) 5 | { 6 | for (int i = 0; i < n; i++) 7 | printf("%d%c", v[i], (i == n - 1 ? '\n' : ' ')); 8 | } 9 | 10 | void merge(int *a, int sizea, int *b, int sizeb) 11 | { 12 | int *temp = (int *)malloc((sizea + sizeb) * sizeof(int)); 13 | int i = 0, j = 0, k = 0; 14 | for (; i < sizea && j < sizeb; k++) 15 | { 16 | if (a[i] <= b[j]) 17 | temp[k] = a[i++]; 18 | else 19 | temp[k] = b[j++]; 20 | } 21 | 22 | while (i < sizea) 23 | temp[k++] = a[i++]; 24 | while (j < sizeb) 25 | temp[k++] = b[j++]; 26 | 27 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 28 | a[i] = temp[k]; 29 | 30 | free(temp); 31 | } 32 | 33 | int ans[800008], v[100001]; 34 | 35 | int main() 36 | { 37 | int n = 0; 38 | for (int i = 0; i < 8; i++) 39 | { 40 | int vsize = 0; 41 | scanf(" %d", &vsize); 42 | for (int j = 0; j < vsize; j++) 43 | scanf(" %d", &v[j]); 44 | merge(ans, n, v, vsize); 45 | n += vsize; 46 | } 47 | 48 | printarr(ans, n); 49 | 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /Lista 3/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void printarr(int *v, int n) 5 | { 6 | for (int i = 0; i < n; i++) 7 | printf("%d%c", v[i], (i == n - 1 ? '\n' : ' ')); 8 | } 9 | 10 | void merge(int *a, int sizea, int *b, int sizeb) 11 | { 12 | int *temp = (int *)malloc((sizea + sizeb) * sizeof(int)); 13 | int i = 0, j = 0, k = 0; 14 | for (; i < sizea && j < sizeb; k++) 15 | { 16 | if (a[i] <= b[j]) 17 | temp[k] = a[i++]; 18 | else 19 | temp[k] = b[j++]; 20 | } 21 | 22 | while (i < sizea) 23 | temp[k++] = a[i++]; 24 | while (j < sizeb) 25 | temp[k++] = b[j++]; 26 | 27 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 28 | a[i] = temp[k]; 29 | 30 | free(temp); 31 | } 32 | 33 | void mergesort(int *v, int n) 34 | { 35 | if (n < 2) return; 36 | int m = n / 2; 37 | mergesort(v, m); 38 | mergesort(&v[m], n - m); 39 | merge(v, m, v + m, n - m); 40 | } 41 | 42 | int main() 43 | { 44 | int n = 0; 45 | scanf("%d", &n); 46 | int *v = (int *)malloc(n * sizeof(int)); 47 | for (int i = 0; i < n; i++) 48 | scanf(" %d", v + i); 49 | 50 | mergesort(v, n); 51 | printarr(v, n); 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /Lista 3/C.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void printarr(int *v, int n) 5 | { 6 | for (int i = 0; i < n; i++) 7 | printf("%d%c", v[i], (i == n - 1 ? '\n' : ' ')); 8 | } 9 | 10 | void merge(int *a, int sizea, int *b, int sizeb) 11 | { 12 | int *temp = (int *)malloc((sizea + sizeb) * sizeof(int)); 13 | int i = 0, j = 0, k = 0; 14 | for (; i < sizea && j < sizeb; k++) 15 | { 16 | if (a[i] <= b[j]) 17 | temp[k] = a[i++]; 18 | else 19 | temp[k] = b[j++]; 20 | } 21 | 22 | while (i < sizea) 23 | temp[k++] = a[i++]; 24 | while (j < sizeb) 25 | temp[k++] = b[j++]; 26 | 27 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 28 | a[i] = temp[k]; 29 | 30 | free(temp); 31 | } 32 | 33 | void mergesort(int *v, int n) 34 | { 35 | if (n < 2) return; 36 | int m = n / 2; 37 | mergesort(v, m); 38 | mergesort(&v[m], n - m); 39 | merge(v, m, v + m, n - m); 40 | } 41 | 42 | int v[100001]; 43 | 44 | int main() 45 | { 46 | int n = 0; 47 | for (; scanf(" %d", v + n) == 1; n++); 48 | 49 | mergesort(v, n); 50 | printarr(v, n); 51 | 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /Lista 3/D.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int search(int *v, int n, int x) 5 | { 6 | int l = 0, r = n - 1; 7 | while (l <= r) 8 | { 9 | int m = (l + r) / 2; 10 | if (v[m] == x) 11 | return m; 12 | else if (v[m] < x) 13 | l = m + 1; 14 | else 15 | r = m - 1; 16 | } 17 | return l; 18 | } 19 | 20 | int main() 21 | { 22 | int n, m; 23 | scanf("%d %d", &n, &m); 24 | int *v = (int *)malloc(n * sizeof(int)); 25 | for (int i = 0; i < n; i++) 26 | scanf(" %d", v + i); 27 | 28 | while (m--) 29 | { 30 | int x; 31 | scanf(" %d", &x); 32 | printf("%d\n", search(v, n, x)); 33 | } 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /Lista 3/E.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct 5 | { 6 | int x, pos; 7 | } Item; 8 | 9 | int search(Item *v, int n, int x) 10 | { 11 | int l = 0, r = n - 1; 12 | while (l <= r) 13 | { 14 | int m = (l + r) / 2; 15 | if (v[m].x == x) 16 | return v[m].pos; 17 | else if (v[m].x < x) 18 | l = m + 1; 19 | else 20 | r = m - 1; 21 | } 22 | return -1; 23 | } 24 | 25 | void merge(Item *a, int sizea, Item *b, int sizeb) 26 | { 27 | Item *temp = (Item *)malloc((sizea + sizeb) * sizeof(Item)); 28 | int i = 0, j = 0, k = 0; 29 | for (; i < sizea && j < sizeb; k++) 30 | { 31 | if (a[i].x <= b[j].x) 32 | temp[k] = a[i++]; 33 | else 34 | temp[k] = b[j++]; 35 | } 36 | 37 | while (i < sizea) 38 | temp[k++] = a[i++]; 39 | while (j < sizeb) 40 | temp[k++] = b[j++]; 41 | 42 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 43 | a[i] = temp[k]; 44 | 45 | free(temp); 46 | } 47 | 48 | void mergesort(Item *v, int n) 49 | { 50 | if (n < 2) return; 51 | int m = n / 2; 52 | mergesort(v, m); 53 | mergesort(&v[m], n - m); 54 | merge(v, m, v + m, n - m); 55 | } 56 | 57 | int main() 58 | { 59 | int n, m; 60 | scanf("%d %d", &n, &m); 61 | Item *v = (Item *)malloc(n * sizeof(Item)); 62 | for (int i = 0; i < n; i++) 63 | { 64 | scanf(" %d", &v[i].x); 65 | v[i].pos = i; 66 | } 67 | 68 | mergesort(v, n); 69 | 70 | while (m--) 71 | { 72 | int x; 73 | scanf(" %d", &x); 74 | printf("%d\n", search(v, n, x)); 75 | } 76 | 77 | return 0; 78 | } 79 | -------------------------------------------------------------------------------- /Lista 3/F.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define Item int 5 | #define key(x) (x) 6 | 7 | int search(Item *v, int n, int x) 8 | { 9 | int l = 0, r = n - 1; 10 | while (l <= r) 11 | { 12 | int m = (l + r) / 2; 13 | if (key(v[m]) == x) 14 | return 1; 15 | else if (key(v[m]) < x) 16 | l = m + 1; 17 | else 18 | r = m - 1; 19 | } 20 | return 0; 21 | } 22 | 23 | void merge(Item *a, int sizea, Item *b, int sizeb) 24 | { 25 | Item *temp = (Item *)malloc((sizea + sizeb) * sizeof(Item)); 26 | int i = 0, j = 0, k = 0; 27 | for (; i < sizea && j < sizeb; k++) 28 | { 29 | if (key(a[i]) <= key(b[j])) 30 | temp[k] = a[i++]; 31 | else 32 | temp[k] = b[j++]; 33 | } 34 | 35 | while (i < sizea) 36 | temp[k++] = a[i++]; 37 | while (j < sizeb) 38 | temp[k++] = b[j++]; 39 | 40 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 41 | a[i] = temp[k]; 42 | 43 | free(temp); 44 | } 45 | 46 | void mergesort(Item *v, int n) 47 | { 48 | if (n < 2) return; 49 | int m = n / 2; 50 | mergesort(v, m); 51 | mergesort(&v[m], n - m); 52 | merge(v, m, v + m, n - m); 53 | } 54 | 55 | int main() 56 | { 57 | int n; 58 | scanf("%d", &n); 59 | Item *v = (Item *)malloc(n * sizeof(Item)); 60 | for (int i = 0; i < n; i++) 61 | scanf(" %d", &v[i]); 62 | 63 | mergesort(v, n); 64 | 65 | for (int x; scanf(" %d", &x) == 1;) 66 | { 67 | printf("%s\n", search(v, n, x) ? "sim" : "nao"); 68 | } 69 | 70 | return 0; 71 | } 72 | -------------------------------------------------------------------------------- /Lista 3/G.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define key(x) (x.curr) 5 | #define T unsigned long long 6 | 7 | typedef struct 8 | { 9 | T curr, prev, next; 10 | } Item; 11 | 12 | int search(Item *v, int n, T x) 13 | { 14 | int l = 0, r = n - 1; 15 | while (l <= r) 16 | { 17 | int m = (l + r) / 2; 18 | if (key(v[m]) == x) 19 | return m; 20 | else if (key(v[m]) < x) 21 | l = m + 1; 22 | else 23 | r = m - 1; 24 | } 25 | return -1; 26 | } 27 | 28 | void merge(Item *a, int sizea, Item *b, int sizeb) 29 | { 30 | Item *temp = (Item *)malloc((sizea + sizeb) * sizeof(Item)); 31 | int i = 0, j = 0, k = 0; 32 | for (; i < sizea && j < sizeb; k++) 33 | { 34 | if (key(a[i]) <= key(b[j])) 35 | temp[k] = a[i++]; 36 | else 37 | temp[k] = b[j++]; 38 | } 39 | 40 | while (i < sizea) 41 | temp[k++] = a[i++]; 42 | while (j < sizeb) 43 | temp[k++] = b[j++]; 44 | 45 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 46 | a[i] = temp[k]; 47 | 48 | free(temp); 49 | } 50 | 51 | void mergesort(Item *v, int n) 52 | { 53 | if (n < 2) 54 | return; 55 | int m = n / 2; 56 | mergesort(v, m); 57 | mergesort(&v[m], n - m); 58 | merge(v, m, v + m, n - m); 59 | } 60 | 61 | void printitem(Item x) 62 | { 63 | printf("%llx %llx %llx\n", x.curr, x.prev, x.next); 64 | } 65 | 66 | void printprev(Item *v, int n, T x) 67 | { 68 | int idx = search(v, n, x); 69 | if (idx == -1 || v[idx].curr == 0) 70 | return; 71 | printprev(v, n, v[idx].prev); 72 | printitem(v[idx]); 73 | } 74 | 75 | void printnext(Item *v, int n, T x) 76 | { 77 | int idx = search(v, n, x); 78 | if (idx == -1 || v[idx].curr == 0) 79 | return; 80 | printitem(v[idx]); 81 | printnext(v, n, v[idx].next); 82 | } 83 | 84 | void printnext_until(Item *v, int n, T x, T last) 85 | { 86 | int idx = search(v, n, x); 87 | if (idx == -1 || v[idx].curr == last) 88 | return; 89 | printf("%llx\n", v[idx].curr); 90 | printnext_until(v, n, v[idx].next, last); 91 | } 92 | 93 | Item v[250001]; 94 | 95 | int main() 96 | { 97 | int n; 98 | for (n = 0; scanf(" %llx %llx %llx", &v[n].curr, &v[n].prev, &v[n].next) == 3; n++); 99 | 100 | Item ptr1 = v[0], ptr2 = v[1]; 101 | mergesort(v, n); 102 | 103 | v[search(v, n, ptr1.prev)].next = ptr2.next; 104 | v[search(v, n, ptr2.next)].prev = ptr1.prev; 105 | 106 | printprev(v, n, ptr1.prev); 107 | printnext(v, n, ptr2.next); 108 | printf("\n"); 109 | printnext_until(v, n, ptr1.curr, ptr2.next); 110 | 111 | return 0; 112 | } 113 | -------------------------------------------------------------------------------- /Lista 4/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define Item int 5 | #define key(x) (x) 6 | #define less(a, b) (a < b) 7 | #define swap(a, b) \ 8 | { \ 9 | Item t = a; \ 10 | a = b; \ 11 | b = t; \ 12 | } 13 | #define cmpswap(a, b) \ 14 | if (less(b, a)) \ 15 | swap(a, b) 16 | 17 | int partition(Item *v, int size) 18 | { 19 | int l = -1, r = size - 1; 20 | Item pivot = v[r]; 21 | 22 | while (1) 23 | { 24 | while (less(v[++l], pivot)); 25 | while (less(pivot, v[--r]) && r > l); 26 | 27 | if (l >= r) 28 | break; 29 | swap(v[l], v[r]); 30 | } 31 | swap(v[l], v[size - 1]); 32 | return l; 33 | } 34 | 35 | void quicksort(Item *v, int size) 36 | { 37 | if (size < 2) 38 | return; 39 | 40 | cmpswap(v[(size - 1) / 2], v[size - 1]); 41 | cmpswap(v[0], v[(size - 1) / 2]); 42 | cmpswap(v[size - 1], v[(size - 1) / 2]); 43 | 44 | int m = partition(v, size); 45 | quicksort(v, m); 46 | quicksort(v + m + 1, size - m - 1); 47 | } 48 | 49 | void merge(Item *a, int sizea, Item *b, int sizeb) 50 | { 51 | Item *temp = (Item *)malloc((sizea + sizeb) * sizeof(Item)); 52 | int i = 0, j = 0, k = 0; 53 | for (; i < sizea && j < sizeb; k++) 54 | { 55 | if (key(a[i]) <= key(b[j])) 56 | temp[k] = a[i++]; 57 | else 58 | temp[k] = b[j++]; 59 | } 60 | 61 | while (i < sizea) 62 | temp[k++] = a[i++]; 63 | while (j < sizeb) 64 | temp[k++] = b[j++]; 65 | 66 | for (k = 0, i = 0; i < (sizea + sizeb); i++, k++) 67 | a[i] = temp[k]; 68 | 69 | free(temp); 70 | } 71 | 72 | int remove_duplicates(Item *v, int n) 73 | { 74 | int size = 1; 75 | for (int i = 1; i < n; i++) 76 | if (v[i] != v[size - 1]) 77 | v[size++] = v[i]; 78 | return size; 79 | } 80 | 81 | int main() 82 | { 83 | int n; 84 | scanf(" %d", &n); 85 | int *v = (int *)malloc(sizeof(int) * (2 * n)); 86 | for (int i = 0; i < n; i++) 87 | scanf(" %d", v + i); 88 | 89 | quicksort(v, n); 90 | 91 | int size = remove_duplicates(v, n); 92 | if (size % 2) 93 | v[size++] = 1000000000; 94 | 95 | int size_crazy = 0; 96 | for (int i = 0; i < size - 1; i += 2) 97 | v[size + size_crazy++] = v[i] + v[i + 1]; 98 | 99 | merge(v, size, v + size, size_crazy); 100 | size = remove_duplicates(v, size + size_crazy); 101 | for (int i = 0; i < size; i += 4) 102 | printf("%d\n", v[i]); 103 | printf("Elementos: %d\n", size); 104 | 105 | return 0; 106 | } 107 | -------------------------------------------------------------------------------- /Lista 4/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define Item int 5 | #define key(x) (x) 6 | #define less(a, b) (a < b) 7 | #define swap(a, b) \ 8 | { \ 9 | Item t = a; \ 10 | a = b; \ 11 | b = t; \ 12 | } 13 | #define cmpswap(a, b) \ 14 | if (less(b, a)) \ 15 | swap(a, b) 16 | 17 | int partition(Item *v, int size) 18 | { 19 | int l = -1, r = size - 1; 20 | Item pivot = v[r]; 21 | 22 | while (1) 23 | { 24 | while (less(v[++l], pivot)); 25 | while (less(pivot, v[--r]) && r > l); 26 | 27 | if (l >= r) 28 | break; 29 | swap(v[l], v[r]); 30 | } 31 | swap(v[l], v[size - 1]); 32 | return l; 33 | } 34 | 35 | void quicksort(Item *v, int size) 36 | { 37 | if (size < 2) 38 | return; 39 | 40 | swap(v[(size - 1) / 2], v[size - 2]); 41 | cmpswap(v[0], v[size - 2]); 42 | cmpswap(v[0], v[size - 1]); 43 | cmpswap(v[size - 2], v[size - 1]); 44 | 45 | int m = partition(v, size - 1); 46 | quicksort(v, m); 47 | quicksort(v + m + 1, size - m - 1); 48 | } 49 | 50 | int main() 51 | { 52 | int n; 53 | scanf(" %d", &n); 54 | int *v = (int *)malloc(sizeof(int) * (2 * n)); 55 | for (int i = 0; i < n; i++) 56 | scanf(" %d", v + i); 57 | 58 | quicksort(v, n); 59 | 60 | for (int i = 0; i < n; i++) 61 | printf("%d%c", v[i], " \n"[i == n-1]); 62 | 63 | return 0; 64 | } 65 | -------------------------------------------------------------------------------- /Lista 4/C.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ull unsigned long long 5 | #define Item struct Element 6 | #define key(x) (x.curr) 7 | #define less(a, b) (key(a) < key(b)) 8 | #define swap(a, b) \ 9 | { \ 10 | Item t = a; \ 11 | a = b; \ 12 | b = t; \ 13 | } 14 | #define cmpswap(a, b) \ 15 | if (less(b, a)) \ 16 | swap(a, b) 17 | 18 | struct Element 19 | { 20 | ull curr, prev, next; 21 | }; 22 | 23 | int partition(Item *v, int size) 24 | { 25 | int l = -1, r = size - 1; 26 | Item pivot = v[r]; 27 | 28 | while (1) 29 | { 30 | while (less(v[++l], pivot)); 31 | while (less(pivot, v[--r]) && r > l); 32 | 33 | if (l >= r) 34 | break; 35 | swap(v[l], v[r]); 36 | } 37 | swap(v[l], v[size - 1]); 38 | return l; 39 | } 40 | 41 | void quicksort(Item *v, int size) 42 | { 43 | if (size < 2) 44 | return; 45 | 46 | cmpswap(v[(size - 1) / 2], v[size - 1]); 47 | cmpswap(v[0], v[(size - 1) / 2]); 48 | cmpswap(v[size - 1], v[(size - 1) / 2]); 49 | 50 | int m = partition(v, size); 51 | quicksort(v, m); 52 | quicksort(v + m + 1, size - m - 1); 53 | } 54 | 55 | int search(Item *v, int n, ull x) 56 | { 57 | int l = 0, r = n - 1; 58 | while (l <= r) 59 | { 60 | int m = (l + r) / 2; 61 | if (key(v[m]) == x) 62 | return m; 63 | else if (key(v[m]) < x) 64 | l = m + 1; 65 | else 66 | r = m - 1; 67 | } 68 | return -1; 69 | } 70 | 71 | int is_sane(Item *v, int n, Item prev, Item target) 72 | { 73 | if (prev.next == target.curr && target.prev == prev.curr) 74 | return 1; 75 | 76 | int idx = search(v, n, prev.next); 77 | if (idx == -1 || v[idx].prev != prev.curr) 78 | return 0; 79 | 80 | return is_sane(v, n, v[idx], target); 81 | } 82 | 83 | Item v[500000]; 84 | 85 | int main() 86 | { 87 | int n; 88 | for (n = 0; scanf(" %llx %llx %llx", &v[n].curr, &v[n].prev, &v[n].next) == 3; n++); 89 | 90 | Item ptr1 = v[0], ptr2 = v[1]; 91 | quicksort(v, n); 92 | 93 | printf("%s\n", (is_sane(v, n, ptr1, ptr2) ? "sana" : "insana")); 94 | 95 | return 0; 96 | } 97 | -------------------------------------------------------------------------------- /Lista 4/D.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | #define Item struct Element 7 | #define key(x) (x.jp) 8 | #define less(a, b) (strcmp(key(a), key(b)) < 0) 9 | #define less_key(a, k) (strcmp(key(a), k) < 0) 10 | #define eq_key(a, k) (strcmp(key(a), k) == 0) 11 | #define swap(a, b) \ 12 | { \ 13 | Item t = a; \ 14 | a = b; \ 15 | b = t; \ 16 | } 17 | #define cmpswap(a, b) \ 18 | if (less(b, a)) \ 19 | swap(a, b) 20 | 21 | struct Element 22 | { 23 | char jp[82], br[82]; 24 | }; 25 | 26 | int partition(Item *v, int l, int r) 27 | { 28 | Item pivot = v[r]; 29 | int j = l; 30 | for (int k = l; k < r; k++) 31 | if (less(v[k], pivot)) 32 | { 33 | swap(v[k], v[j]); 34 | j++; 35 | } 36 | swap(v[j], v[r]); 37 | return j; 38 | } 39 | 40 | void quicksortM3(Item *v, int l, int r) 41 | { 42 | if (r - l <= 32) 43 | return; 44 | 45 | swap(v[(l + r) / 2], v[r - 1]); 46 | cmpswap(v[l], v[r - 1]); 47 | cmpswap(v[l], v[r]); 48 | cmpswap(v[r - 1], v[r]); 49 | 50 | int m = partition(v, l, r); 51 | quicksortM3(v, l, m - 1); 52 | quicksortM3(v, m + 1, r); 53 | } 54 | 55 | void insertionsort(Item *v, int l, int r) 56 | { 57 | for (int i = l + 1, j; i <= r; i++) 58 | { 59 | Item t = v[i]; 60 | for (j = i; j > 0 && less(t, v[j - 1]); j--) 61 | v[j] = v[j - 1]; 62 | v[j] = t; 63 | } 64 | } 65 | 66 | void quicksort(Item *v, int l, int r) 67 | { 68 | quicksortM3(v, l, r); 69 | insertionsort(v, l, r); 70 | } 71 | 72 | int binarysearch(Item *v, int l, int r, char *x) 73 | { 74 | while (l <= r) 75 | { 76 | int m = (l + r) / 2; 77 | if (eq_key(v[m], x)) 78 | return m; 79 | else if (less_key(v[m], x)) 80 | l = m + 1; 81 | else 82 | r = m - 1; 83 | } 84 | return -1; 85 | } 86 | 87 | Item v[1000001]; 88 | 89 | void solve() 90 | { 91 | int m, n; 92 | scanf(" %d %d\n", &m, &n); 93 | 94 | for (int i = 0; i < m; i++) 95 | { 96 | gets(v[i].jp); 97 | gets(v[i].br); 98 | } 99 | 100 | quicksort(v, 0, m - 1); 101 | 102 | while (n--) 103 | { 104 | char line[81]; 105 | gets(line); 106 | char *word; 107 | word = strtok(line, " "); 108 | while (word != NULL) 109 | { 110 | int idx = binarysearch(v, 0, m - 1, word); 111 | printf("%s", (idx != -1 ? v[idx].br : word)); 112 | word = strtok(NULL, " "); 113 | printf("%c", " \n"[word == NULL]); 114 | } 115 | } 116 | 117 | printf("\n"); 118 | } 119 | 120 | int main() 121 | { 122 | int t; 123 | scanf(" %d", &t); 124 | while (t--) 125 | solve(); 126 | 127 | return 0; 128 | } 129 | -------------------------------------------------------------------------------- /Lista 4/E.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | // #define Item int 7 | // #define key(x) (x) 8 | #define less(a, b) (a.value == b.value ? a.key > b.key : a.value > b.value) 9 | #define swap(a, b) \ 10 | { \ 11 | Item t = a; \ 12 | a = b; \ 13 | b = t; \ 14 | } 15 | #define cmpswap(a, b) \ 16 | if (less(b, a)) \ 17 | swap(a, b) 18 | 19 | typedef struct 20 | { 21 | int key, value; 22 | } Item; 23 | 24 | int partition(Item *v, int l, int r) 25 | { 26 | Item pivot = v[r]; 27 | int j = l; 28 | for (int k = l; k < r; k++) 29 | if (less(v[k], pivot)) 30 | { 31 | swap(v[k], v[j]); 32 | j++; 33 | } 34 | swap(v[j], v[r]); 35 | return j; 36 | } 37 | 38 | void quicksort(Item *v, int l, int r) 39 | { 40 | if (r <= l) 41 | return; 42 | 43 | cmpswap(v[(l + r) / 2], v[r]); 44 | cmpswap(v[l], v[(l + r) / 2]); 45 | cmpswap(v[r], v[(l + r) / 2]); 46 | 47 | int m = partition(v, l, r); 48 | quicksort(v, l, m - 1); 49 | quicksort(v, m + 1, r); 50 | } 51 | 52 | Item ps[91], ss[901], dfs[9001], des[90001]; 53 | int pn = 0, sn = 0, dfn = 0, den = 0; 54 | 55 | void solve() 56 | { 57 | long long s, f, e; 58 | scanf(" %lld %lld %lld", &s, &f, &e); 59 | 60 | long long valid = 0, invalid = 0, totalp = 0; 61 | for (int x, l; scanf("%d%n", &x, &l) == 1;) 62 | { 63 | if (x < 0) 64 | { 65 | invalid++; 66 | continue; 67 | } 68 | 69 | switch (l) 70 | { 71 | case 3: 72 | ps[x - 10].key = x; 73 | ps[x - 10].value++; 74 | totalp++; 75 | break; 76 | case 4: 77 | ss[x - 100].key = x; 78 | ss[x - 100].value++; 79 | break; 80 | case 5: 81 | dfs[x - 1000].key = x; 82 | dfs[x - 1000].value++; 83 | break; 84 | default: 85 | des[x - 10000].key = x; 86 | des[x - 10000].value++; 87 | } 88 | valid++; 89 | } 90 | 91 | for (int i = 0; i < 91; i++) 92 | if (ps[i].value) 93 | ps[pn++] = ps[i]; 94 | for (int i = 0; i < 901; i++) 95 | if (ss[i].value) 96 | ss[sn++] = ss[i]; 97 | for (int i = 0; i < 9001; i++) 98 | if (dfs[i].value) 99 | dfs[dfn++] = dfs[i]; 100 | for (int i = 0; i < 90001; i++) 101 | if (des[i].value) 102 | des[den++] = des[i]; 103 | 104 | printf("%lld %lld\n", valid, invalid); 105 | 106 | quicksort(ps, 0, pn - 1); 107 | quicksort(ss, 0, sn - 1); 108 | quicksort(dfs, 0, dfn - 1); 109 | quicksort(des, 0, den - 1); 110 | 111 | if ((double)ps[0].value / totalp >= .51) 112 | printf("%d\n", ps[0].key); 113 | else 114 | printf("Segundo turno\n"); 115 | 116 | for (int i = 0; i < s; i++) 117 | printf("%d%c", ss[i].key, " \n"[i == s - 1]); 118 | for (int i = 0; i < f; i++) 119 | printf("%d%c", dfs[i].key, " \n"[i == f - 1]); 120 | for (int i = 0; i < e; i++) 121 | printf("%d%c", des[i].key, " \n"[i == e - 1]); 122 | } 123 | 124 | int main() 125 | { 126 | solve(); 127 | 128 | return 0; 129 | } 130 | -------------------------------------------------------------------------------- /Lista 4/F.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | // #define Item int 7 | // #define key(x) (x) 8 | #define less(a, b) (a.value == b.value ? a.key < b.key : a.value < b.value) 9 | #define less2(a, b) (a.key == b.key ? a.value < b.value : a.key < b.key) 10 | #define swap(a, b) \ 11 | { \ 12 | Item t = a; \ 13 | a = b; \ 14 | b = t; \ 15 | } 16 | #define cmpswap(a, b) \ 17 | if (less(b, a)) \ 18 | swap(a, b) 19 | #define cmpswap2(a, b) \ 20 | if (less2(b, a)) \ 21 | swap(a, b) 22 | 23 | typedef struct 24 | { 25 | long long key; 26 | int value; 27 | } Item; 28 | 29 | int partition2(Item *v, int l, int r) 30 | { 31 | Item pivot = v[r]; 32 | int j = l; 33 | for (int k = l; k < r; k++) 34 | if (less2(v[k], pivot)) 35 | { 36 | swap(v[k], v[j]); 37 | j++; 38 | } 39 | swap(v[j], v[r]); 40 | return j; 41 | } 42 | 43 | void quicksortM3(Item *v, int l, int r) 44 | { 45 | if (r - l <= 32) 46 | return; 47 | 48 | swap(v[(l + r) / 2], v[r - 1]); 49 | cmpswap2(v[l], v[r - 1]); 50 | cmpswap2(v[l], v[r]); 51 | cmpswap2(v[r - 1], v[r]); 52 | 53 | int m = partition2(v, l, r); 54 | quicksortM3(v, l, m - 1); 55 | quicksortM3(v, m + 1, r); 56 | } 57 | 58 | void insertionsort(Item *v, int l, int r) 59 | { 60 | for (int i = l + 1, j; i <= r; i++) 61 | { 62 | Item t = v[i]; 63 | for (j = i; j > 0 && less2(t, v[j - 1]); j--) 64 | v[j] = v[j - 1]; 65 | v[j] = t; 66 | } 67 | } 68 | 69 | void quicksort2(Item *v, int l, int r) 70 | { 71 | quicksortM3(v, l, r); 72 | insertionsort(v, l, r); 73 | } 74 | 75 | int partition(Item *v, int l, int r) 76 | { 77 | Item pivot = v[r]; 78 | int j = l; 79 | for (int k = l; k < r; k++) 80 | if (less(v[k], pivot)) 81 | { 82 | swap(v[k], v[j]); 83 | j++; 84 | } 85 | swap(v[j], v[r]); 86 | return j; 87 | } 88 | 89 | void quickselect(Item *v, int l, int r, int i) 90 | { 91 | cmpswap(v[(l + r) / 2], v[r]); 92 | cmpswap(v[l], v[(l + r) / 2]); 93 | cmpswap(v[r], v[(l + r) / 2]); 94 | 95 | int m = partition(v, l, r); 96 | if (m > i) 97 | quickselect(v, l, m - 1, i); 98 | else if (m < i) 99 | quickselect(v, m + 1, r, i); 100 | } 101 | 102 | Item v[10000001]; 103 | 104 | void solve() 105 | { 106 | int k; 107 | scanf(" %d", &k); 108 | int n; 109 | for (n = 0; scanf(" %lld %d", &v[n].key, &v[n].value) == 2; n++); 110 | 111 | quickselect(v, 0, n - 1, k - 1); 112 | quicksort2(v, 0, k - 1); 113 | 114 | for (int i = 0; i < k; i++) 115 | printf("%lld %d\n", v[i].key, v[i].value); 116 | } 117 | 118 | int main() 119 | { 120 | solve(); 121 | 122 | return 0; 123 | } 124 | -------------------------------------------------------------------------------- /Lista 4/G.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | #define min(a, b) (a < b ? a : b) 7 | #define max(a, b) (b < a ? a : b) 8 | #define Item unsigned 9 | #define key(x) (x) 10 | #define less(a, b) (a < b) 11 | #define swap(a, b) \ 12 | { \ 13 | Item t = a; \ 14 | a = b; \ 15 | b = t; \ 16 | } 17 | #define cmpswap(a, b) \ 18 | if (less(b, a)) \ 19 | swap(a, b) 20 | 21 | int partition(Item *v, int l, int r) 22 | { 23 | Item pivot = v[r]; 24 | int j = l; 25 | for (int k = l; k < r; k++) 26 | if (less(v[k], pivot)) 27 | { 28 | swap(v[k], v[j]); 29 | j++; 30 | } 31 | swap(v[j], v[r]); 32 | return j; 33 | } 34 | 35 | void quicksortM3(Item *v, int l, int r) 36 | { 37 | if (r - l <= 32) 38 | return; 39 | 40 | swap(v[(l + r) / 2], v[r - 1]); 41 | cmpswap(v[l], v[r - 1]); 42 | cmpswap(v[l], v[r]); 43 | cmpswap(v[r - 1], v[r]); 44 | 45 | int m = partition(v, l, r); 46 | quicksortM3(v, l, m - 1); 47 | quicksortM3(v, m + 1, r); 48 | } 49 | 50 | void insertionsort(Item *v, int l, int r) 51 | { 52 | for (int i = l + 1, j; i <= r; i++) 53 | { 54 | Item t = v[i]; 55 | for (j = i; j > 0 && less(t, v[j - 1]); j--) 56 | v[j] = v[j - 1]; 57 | v[j] = t; 58 | } 59 | } 60 | 61 | void quicksort(Item *v, int l, int r) 62 | { 63 | quicksortM3(v, l, r); 64 | insertionsort(v, l, r); 65 | } 66 | 67 | void quickselect(Item *v, int l, int r, int i) 68 | { 69 | if (i < l || i > r) 70 | return; 71 | 72 | cmpswap(v[(l + r) / 2], v[r]); 73 | cmpswap(v[l], v[(l + r) / 2]); 74 | cmpswap(v[r], v[(l + r) / 2]); 75 | 76 | int m = partition(v, l, r); 77 | if (m > i) 78 | quickselect(v, l, m - 1, i); 79 | else if (m < i) 80 | quickselect(v, m + 1, r, i); 81 | } 82 | 83 | void solve() 84 | { 85 | int n, p, x; 86 | scanf(" %d %d %d", &n, &p, &x); 87 | unsigned *v = malloc(n * sizeof(unsigned)); 88 | for (int i = 0; i < n; i++) 89 | scanf(" %u", v + i); 90 | 91 | quickselect(v, 0, n-1, min(n-1, p*x)); 92 | quickselect(v, 0, n-1, min(n-1, (p+1)*x-1)); 93 | quicksort(v, min(n-1, p*x), min(n-1, (p+1)*x-1)); 94 | 95 | for (int i = p*x; i < min(n, (p+1)*x); i++) 96 | printf("%u\n", v[i]); 97 | } 98 | 99 | int main() 100 | { 101 | solve(); 102 | 103 | return 0; 104 | } 105 | -------------------------------------------------------------------------------- /Lista 5/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void solve(int n) 5 | { 6 | if (!n) 7 | return; 8 | 9 | int ans = 0, counter = 0; 10 | for (int i = 0; i < n; i++) 11 | { 12 | int x; 13 | scanf(" %d",&x); 14 | if (counter == 0) 15 | { 16 | ans = x; 17 | counter++; 18 | } 19 | else 20 | counter += (ans == x ? 1 : -1); 21 | } 22 | printf("%d\n", ans); 23 | scanf(" %d", &n); 24 | solve(n); 25 | } 26 | 27 | int main() 28 | { 29 | int n; 30 | scanf(" %d", &n); 31 | solve(n); 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /Lista 5/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ull unsigned long long 5 | #define min(a, b) (a < b ? a : b) 6 | #define max(a, b) (b < a ? a : b) 7 | // #define Item unsigned 8 | #define key(x) (x) 9 | #define less(a, b) (a.v == b.v ? a.k < b.k : a.v < b.v) 10 | #define swap(a, b) \ 11 | { \ 12 | Item t = a; \ 13 | a = b; \ 14 | b = t; \ 15 | } 16 | #define cmpswap(a, b) \ 17 | if (less(b, a)) \ 18 | swap(a, b) 19 | 20 | typedef struct 21 | { 22 | int k, v; 23 | } Item; 24 | 25 | int partition(Item *v, int l, int r) 26 | { 27 | Item pivot = v[r]; 28 | int j = l; 29 | for (int k = l; k < r; k++) 30 | if (less(v[k], pivot)) 31 | { 32 | swap(v[k], v[j]); 33 | j++; 34 | } 35 | swap(v[j], v[r]); 36 | return j; 37 | } 38 | 39 | void quicksortM3(Item *v, int l, int r) 40 | { 41 | if (r - l <= 32) 42 | return; 43 | 44 | swap(v[(l + r) / 2], v[r - 1]); 45 | cmpswap(v[l], v[r - 1]); 46 | cmpswap(v[l], v[r]); 47 | cmpswap(v[r - 1], v[r]); 48 | 49 | int m = partition(v, l, r); 50 | quicksortM3(v, l, m - 1); 51 | quicksortM3(v, m + 1, r); 52 | } 53 | 54 | void insertionsort(Item *v, int l, int r) 55 | { 56 | for (int i = l + 1, j; i <= r; i++) 57 | { 58 | Item t = v[i]; 59 | for (j = i; j > 0 && less(t, v[j - 1]); j--) 60 | v[j] = v[j - 1]; 61 | v[j] = t; 62 | } 63 | } 64 | 65 | void quicksort(Item *v, int l, int r) 66 | { 67 | quicksortM3(v, l, r); 68 | insertionsort(v, l, r); 69 | } 70 | 71 | int main() 72 | { 73 | char s[1010]; 74 | while (scanf(" %s", s) == 1) 75 | { 76 | int fr[130]; 77 | Item v[130]; 78 | 79 | for (int i = 0; i < 130; i++) 80 | fr[i] = 0; 81 | 82 | for (int i = 0; s[i] != '\0'; i++) 83 | fr[s[i]]++; 84 | int k = 0; 85 | for (int i = 0; i < 130; i++) 86 | if (fr[i]) 87 | v[k++] = (Item) {.k = i, .v=fr[i]}; 88 | quicksort(v, 0, k-1); 89 | for (int i = 0; i < k; i++) 90 | printf("%d %d\n", v[i].k, v[i].v); 91 | printf("\n"); 92 | } 93 | 94 | return 0; 95 | } 96 | -------------------------------------------------------------------------------- /Lista 5/C.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | // #define Item int 7 | // #define key(x) (x) 8 | #define less(a, b) (a.value == b.value ? a.key > b.key : a.value > b.value) 9 | #define swap(a, b) \ 10 | { \ 11 | Item t = a; \ 12 | a = b; \ 13 | b = t; \ 14 | } 15 | #define cmpswap(a, b) \ 16 | if (less(b, a)) \ 17 | swap(a, b) 18 | 19 | typedef struct 20 | { 21 | int key, value; 22 | } Item; 23 | 24 | int partition(Item *v, int l, int r) 25 | { 26 | Item pivot = v[r]; 27 | int j = l; 28 | for (int k = l; k < r; k++) 29 | if (less(v[k], pivot)) 30 | { 31 | swap(v[k], v[j]); 32 | j++; 33 | } 34 | swap(v[j], v[r]); 35 | return j; 36 | } 37 | 38 | void quicksort(Item *v, int l, int r) 39 | { 40 | if (r <= l) 41 | return; 42 | 43 | cmpswap(v[(l + r) / 2], v[r]); 44 | cmpswap(v[l], v[(l + r) / 2]); 45 | cmpswap(v[r], v[(l + r) / 2]); 46 | 47 | int m = partition(v, l, r); 48 | quicksort(v, l, m - 1); 49 | quicksort(v, m + 1, r); 50 | } 51 | 52 | Item ps[91], ss[901], dfs[9001], des[90001]; 53 | int pn = 0, sn = 0, dfn = 0, den = 0; 54 | 55 | void solve() 56 | { 57 | long long s, f, e; 58 | scanf(" %lld %lld %lld", &s, &f, &e); 59 | 60 | long long valid = 0, invalid = 0, totalp = 0; 61 | for (int x, l; scanf("%d%n", &x, &l) == 1;) 62 | { 63 | if (x < 0) 64 | { 65 | invalid++; 66 | continue; 67 | } 68 | 69 | switch (l) 70 | { 71 | case 3: 72 | ps[x - 10].key = x; 73 | ps[x - 10].value++; 74 | totalp++; 75 | break; 76 | case 4: 77 | ss[x - 100].key = x; 78 | ss[x - 100].value++; 79 | break; 80 | case 5: 81 | dfs[x - 1000].key = x; 82 | dfs[x - 1000].value++; 83 | break; 84 | default: 85 | des[x - 10000].key = x; 86 | des[x - 10000].value++; 87 | } 88 | valid++; 89 | } 90 | 91 | for (int i = 0; i < 91; i++) 92 | if (ps[i].value) 93 | ps[pn++] = ps[i]; 94 | for (int i = 0; i < 901; i++) 95 | if (ss[i].value) 96 | ss[sn++] = ss[i]; 97 | for (int i = 0; i < 9001; i++) 98 | if (dfs[i].value) 99 | dfs[dfn++] = dfs[i]; 100 | for (int i = 0; i < 90001; i++) 101 | if (des[i].value) 102 | des[den++] = des[i]; 103 | 104 | printf("%lld %lld\n", valid, invalid); 105 | 106 | quicksort(ps, 0, pn - 1); 107 | quicksort(ss, 0, sn - 1); 108 | quicksort(dfs, 0, dfn - 1); 109 | quicksort(des, 0, den - 1); 110 | 111 | if ((double)ps[0].value / totalp >= .51) 112 | printf("%d\n", ps[0].key); 113 | else 114 | printf("Segundo turno\n"); 115 | 116 | for (int i = 0; i < s; i++) 117 | printf("%d%c", ss[i].key, " \n"[i == s - 1]); 118 | for (int i = 0; i < f; i++) 119 | printf("%d%c", dfs[i].key, " \n"[i == f - 1]); 120 | for (int i = 0; i < e; i++) 121 | printf("%d%c", des[i].key, " \n"[i == e - 1]); 122 | } 123 | 124 | int main() 125 | { 126 | // int t; 127 | // scanf(" %d", &t); 128 | // while (t--) 129 | solve(); 130 | 131 | return 0; 132 | } 133 | -------------------------------------------------------------------------------- /Lista 5/D.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define ull unsigned long long 6 | // #define Item int 7 | // #define key(x) (x) 8 | #define less(a, b) (a.value == b.value ? a.key > b.key : a.value > b.value) 9 | #define swap(a, b) \ 10 | { \ 11 | Item t = a; \ 12 | a = b; \ 13 | b = t; \ 14 | } 15 | #define cmpswap(a, b) \ 16 | if (less(b, a)) \ 17 | swap(a, b) 18 | 19 | typedef struct 20 | { 21 | int key, value; 22 | } Item; 23 | 24 | int partition(Item *v, int l, int r) 25 | { 26 | Item pivot = v[r]; 27 | int j = l; 28 | for (int k = l; k < r; k++) 29 | if (less(v[k], pivot)) 30 | { 31 | swap(v[k], v[j]); 32 | j++; 33 | } 34 | swap(v[j], v[r]); 35 | return j; 36 | } 37 | 38 | void quicksort(Item *v, int l, int r) 39 | { 40 | if (r <= l) 41 | return; 42 | 43 | cmpswap(v[(l + r) / 2], v[r]); 44 | cmpswap(v[l], v[(l + r) / 2]); 45 | cmpswap(v[r], v[(l + r) / 2]); 46 | 47 | int m = partition(v, l, r); 48 | quicksort(v, l, m - 1); 49 | quicksort(v, m + 1, r); 50 | } 51 | 52 | Item ps[91], ss[901], dfs[9001], des[90001]; 53 | int pn = 0, sn = 0, dfn = 0, den = 0; 54 | 55 | void solve() 56 | { 57 | long long s, f, e; 58 | scanf(" %lld %lld %lld", &s, &f, &e); 59 | 60 | long long valid = 0, invalid = 0, totalp = 0; 61 | for (int x, l; scanf("%d%n", &x, &l) == 1;) 62 | { 63 | if (x < 0) 64 | { 65 | invalid++; 66 | continue; 67 | } 68 | 69 | switch (l) 70 | { 71 | case 3: 72 | ps[x - 10].key = x; 73 | ps[x - 10].value++; 74 | totalp++; 75 | break; 76 | case 4: 77 | ss[x - 100].key = x; 78 | ss[x - 100].value++; 79 | break; 80 | case 5: 81 | dfs[x - 1000].key = x; 82 | dfs[x - 1000].value++; 83 | break; 84 | default: 85 | des[x - 10000].key = x; 86 | des[x - 10000].value++; 87 | } 88 | valid++; 89 | } 90 | 91 | for (int i = 0; i < 91; i++) 92 | if (ps[i].value) 93 | ps[pn++] = ps[i]; 94 | for (int i = 0; i < 901; i++) 95 | if (ss[i].value) 96 | ss[sn++] = ss[i]; 97 | for (int i = 0; i < 9001; i++) 98 | if (dfs[i].value) 99 | dfs[dfn++] = dfs[i]; 100 | for (int i = 0; i < 90001; i++) 101 | if (des[i].value) 102 | des[den++] = des[i]; 103 | 104 | printf("%lld %lld\n", valid, invalid); 105 | 106 | quicksort(ps, 0, pn - 1); 107 | quicksort(ss, 0, sn - 1); 108 | quicksort(dfs, 0, dfn - 1); 109 | quicksort(des, 0, den - 1); 110 | 111 | if ((double)ps[0].value / totalp >= .51) 112 | printf("%d\n", ps[0].key); 113 | else 114 | printf("Segundo turno\n"); 115 | 116 | for (int i = 0; i < s; i++) 117 | printf("%d%c", ss[i].key, " \n"[i == s - 1]); 118 | for (int i = 0; i < f; i++) 119 | printf("%d%c", dfs[i].key, " \n"[i == f - 1]); 120 | for (int i = 0; i < e; i++) 121 | printf("%d%c", des[i].key, " \n"[i == e - 1]); 122 | } 123 | 124 | int main() 125 | { 126 | solve(); 127 | 128 | return 0; 129 | } 130 | -------------------------------------------------------------------------------- /Lista 5/E.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int v[1010]; 5 | 6 | int main() 7 | { 8 | int n; 9 | scanf(" %d", &n); 10 | 11 | int ans = 0, best = 0; 12 | for (int i = 0; i < n; i++) 13 | { 14 | int x; 15 | scanf(" %d",&x); 16 | if (++v[x] > best) 17 | { 18 | best = v[x]; 19 | ans = x; 20 | } 21 | else if (v[x] == best && ans < x) 22 | ans = x; 23 | } 24 | printf("%d\n", ans); 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /Lista 5/F.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int v[1010]; 5 | 6 | int main() 7 | { 8 | int n; 9 | scanf(" %d", &n); 10 | 11 | int ans = 0, best = 0; 12 | for (int i = 0; i < n; i++) 13 | { 14 | int x; 15 | scanf(" %d",&x); 16 | if (++v[x] > best) 17 | { 18 | best = v[x]; 19 | ans = x; 20 | } 21 | else if (v[x] == best && ans < x) 22 | ans = x; 23 | } 24 | printf("%d\n", ans); 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /Lista 5/G.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | char ht[109][20]; 6 | int size = 0; 7 | 8 | int hash(char *k) 9 | { 10 | int h = 0; 11 | for (int i = 0; k[i] != '\0'; i++) 12 | h += k[i] * (i+1LL); 13 | return (h * 19) % 101; 14 | } 15 | 16 | int search(char *s) 17 | { 18 | int h = hash(s); 19 | for (int j = 0; j < 20; j++) 20 | { 21 | int i = (h + j*j + 23LL*j) % 101; 22 | if (strcmp(ht[i], s) == 0) 23 | return 1; 24 | } 25 | return 0; 26 | } 27 | 28 | void insert(char *s) 29 | { 30 | if (search(s)) 31 | return; 32 | 33 | int h = hash(s); 34 | for (int j = 0; j < 20; j++) 35 | { 36 | int i = (h + j*j + 23LL*j) % 101; 37 | if (*ht[i] == '\0') 38 | { 39 | strcpy(ht[i], s); 40 | size++; 41 | break; 42 | } 43 | } 44 | } 45 | 46 | void delete(char *s) 47 | { 48 | int h = hash(s); 49 | for (int j = 0; j < 20; j++) 50 | { 51 | int i = (h + j*j + 23LL*j) % 101; 52 | if (strcmp(ht[i], s) == 0) 53 | { 54 | *ht[i] = '\0'; 55 | size--; 56 | } 57 | } 58 | } 59 | 60 | int main() 61 | { 62 | int t; 63 | scanf(" %d", &t); 64 | while (t--) 65 | { 66 | for (int i = 0; i < 101; i++) 67 | *ht[i] = '\0'; 68 | size = 0; 69 | 70 | int n; 71 | scanf(" %d", &n); 72 | char m[4], s[16]; 73 | while (n--) 74 | { 75 | scanf(" %s:%s", m, s); 76 | if (m[0] == 'A') 77 | insert(s); 78 | else 79 | delete(s); 80 | } 81 | printf("%d\n", size); 82 | for (int i = 0; i < 101; i++) 83 | if (*ht[i] != '\0') 84 | printf("%d:%s\n", i, ht[i]); 85 | } 86 | 87 | return 0; 88 | } 89 | -------------------------------------------------------------------------------- /Lista 5/H.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | typedef struct Item 6 | { 7 | char k[11], fn[101], ln[101], bd[20], pn[20]; 8 | } Item; 9 | 10 | #define HT_SIZE 1572869u 11 | #define key(a) (a.k) 12 | #define less(a, b) (a < b) 13 | #define swap(a, b) \ 14 | { \ 15 | int t = a; \ 16 | a = b; \ 17 | b = t; \ 18 | } 19 | #define cmpswap(a, b) \ 20 | if (less(b, a)) \ 21 | swap(a, b) 22 | #define eq(a, b) (!(strcmp(a.k, b.k) || strcmp(a.fn, b.fn) || strcmp(a.ln, b.ln) || strcmp(a.bd, b.bd) || strcmp(a.pn, b.pn))) 23 | 24 | int partition(int *v, int l, int r) 25 | { 26 | int pivot = v[r]; 27 | int j = l; 28 | for (int k = l; k < r; k++) 29 | if (less(v[k], pivot)) 30 | { 31 | swap(v[k], v[j]); 32 | j++; 33 | } 34 | swap(v[j], v[r]); 35 | return j; 36 | } 37 | 38 | void quicksortM3(int *v, int l, int r) 39 | { 40 | if (r - l <= 32) 41 | return; 42 | 43 | swap(v[(l + r) / 2], v[r - 1]); 44 | cmpswap(v[l], v[r - 1]); 45 | cmpswap(v[l], v[r]); 46 | cmpswap(v[r - 1], v[r]); 47 | 48 | int m = partition(v, l, r); 49 | quicksortM3(v, l, m - 1); 50 | quicksortM3(v, m + 1, r); 51 | } 52 | 53 | void insertionsort(int *v, int l, int r) 54 | { 55 | for (int i = l + 1, j; i <= r; i++) 56 | { 57 | int t = v[i]; 58 | for (j = i; j > 0 && less(t, v[j - 1]); j--) 59 | v[j] = v[j - 1]; 60 | v[j] = t; 61 | } 62 | } 63 | 64 | void quicksort(int *v, int l, int r) 65 | { 66 | quicksortM3(v, l, r); 67 | insertionsort(v, l, r); 68 | } 69 | 70 | #define STRING_HASH 71 | 72 | #ifdef STRING_HASH 73 | #define INITIAL_HASH_VALUE 5381 74 | #define MULT_HASH_VALUE 33 75 | unsigned hashu(const char *x) 76 | { 77 | unsigned h = INITIAL_HASH_VALUE; 78 | for (int i = 0; x[i] != '\0'; i++) 79 | h = (h * MULT_HASH_VALUE + x[i]) % HT_SIZE; 80 | return h; 81 | } 82 | #define key_t const char * 83 | #define hash_k(k) (hashu(k)) 84 | #define eq_k(x, k) (strcmp(key(x), k) == 0) 85 | #else 86 | #define hash_k(k) (key(k) % HT_SIZE) 87 | #define key_t int 88 | #define eq_k(x, k) (key(x) == k) 89 | #endif 90 | #define hash(x) (hash_k(key(x))) 91 | 92 | typedef struct LinkedItem 93 | { 94 | Item item; 95 | struct LinkedItem *next; 96 | } LinkedItem; 97 | 98 | typedef struct HashTable 99 | { 100 | unsigned size; 101 | LinkedItem **v; 102 | } HashTable; 103 | 104 | HashTable HT_init() 105 | { 106 | HashTable ht = {.size = 0}; 107 | ht.v = (LinkedItem **)malloc(HT_SIZE * sizeof(LinkedItem *)); 108 | for (unsigned i = 0; i < HT_SIZE; i++) 109 | ht.v[i] = NULL; 110 | return ht; 111 | } 112 | 113 | void HT_free(HashTable ht) 114 | { 115 | for (unsigned i; i < HT_SIZE; i++) 116 | { 117 | LinkedItem *prev = ht.v[i], *next = NULL; 118 | while (prev) 119 | { 120 | next = prev->next; 121 | free(prev); 122 | prev = next; 123 | } 124 | } 125 | free(ht.v); 126 | } 127 | 128 | #define HT_MACRO(k_name) \ 129 | int HT_insert##k_name(HashTable *ht, Item x) \ 130 | { \ 131 | unsigned h = hash(x); \ 132 | if (!ht->v[h]) \ 133 | { \ 134 | ht->v[h] = (LinkedItem *)malloc(sizeof(LinkedItem)); \ 135 | *ht->v[h] = (LinkedItem){.next = NULL, .item = x}; \ 136 | return 1; \ 137 | } \ 138 | LinkedItem *curr = ht->v[h]; \ 139 | while (curr->next && !eq(curr->item, x)) \ 140 | curr = curr->next; \ 141 | if (eq(curr->item, x)) \ 142 | return 0; \ 143 | curr->next = (LinkedItem *)malloc(sizeof(LinkedItem)); \ 144 | *curr->next = (LinkedItem){.item = x, .next = NULL}; \ 145 | ht->size++; \ 146 | return 1; \ 147 | } \ 148 | int HT_remove##k_name(HashTable *ht, key_t k) \ 149 | { \ 150 | unsigned h = hash_k(k); \ 151 | if (!ht->v[h]) \ 152 | return 0; \ 153 | LinkedItem *curr = ht->v[h], *to_remove = NULL; \ 154 | if (eq_k(curr->item, k)) \ 155 | { \ 156 | ht->v[h] = curr->next; \ 157 | to_remove = curr; \ 158 | } \ 159 | else \ 160 | { \ 161 | while (curr->next && !eq_k(curr->next->item, k)) \ 162 | curr = curr->next; \ 163 | if (!curr->next) \ 164 | return 0; \ 165 | to_remove = curr->next; \ 166 | curr->next = to_remove->next; \ 167 | } \ 168 | free(to_remove); \ 169 | return 1; \ 170 | } \ 171 | int HT_delete##k_name(HashTable *ht, Item x) \ 172 | { \ 173 | unsigned h = hash(x); \ 174 | if (!ht->v[h]) \ 175 | return 0; \ 176 | LinkedItem *curr = ht->v[h], *to_remove = NULL; \ 177 | if (eq(curr->item, x)) \ 178 | { \ 179 | ht->v[h] = curr->next; \ 180 | to_remove = curr; \ 181 | } \ 182 | else \ 183 | { \ 184 | while (curr->next && !eq(curr->next->item, x)) \ 185 | curr = curr->next; \ 186 | if (!curr->next) \ 187 | return 0; \ 188 | to_remove = curr->next; \ 189 | curr->next = to_remove->next; \ 190 | } \ 191 | free(to_remove); \ 192 | return 1; \ 193 | } \ 194 | LinkedItem *HT_search##k_name(HashTable ht, key_t k) \ 195 | { \ 196 | unsigned h = hash_k(k); \ 197 | LinkedItem *curr = ht.v[h]; \ 198 | while (curr) \ 199 | { \ 200 | if (eq_k(curr->item, k)) \ 201 | return curr; \ 202 | curr = curr->next; \ 203 | } \ 204 | return NULL; \ 205 | } \ 206 | int HT_contains##k_name(HashTable ht, Item x) \ 207 | { \ 208 | LinkedItem *curr = ht.v[hash(x)]; \ 209 | while (curr) \ 210 | { \ 211 | if (eq(curr->item, x)) \ 212 | return 1; \ 213 | curr = curr->next; \ 214 | } \ 215 | return 0; \ 216 | } 217 | 218 | #ifndef HT_K 219 | #define HT_K 220 | #undef key 221 | #define key(x) (x.k) 222 | #define hash(x) (hash_k(key(x))) 223 | HT_MACRO(k) 224 | #endif 225 | 226 | #ifndef HT_FN 227 | #define HT_FN 228 | #undef key 229 | #define key(x) (x.fn) 230 | #define hash(x) (hash_k(key(x))) 231 | HT_MACRO(fn) 232 | #endif 233 | 234 | #ifndef HT_LN 235 | #define HT_LN 236 | #undef key 237 | #define key(x) (x.ln) 238 | #define hash(x) (hash_k(key(x))) 239 | HT_MACRO(ln) 240 | #endif 241 | 242 | #ifndef HT_BD 243 | #define HT_BD 244 | #undef key 245 | #define key(x) (x.bd) 246 | #define hash(x) (hash_k(key(x))) 247 | HT_MACRO(bd) 248 | #endif 249 | 250 | #ifndef HT_PN 251 | #define HT_PN 252 | #undef key 253 | #define key(x) (x.pn) 254 | #define hash(x) (hash_k(key(x))) 255 | HT_MACRO(pn) 256 | #endif 257 | 258 | typedef struct Query 259 | { 260 | char field[4], value[200]; 261 | } Query; 262 | 263 | int ans[1000], ans_size = 0; 264 | 265 | void solve() 266 | { 267 | HashTable is = HT_init(), fs = HT_init(), ls = HT_init(), bs = HT_init(), ps = HT_init(); 268 | 269 | char command[6]; 270 | while (scanf(" %s", command) == 1) 271 | { 272 | switch (command[0]) 273 | { 274 | case 'a': 275 | { 276 | Item x; 277 | scanf(" %s %s %s %s %s", x.k, x.fn, x.ln, x.bd, x.pn); 278 | if (HT_searchk(is, x.k)) 279 | printf("ID %s ja cadastrado.\n", x.k); 280 | else 281 | { 282 | HT_insertk(&is, x); 283 | HT_insertfn(&fs, x); 284 | HT_insertln(&ls, x); 285 | HT_insertbd(&bs, x); 286 | HT_insertpn(&ps, x); 287 | } 288 | 289 | break; 290 | } 291 | case 'i': 292 | { 293 | char k[11]; 294 | scanf(" %s", k); 295 | LinkedItem *x = HT_searchk(is, k); 296 | if (!x) 297 | printf("ID %s nao existente.\n", k); 298 | else 299 | printf("%s %s %s %s\n", x->item.fn, x->item.ln, x->item.bd, x->item.pn); 300 | break; 301 | } 302 | case 'd': 303 | { 304 | char k[11]; 305 | scanf(" %s", k); 306 | LinkedItem *x = HT_searchk(is, k); 307 | if (!x) 308 | printf("ID %s nao existente.\n", k); 309 | else 310 | { 311 | HT_deletefn(&fs, x->item); 312 | HT_deleteln(&ls, x->item); 313 | HT_deletebd(&bs, x->item); 314 | HT_deletepn(&ps, x->item); 315 | HT_deletek(&is, x->item); 316 | } 317 | break; 318 | } 319 | default: 320 | { 321 | Query qs[4]; 322 | int qsize; 323 | 324 | char line[202]; 325 | scanf(" %[^\n]s", line); 326 | char *q = strtok(line, " "); 327 | for (qsize = 0; q && qsize < 4; qsize++) 328 | { 329 | sscanf(q, " %[^:]:%s", qs[qsize].field, qs[qsize].value); 330 | q = strtok(NULL, " "); 331 | } 332 | 333 | for (LinkedItem *x = (qs[0].field[0] == 'f' ? HT_searchfn(fs, qs[0].value) : (qs[0].field[0] == 'l' ? HT_searchln(ls, qs[0].value) : (qs[0].field[0] == 'b' ? HT_searchbd(bs, qs[0].value) : HT_searchpn(ps, qs[0].value)))); x; x = x->next) 334 | { 335 | int ok = 1; 336 | for (int j = 0; j < qsize; j++) 337 | { 338 | if (qs[j].field[0] == 'f' && strcmp(qs[j].value, x->item.fn)) 339 | { 340 | ok = 0; 341 | break; 342 | } 343 | else if (qs[j].field[0] == 'l' && strcmp(qs[j].value, x->item.ln)) 344 | { 345 | ok = 0; 346 | break; 347 | } 348 | else if (qs[j].field[0] == 'b' && strcmp(qs[j].value, x->item.bd)) 349 | { 350 | ok = 0; 351 | break; 352 | } 353 | else if (qs[j].field[0] == 'p' && strcmp(qs[j].value, x->item.pn)) 354 | { 355 | ok = 0; 356 | break; 357 | } 358 | } 359 | if (ok) 360 | ans[ans_size++] = atoi(x->item.k); 361 | } 362 | if (!ans_size) 363 | printf("\n"); 364 | else 365 | { 366 | quicksort(ans, 0, ans_size - 1); 367 | for (int i = 0; i < ans_size; i++) 368 | printf("%d%c", ans[i], " \n"[i == ans_size - 1]); 369 | ans_size = 0; 370 | } 371 | } 372 | } 373 | } 374 | 375 | HT_free(is); 376 | HT_free(bs); 377 | HT_free(fs); 378 | HT_free(ls); 379 | HT_free(ps); 380 | } 381 | 382 | int main() 383 | { 384 | solve(); 385 | 386 | return 0; 387 | } 388 | -------------------------------------------------------------------------------- /Lista 5/I.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | typedef struct Item 6 | { 7 | unsigned k; 8 | char v; 9 | } Item; 10 | 11 | #define HT_SIZE 1572869u 12 | #define key(a) (a.k) 13 | #define eq(a, b) (a.k == b.k) 14 | 15 | #ifdef STRING_HASH 16 | #define INITIAL_HASH_VALUE 5381 17 | #define MULT_HASH_VALUE 33 18 | unsigned hashu(const char *x) 19 | { 20 | unsigned h = INITIAL_HASH_VALUE; 21 | for (int i = 0; x[i] != '\0'; i++) 22 | h = (h * MULT_HASH_VALUE + x[i]) % HT_SIZE; 23 | return h; 24 | } 25 | #define key_t const char * 26 | #define hash_k(k) (hashu(k)) 27 | #define eq_k(x, k) (strcmp(key(x), k) == 0) 28 | #else 29 | #define hash_k(k) (k % HT_SIZE) 30 | #define key_t unsigned 31 | #define eq_k(x, k) (key(x) == k) 32 | #endif 33 | 34 | #define hash(x) (hash_k(key(x))) 35 | 36 | typedef struct LinkedItem 37 | { 38 | Item item; 39 | struct LinkedItem *next; 40 | } LinkedItem; 41 | 42 | typedef struct HashTable 43 | { 44 | unsigned size; 45 | LinkedItem **v; 46 | } HashTable; 47 | 48 | HashTable HT_init() 49 | { 50 | HashTable ht = {.size = 0}; 51 | ht.v = (LinkedItem **)malloc(HT_SIZE * sizeof(LinkedItem *)); 52 | for (unsigned i = 0; i < HT_SIZE; i++) 53 | ht.v[i] = NULL; 54 | return ht; 55 | } 56 | 57 | void HT_free(HashTable ht) 58 | { 59 | for (unsigned i; i < HT_SIZE; i++) 60 | { 61 | LinkedItem *prev = ht.v[i], *next = NULL; 62 | while (prev) 63 | { 64 | next = prev->next; 65 | free(prev); 66 | prev = next; 67 | } 68 | } 69 | free(ht.v); 70 | } 71 | 72 | int HT_insert(HashTable *ht, Item x) 73 | { 74 | unsigned h = hash(x); 75 | if (!ht->v[h]) 76 | { 77 | ht->v[h] = (LinkedItem *)malloc(sizeof(LinkedItem)); 78 | *ht->v[h] = (LinkedItem){.next = NULL, .item = x}; 79 | return 1; 80 | } 81 | LinkedItem *curr = ht->v[h]; 82 | while (curr->next && !eq(curr->item, x)) 83 | curr = curr->next; 84 | if (eq(curr->item, x)) 85 | return 0; 86 | 87 | curr->next = (LinkedItem *)malloc(sizeof(LinkedItem)); 88 | *curr->next = (LinkedItem){.item = x, .next = NULL}; 89 | ht->size++; 90 | return 1; 91 | } 92 | 93 | int HT_remove(HashTable *ht, key_t k) 94 | { 95 | unsigned h = hash_k(k); 96 | if (!ht->v[h]) 97 | return 0; 98 | 99 | LinkedItem *curr = ht->v[h], *to_remove = NULL; 100 | if (eq_k(curr->item, k)) 101 | { 102 | ht->v[h] = curr->next; 103 | to_remove = curr; 104 | } 105 | else 106 | { 107 | while (curr->next && !eq_k(curr->next->item, k)) 108 | curr = curr->next; 109 | 110 | if (!curr->next) 111 | return 0; 112 | 113 | to_remove = curr->next; 114 | curr->next = to_remove->next; 115 | } 116 | 117 | free(to_remove); 118 | return 1; 119 | } 120 | 121 | int HT_delete(HashTable *ht, Item x) 122 | { 123 | unsigned h = hash(x); 124 | if (!ht->v[h]) 125 | return 0; 126 | 127 | LinkedItem *curr = ht->v[h], *to_remove = NULL; 128 | if (eq(curr->item, x)) 129 | { 130 | ht->v[h] = curr->next; 131 | to_remove = curr; 132 | } 133 | else 134 | { 135 | while (curr->next && !eq(curr->next->item, x)) 136 | curr = curr->next; 137 | 138 | if (!curr->next) 139 | return 0; 140 | 141 | to_remove = curr->next; 142 | curr->next = to_remove->next; 143 | } 144 | 145 | free(to_remove); 146 | return 1; 147 | } 148 | 149 | LinkedItem *HT_search(HashTable ht, key_t k) 150 | { 151 | unsigned h = hash_k(k); 152 | LinkedItem *curr = ht.v[h]; 153 | while (curr) 154 | { 155 | if (eq_k(curr->item, k)) 156 | return curr; 157 | curr = curr->next; 158 | } 159 | return NULL; 160 | } 161 | 162 | int HT_contains(HashTable ht, Item x) 163 | { 164 | LinkedItem *curr = ht.v[hash(x)]; 165 | while (curr) 166 | { 167 | if (eq(curr->item, x)) 168 | return 1; 169 | curr = curr->next; 170 | } 171 | return 0; 172 | } 173 | 174 | 175 | void solve() 176 | { 177 | HashTable ht = HT_init(); 178 | Item item; 179 | unsigned mn = 1 << 31, mx = 0; 180 | while (scanf(" %d %c", &item.k, &item.v) == 2) 181 | { 182 | HT_insert(&ht, item); 183 | mn = item.k < mn ? item.k : mn; 184 | mx = item.k > mx ? item.k : mx; 185 | } 186 | 187 | for (unsigned i = mn; i <= mx; i++) 188 | { 189 | LinkedItem *li = HT_search(ht, i); 190 | if (li) 191 | printf("%c", li->item.v); 192 | } 193 | printf("\n"); 194 | } 195 | 196 | int main() 197 | { 198 | solve(); 199 | 200 | return 0; 201 | } 202 | -------------------------------------------------------------------------------- /Lista 6/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define min(a, b) (a < b ? a : b) 5 | #define max(a, b) (b < a ? a : b) 6 | #define Item int 7 | #define key(x) (x) 8 | #define less(a, b) (a > b) 9 | #define swap(a, b) \ 10 | { \ 11 | Item t = a; \ 12 | a = b; \ 13 | b = t; \ 14 | } 15 | #define cmpswap(a, b) \ 16 | if (less(b, a)) \ 17 | swap(a, b) 18 | 19 | Item NULL_ITEM = -1; 20 | 21 | typedef struct 22 | { 23 | Item *heap; 24 | size_t size, capacity; 25 | } PriorityQueue; 26 | 27 | void HEAP_fixup(Item *heap, int i) 28 | { 29 | for (; i > 1 && less(heap[i / 2], heap[i]); i /= 2) 30 | swap(heap[i], heap[i / 2]); 31 | } 32 | 33 | void HEAP_fixdown(Item *heap, size_t size, int i) 34 | { 35 | for (int larger = i * 2; i * 2 <= size; i = larger, larger = i * 2) 36 | { 37 | if (larger < size && less(heap[larger], heap[larger + 1])) 38 | larger++; 39 | 40 | if (!less(heap[i], heap[larger])) 41 | break; 42 | 43 | swap(heap[i], heap[larger]); 44 | } 45 | } 46 | 47 | PriorityQueue PQ_init(size_t capacity) 48 | { 49 | PriorityQueue pq = {.capacity = capacity, .size = 0}; 50 | pq.heap = malloc((capacity + 1) * sizeof(Item)); 51 | return pq; 52 | } 53 | 54 | void PQ_free(PriorityQueue pq) 55 | { 56 | free(pq.heap); 57 | } 58 | 59 | int PQ_isEmpty(PriorityQueue pq) 60 | { 61 | return pq.size == 0; 62 | } 63 | 64 | void PQ_ensureCapacity(PriorityQueue *pq, size_t newCapacity) 65 | { 66 | if (newCapacity <= pq->capacity) 67 | return; 68 | 69 | pq->capacity *= 4; 70 | pq->heap = realloc(pq->heap, (pq->capacity + 1) * sizeof(Item)); 71 | } 72 | 73 | void PQ_insert(PriorityQueue *pq, Item x) 74 | { 75 | PQ_ensureCapacity(pq, pq->size + 1); 76 | pq->heap[++pq->size] = x; 77 | HEAP_fixup(pq->heap, pq->size); 78 | } 79 | 80 | Item PQ_getTop(PriorityQueue pq) 81 | { 82 | return pq.heap[1]; 83 | } 84 | 85 | Item PQ_extractTop(PriorityQueue *pq) 86 | { 87 | if (PQ_isEmpty(*pq)) 88 | return NULL_ITEM; 89 | 90 | Item top = PQ_getTop(*pq); 91 | pq->heap[1] = pq->heap[pq->size--]; 92 | HEAP_fixdown(pq->heap, pq->size, 1); 93 | return top; 94 | } 95 | 96 | int main() 97 | { 98 | PriorityQueue pq = PQ_init(16); 99 | int t, p, v[100]; 100 | 101 | while (scanf(" %d %d", &t, &p) == 2) 102 | { 103 | if (t == 1) 104 | PQ_insert(&pq, p); 105 | else 106 | { 107 | int n; 108 | for (n = 0; n < p; n++) 109 | { 110 | int top = PQ_extractTop(&pq); 111 | if (top == NULL_ITEM) 112 | break; 113 | v[n] = top; 114 | } 115 | for (int i = 0; i < n; i++) 116 | { 117 | printf("%d%c", v[i], " \n"[i == n-1]); 118 | PQ_insert(&pq, v[i]); 119 | } 120 | } 121 | } 122 | 123 | PQ_free(pq); 124 | 125 | return 0; 126 | } 127 | -------------------------------------------------------------------------------- /Lista 6/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define min(a, b) (a < b ? a : b) 5 | #define max(a, b) (b < a ? a : b) 6 | // #define Item int 7 | #define key(x) (x->value) 8 | #define less(a, b) (key(a) > key(b)) 9 | #define swap(a, b) \ 10 | { \ 11 | Item t = a; \ 12 | a = b; \ 13 | b = t; \ 14 | } 15 | #define cmpswap(a, b) \ 16 | if (less(b, a)) \ 17 | swap(a, b) 18 | 19 | struct Item 20 | { 21 | int heap_idx, value; 22 | }; 23 | 24 | typedef struct Item *Item; 25 | 26 | Item NULL_ITEM = NULL; 27 | 28 | typedef struct 29 | { 30 | Item *heap; 31 | size_t size, capacity; 32 | } PriorityQueue; 33 | 34 | void HEAP_fixup(Item *heap, int i) 35 | { 36 | for (; i > 1 && less(heap[i / 2], heap[i]); i /= 2) 37 | { 38 | swap(heap[i], heap[i / 2]); 39 | heap[i]->heap_idx = i; 40 | heap[i / 2]->heap_idx = i / 2; 41 | } 42 | } 43 | 44 | void HEAP_fixdown(Item *heap, size_t size, int i) 45 | { 46 | for (int larger = i * 2; i * 2 <= size; i = larger, larger = i * 2) 47 | { 48 | if (larger < size && less(heap[larger], heap[larger + 1])) 49 | larger++; 50 | 51 | if (!less(heap[i], heap[larger])) 52 | break; 53 | 54 | swap(heap[i], heap[larger]); 55 | heap[i]->heap_idx = i; 56 | heap[larger]->heap_idx = larger; 57 | } 58 | } 59 | 60 | PriorityQueue PQ_init(size_t capacity) 61 | { 62 | PriorityQueue pq = {.capacity = capacity, .size = 0}; 63 | pq.heap = malloc((capacity + 1) * sizeof(Item)); 64 | return pq; 65 | } 66 | 67 | void PQ_free(PriorityQueue pq) 68 | { 69 | free(pq.heap); 70 | } 71 | 72 | int PQ_isEmpty(PriorityQueue pq) 73 | { 74 | return pq.size == 0; 75 | } 76 | 77 | void PQ_ensureCapacity(PriorityQueue *pq, size_t newCapacity) 78 | { 79 | if (newCapacity <= pq->capacity) 80 | return; 81 | 82 | pq->capacity *= 4; 83 | pq->heap = realloc(pq->heap, (pq->capacity + 1) * sizeof(Item)); 84 | } 85 | 86 | void PQ_insert(PriorityQueue *pq, Item x) 87 | { 88 | PQ_ensureCapacity(pq, pq->size + 1); 89 | pq->heap[++pq->size] = x; 90 | x->heap_idx = pq->size; 91 | HEAP_fixup(pq->heap, pq->size); 92 | } 93 | 94 | Item PQ_getTop(PriorityQueue pq) 95 | { 96 | return pq.heap[1]; 97 | } 98 | 99 | Item PQ_extractTop(PriorityQueue *pq) 100 | { 101 | if (PQ_isEmpty(*pq)) 102 | return NULL_ITEM; 103 | 104 | Item top = PQ_getTop(*pq); 105 | pq->heap[1] = pq->heap[pq->size--]; 106 | HEAP_fixdown(pq->heap, pq->size, 1); 107 | return top; 108 | } 109 | 110 | Item PQ_remove(PriorityQueue *pq, int i) 111 | { 112 | if (i < 1 || i > pq->size) 113 | return NULL_ITEM; 114 | 115 | Item removed = pq->heap[i]; 116 | pq->heap[i] = pq->heap[pq->size--]; 117 | HEAP_fixdown(pq->heap, pq->size, i); 118 | return removed; 119 | } 120 | 121 | void solve() 122 | { 123 | int n, k; 124 | scanf(" %d %d\n", &n, &k); 125 | if (n == 0 && k == 0) 126 | return; 127 | 128 | Item v = malloc(n * sizeof(struct Item)); 129 | for (int i = 0; i < n; i++) 130 | scanf(" %d", &v[i].value); 131 | 132 | PriorityQueue pq = PQ_init(k); 133 | for (int i = 0; i < k - 1; i++) 134 | PQ_insert(&pq, &v[i]); 135 | 136 | for (int i = k - 1; i < n; i++) 137 | { 138 | PQ_insert(&pq, &v[i]); 139 | printf("%d%c", PQ_getTop(pq)->value, " \n"[i == n-1]); 140 | PQ_remove(&pq, v[i - k + 1].heap_idx); 141 | } 142 | 143 | PQ_free(pq); 144 | solve(); 145 | } 146 | 147 | int main() 148 | { 149 | solve(); 150 | 151 | return 0; 152 | } 153 | -------------------------------------------------------------------------------- /Lista 7/A.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int g[2010][2010]; 5 | int v[2010]; 6 | 7 | void solve() 8 | { 9 | int n, m, j; 10 | scanf(" %d %d %d", &n, &m, &j); 11 | for (int i = 0, x, y; i < n; i++) 12 | { 13 | g[i][i] = 1; 14 | scanf(" %d", &x); 15 | while (x--) 16 | { 17 | scanf(" %d", &y); 18 | g[i][y] = 1; 19 | } 20 | } 21 | 22 | for (int i = 0, x; i < m; i++) 23 | { 24 | scanf(" %d", &x); 25 | for (int y = 0; y < n; y++) 26 | if (g[x][y] == 1) 27 | v[y] = 2; 28 | } 29 | 30 | while (j--) 31 | { 32 | int x; 33 | scanf(" %d", &x); 34 | printf("%s vou estar la\n", (v[x] == 2 ? "Eu" : "Nao")); 35 | } 36 | } 37 | 38 | int main() 39 | { 40 | solve(); 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /Lista 7/B.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define GRAPH_WEIGHT_T int 5 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 6 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 7 | #define GRAPH_WEIGHT_INF 2147483647 8 | 9 | typedef struct 10 | { 11 | unsigned from, to; 12 | GRAPH_WEIGHT_T weight; 13 | } Edge; 14 | 15 | typedef struct 16 | { 17 | GRAPH_WEIGHT_T **edges; 18 | unsigned vertices; 19 | } Graph; 20 | 21 | Graph G_init(unsigned vertices) 22 | { 23 | Graph g = {.vertices = vertices}; 24 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.vertices); 25 | for (unsigned i = 0; i < g.vertices; i++) 26 | { 27 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.vertices); 28 | for (unsigned j = 0; j < g.vertices; j++) 29 | g.edges[i][j] = GRAPH_WEIGHT_INF; 30 | } 31 | return g; 32 | } 33 | 34 | void G_free(Graph g) 35 | { 36 | for (unsigned i = 0; i < g.vertices; i++) 37 | free(g.edges[i]); 38 | free(g.edges); 39 | } 40 | 41 | void G_insert(Graph *g, Edge e) 42 | { 43 | if (e.from > g->vertices || e.to > g->vertices) 44 | return; 45 | 46 | g->edges[e.from][e.to] = e.weight; 47 | } 48 | 49 | void G_dfs(Graph g, int start, int visited[]) 50 | { 51 | visited[start] = 1; 52 | for (unsigned i = 0; i < g.vertices; i++) 53 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && !visited[i]) 54 | G_dfs(g, i, visited); 55 | } 56 | 57 | 58 | int vi[5001]; 59 | 60 | void solve() 61 | { 62 | int v; 63 | scanf(" %d", &v); 64 | 65 | Graph g = G_init(v); 66 | for (int from, to; scanf(" %d %d", &from, &to) == 2;) 67 | { 68 | G_insert(&g, (Edge){.from = from, .to = to}); 69 | G_insert(&g, (Edge){.from = to, .to = from}); 70 | } 71 | 72 | int ans = 0; 73 | for (int i = 0; i < v; i++) 74 | if (!vi[i]) 75 | { 76 | G_dfs(g, i, vi); 77 | ans++; 78 | } 79 | 80 | printf("%d\n", ans); 81 | 82 | G_free(g); 83 | } 84 | 85 | int main() 86 | { 87 | solve(); 88 | 89 | return 0; 90 | } 91 | -------------------------------------------------------------------------------- /Lista 7/C.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define Item int 5 | #define key(x) (x) 6 | #define less(a, b) (a < b) 7 | #define swap(a, b) \ 8 | { \ 9 | Item t = a; \ 10 | a = b; \ 11 | b = t; \ 12 | } 13 | #define cmpswap(a, b) \ 14 | if (less(b, a)) \ 15 | swap(a, b) 16 | 17 | int partition(Item *v, int l, int r) 18 | { 19 | Item pivot = v[r]; 20 | int j = l; 21 | for (int k = l; k < r; k++) 22 | if (less(v[k], pivot)) 23 | { 24 | swap(v[k], v[j]); 25 | j++; 26 | } 27 | swap(v[j], v[r]); 28 | return j; 29 | } 30 | 31 | void quicksortM3(Item *v, int l, int r) 32 | { 33 | if (r - l <= 32) 34 | return; 35 | 36 | swap(v[(l + r) / 2], v[r - 1]); 37 | cmpswap(v[l], v[r - 1]); 38 | cmpswap(v[l], v[r]); 39 | cmpswap(v[r - 1], v[r]); 40 | 41 | int m = partition(v, l, r); 42 | quicksortM3(v, l, m - 1); 43 | quicksortM3(v, m + 1, r); 44 | } 45 | 46 | void insertionsort(Item *v, int l, int r) 47 | { 48 | for (int i = l + 1, j; i <= r; i++) 49 | { 50 | Item t = v[i]; 51 | for (j = i; j > 0 && less(t, v[j - 1]); j--) 52 | v[j] = v[j - 1]; 53 | v[j] = t; 54 | } 55 | } 56 | 57 | void quicksort(Item *v, int l, int r) 58 | { 59 | quicksortM3(v, l, r); 60 | insertionsort(v, l, r); 61 | } 62 | 63 | #define GRAPH_WEIGHT_T int 64 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 65 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 66 | #define GRAPH_WEIGHT_INF 2147483647 67 | 68 | typedef struct 69 | { 70 | unsigned from, to; 71 | GRAPH_WEIGHT_T weight; 72 | } Edge; 73 | 74 | typedef struct 75 | { 76 | GRAPH_WEIGHT_T **edges; 77 | unsigned V, E; 78 | } Graph; 79 | 80 | Graph G_init(unsigned numberOfVertices) 81 | { 82 | Graph g = {.V = numberOfVertices, .E = 0}; 83 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.V); 84 | for (unsigned i = 0; i < g.V; i++) 85 | { 86 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.V); 87 | for (unsigned j = 0; j < g.V; j++) 88 | g.edges[i][j] = GRAPH_WEIGHT_INF; 89 | } 90 | return g; 91 | } 92 | 93 | void G_free(Graph g) 94 | { 95 | for (unsigned i = 0; i < g.V; i++) 96 | free(g.edges[i]); 97 | free(g.edges); 98 | } 99 | 100 | void G_insert(Graph *g, Edge e) 101 | { 102 | if (e.from > g->V || e.to > g->V) 103 | return; 104 | 105 | g->E += (g->edges[e.from][e.to] == GRAPH_WEIGHT_INF); 106 | g->edges[e.from][e.to] = e.weight; 107 | } 108 | 109 | int G_numberOfEdges(Graph g) 110 | { 111 | return g.E; 112 | } 113 | 114 | int G_numberOfVertices(Graph g) 115 | { 116 | return g.V; 117 | } 118 | 119 | void G_components(Graph g, int start, int components[]) 120 | { 121 | if (components[start] < 0) 122 | components[start] = start; 123 | for (unsigned i = 0; i < g.V; i++) 124 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && components[i] < 0) 125 | { 126 | int mn = ((int)i < components[start] ? (int)i : components[start]); 127 | components[start] = mn; 128 | components[i] = mn; 129 | G_components(g, i, components); 130 | } 131 | } 132 | 133 | int co[5001]; 134 | 135 | void solve() 136 | { 137 | int v, s; 138 | scanf(" %d %d", &v, &s); 139 | 140 | Graph g = G_init(v); 141 | for (int f, t; scanf(" %d %d", &f, &t) == 2;) 142 | { 143 | G_insert(&g, (Edge){.from = f, .to = t}); 144 | G_insert(&g, (Edge){.from = t, .to = f}); 145 | } 146 | 147 | for (int i = 0; i < v; i++) 148 | co[i] = -1; 149 | 150 | for (int i = 0; i < v; i++) 151 | G_components(g, i, co); 152 | 153 | G_free(g); 154 | 155 | int *freq = malloc(sizeof(int) * v); 156 | for (int i = 0; i < v; i++) 157 | freq[i] = 0; 158 | 159 | int ans = v - 1; 160 | for (int i = v - 1; i >= 0; i--) 161 | { 162 | if (++freq[co[i]] > freq[ans] || (freq[co[i]] == freq[ans] && ans != co[s] && co[i] < ans)) 163 | ans = co[i]; 164 | } 165 | free(freq); 166 | 167 | if (ans == co[s] && G_numberOfEdges(g) == 0) 168 | printf("Fique em casa\n"); 169 | else if (ans == co[s]) 170 | printf("Bora pra estrada\n"); 171 | else 172 | printf("Vamos para %d\n", ans); 173 | } 174 | 175 | int main() 176 | { 177 | solve(); 178 | 179 | return 0; 180 | } 181 | -------------------------------------------------------------------------------- /Lista 7/D.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define GRAPH_WEIGHT_T int 5 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 6 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 7 | #define GRAPH_WEIGHT_INF 2147483647 8 | 9 | typedef struct 10 | { 11 | unsigned from, to; 12 | GRAPH_WEIGHT_T weight; 13 | } Edge; 14 | 15 | typedef struct 16 | { 17 | GRAPH_WEIGHT_T **edges; 18 | unsigned V, E; 19 | } Graph; 20 | 21 | Graph G_init(unsigned numberOfVertices) 22 | { 23 | Graph g = {.V = numberOfVertices, .E = 0}; 24 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.V); 25 | for (unsigned i = 0; i < g.V; i++) 26 | { 27 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.V); 28 | for (unsigned j = 0; j < g.V; j++) 29 | g.edges[i][j] = GRAPH_WEIGHT_INF; 30 | } 31 | return g; 32 | } 33 | 34 | void G_free(Graph g) 35 | { 36 | for (unsigned i = 0; i < g.V; i++) 37 | free(g.edges[i]); 38 | free(g.edges); 39 | } 40 | 41 | void G_insert(Graph *g, Edge e) 42 | { 43 | if (e.from > g->V || e.to > g->V) 44 | return; 45 | 46 | g->E += (g->edges[e.from][e.to] == GRAPH_WEIGHT_INF); 47 | g->edges[e.from][e.to] = e.weight; 48 | } 49 | 50 | int G_numberOfEdges(Graph g) 51 | { 52 | return g.E; 53 | } 54 | 55 | int G_numberOfVertices(Graph g) 56 | { 57 | return g.V; 58 | } 59 | 60 | void G_components(Graph g, int start, int components[]) 61 | { 62 | if (components[start] < 0) 63 | components[start] = start; 64 | for (unsigned i = 0; i < g.V; i++) 65 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && components[i] < 0) 66 | { 67 | int mn = ((int)i < components[start] ? (int)i : components[start]); 68 | components[start] = mn; 69 | components[i] = mn; 70 | G_components(g, i, components); 71 | } 72 | } 73 | 74 | void G_transitiveClosure(Graph g, int transitive[][2001]) 75 | { 76 | for (unsigned i = 0; i < g.V; i++) 77 | { 78 | for (unsigned j = 0; j < g.V; j++) 79 | transitive[i][j] = g.edges[i][j] != GRAPH_WEIGHT_INF; 80 | transitive[i][i] = 1; 81 | } 82 | 83 | for (unsigned i = 0; i < g.V; i++) 84 | for (unsigned j = 0; j < g.V; j++) 85 | if (transitive[j][i] == 1) 86 | for (unsigned k = 0; k < g.V; k++) 87 | if (transitive[i][k] == 1) 88 | transitive[j][k] = 1; 89 | } 90 | 91 | int tc[2001][2001]; 92 | 93 | void solve() 94 | { 95 | int v; 96 | scanf(" %d", &v); 97 | 98 | Graph g = G_init(v); 99 | for (int f, t, d; scanf(" %d %d %d", &f, &t, &d) == 3 && d;) 100 | { 101 | G_insert(&g, (Edge){.from = f, .to = t, .weight = 1}); 102 | if (d == 2) 103 | G_insert(&g, (Edge){.from = t, .to = f, .weight = 1}); 104 | } 105 | 106 | G_transitiveClosure(g, tc); 107 | G_free(g); 108 | 109 | for (int t, x; scanf(" %d %d", &t, &x) == 2;) 110 | printf("%s\n", (tc[t][x] && tc[x][t] ? "Ida e Volta" : (tc[t][x] ? "Apenas Ida" : (tc[x][t] ? "Apenas Volta" : "Impossibru")))); 111 | } 112 | 113 | int main() 114 | { 115 | solve(); 116 | 117 | return 0; 118 | } 119 | -------------------------------------------------------------------------------- /Lista 7/E.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define QUEUE_T int 5 | 6 | typedef struct Q_I 7 | { 8 | QUEUE_T val; 9 | struct Q_I *next; 10 | } QueueItem; 11 | 12 | typedef struct 13 | { 14 | size_t size; 15 | QueueItem *head; 16 | QueueItem *tail; 17 | } Queue; 18 | 19 | Queue Q_init() 20 | { 21 | return (Queue){.head = NULL, .tail = NULL, .size = 0}; 22 | } 23 | 24 | int Q_empty(Queue q) 25 | { 26 | return q.size == 0; 27 | } 28 | 29 | QUEUE_T Q_front(Queue q) 30 | { 31 | QUEUE_T front; 32 | if (!Q_empty(q)) 33 | front = q.head->val; 34 | return front; 35 | } 36 | 37 | QUEUE_T Q_back(Queue q) 38 | { 39 | QUEUE_T back; 40 | if (!Q_empty(q)) 41 | back = q.tail->val; 42 | return back; 43 | } 44 | 45 | void Q_push(Queue *q, QUEUE_T value) 46 | { 47 | QueueItem *qi = malloc(sizeof(QueueItem)); 48 | qi->val = value; 49 | qi->next = NULL; 50 | 51 | if (Q_empty(*q)) 52 | { 53 | q->head = qi; 54 | q->tail = qi; 55 | } 56 | else 57 | { 58 | q->tail->next = qi; 59 | q->tail = qi; 60 | } 61 | q->size++; 62 | } 63 | 64 | QUEUE_T Q_pop(Queue *q) 65 | { 66 | QUEUE_T value = Q_front(*q); 67 | if (!Q_empty(*q)) 68 | { 69 | QueueItem *toRemove = q->head; 70 | q->head = toRemove->next; 71 | if (!q->head) 72 | q->tail = NULL; 73 | free(toRemove); 74 | q->size--; 75 | } 76 | return value; 77 | } 78 | 79 | void Q_clear(Queue *q) 80 | { 81 | while (!Q_empty(*q)) 82 | Q_pop(q); 83 | } 84 | 85 | #define GRAPH_WEIGHT_T int 86 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 87 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 88 | #define GRAPH_WEIGHT_INF 2147483647 89 | 90 | typedef struct 91 | { 92 | unsigned from, to; 93 | GRAPH_WEIGHT_T weight; 94 | } Edge; 95 | 96 | typedef struct 97 | { 98 | GRAPH_WEIGHT_T **edges; 99 | unsigned V, E; 100 | } Graph; 101 | 102 | Graph G_init(unsigned numberOfVertices) 103 | { 104 | Graph g = {.V = numberOfVertices, .E = 0}; 105 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.V); 106 | for (unsigned i = 0; i < g.V; i++) 107 | { 108 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.V); 109 | for (unsigned j = 0; j < g.V; j++) 110 | g.edges[i][j] = GRAPH_WEIGHT_INF; 111 | } 112 | return g; 113 | } 114 | 115 | void G_free(Graph g) 116 | { 117 | for (unsigned i = 0; i < g.V; i++) 118 | free(g.edges[i]); 119 | free(g.edges); 120 | } 121 | 122 | void G_insert(Graph *g, Edge e) 123 | { 124 | if (e.from > g->V || e.to > g->V) 125 | return; 126 | 127 | g->E += (g->edges[e.from][e.to] == GRAPH_WEIGHT_INF); 128 | g->edges[e.from][e.to] = e.weight; 129 | } 130 | 131 | int G_numberOfEdges(Graph g) 132 | { 133 | return g.E; 134 | } 135 | 136 | int G_numberOfVertices(Graph g) 137 | { 138 | return g.V; 139 | } 140 | 141 | void G_components(Graph g, int start, int components[]) 142 | { 143 | if (components[start] < 0) 144 | components[start] = start; 145 | for (unsigned i = 0; i < g.V; i++) 146 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && components[i] < 0) 147 | { 148 | int mn = ((int)i < components[start] ? (int)i : components[start]); 149 | components[start] = mn; 150 | components[i] = mn; 151 | G_components(g, i, components); 152 | } 153 | } 154 | 155 | void G_transitiveClosure(Graph g, int transitive[][2001]) 156 | { 157 | for (unsigned i = 0; i < g.V; i++) 158 | { 159 | for (unsigned j = 0; j < g.V; j++) 160 | transitive[i][j] = g.edges[i][j] != GRAPH_WEIGHT_INF; 161 | transitive[i][i] = 1; 162 | } 163 | 164 | for (unsigned i = 0; i < g.V; i++) 165 | for (unsigned j = 0; j < g.V; j++) 166 | if (transitive[j][i] == 1) 167 | for (unsigned k = 0; k < g.V; k++) 168 | if (transitive[i][k] == 1) 169 | transitive[j][k] = 1; 170 | } 171 | 172 | short G_bestPathBF(Graph g, int start, GRAPH_WEIGHT_T *dist) 173 | { 174 | short *onQueue = malloc(sizeof(short) * g.V); 175 | for (unsigned i = 0; i < g.V; i++) 176 | dist[i] = GRAPH_WEIGHT_INF, onQueue[i] = 0; 177 | dist[start] = 0; 178 | 179 | Queue q = Q_init(); 180 | Q_push(&q, start); 181 | onQueue[start] = 1; 182 | 183 | const int sentinel = g.V; 184 | unsigned k = 0; 185 | Q_push(&q, sentinel); 186 | 187 | while (!Q_empty(q)) 188 | { 189 | int v = Q_pop(&q); 190 | if (v < sentinel) 191 | { 192 | for (unsigned i = 0; i < g.V; i++) 193 | { 194 | if (g.edges[v][i] == GRAPH_WEIGHT_INF) 195 | continue; 196 | 197 | if (GRAPH_WEIGHT_LESS(GRAPH_WEIGHT_SUM(dist[v], g.edges[v][i]), dist[i])) 198 | { 199 | dist[i] = k == g.V ? GRAPH_WEIGHT_INF : GRAPH_WEIGHT_SUM(dist[v], g.edges[v][i]); 200 | if (!onQueue[i]) 201 | { 202 | Q_push(&q, i); 203 | onQueue[i] = 1; 204 | } 205 | } 206 | } 207 | } 208 | else 209 | { 210 | if (Q_empty(q)) 211 | return 1; 212 | if (++k >= g.V + 1) 213 | return 0; 214 | Q_push(&q, v); 215 | for (unsigned i = 0; i < g.V; i++) 216 | onQueue[i] = 0; 217 | } 218 | } 219 | 220 | Q_clear(&q); 221 | free(onQueue); 222 | return 1; 223 | } 224 | 225 | int distX[2001][2001], distS[2001][2001], tc[2001][2001], negative_cycles[2001]; 226 | 227 | void solve() 228 | { 229 | int v; 230 | scanf(" %d", &v); 231 | 232 | Graph gX = G_init(v), gS = G_init(v); 233 | for (int f, t, c, d; scanf(" %d %d %d %d", &f, &t, &c, &d) == 4 && (f | t | c | d);) 234 | { 235 | G_insert(&gS, (Edge){.from = f, .to = t, .weight = c}); 236 | if (d == 0) 237 | G_insert(&gS, (Edge){.from = t, .to = f, .weight = c}); 238 | 239 | if (d == 1) 240 | continue; 241 | 242 | G_insert(&gX, (Edge){.from = f, .to = t, .weight = c}); 243 | G_insert(&gX, (Edge){.from = t, .to = f, .weight = c}); 244 | } 245 | 246 | for (int i = 0; i < G_numberOfVertices(gS); i++) 247 | { 248 | if (!G_bestPathBF(gS, i, distS[i])) 249 | negative_cycles[i] = 1; 250 | G_bestPathBF(gX, i, distX[i]); 251 | } 252 | 253 | G_transitiveClosure(gS, tc); 254 | 255 | G_free(gX); 256 | G_free(gS); 257 | 258 | for (int t, x; scanf(" %d %d", &t, &x) == 2;) 259 | { 260 | int ans = distS[t][x] != GRAPH_WEIGHT_INF && distX[t][x] != GRAPH_WEIGHT_INF; 261 | if (negative_cycles[t]) 262 | { 263 | for (int i = 0; i < v && ans; i++) 264 | if (distS[t][i] == GRAPH_WEIGHT_INF && (tc[i][t] || tc[i][x])) 265 | ans = 0; 266 | } 267 | 268 | if (ans) 269 | printf("%d %d\n", distX[t][x], distS[t][x]); 270 | else 271 | printf("Impossibru\n"); 272 | } 273 | } 274 | 275 | int main() 276 | { 277 | solve(); 278 | 279 | return 0; 280 | } 281 | -------------------------------------------------------------------------------- /Lista 7/F.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define GRAPH_WEIGHT_T int 6 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 7 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 8 | #define GRAPH_WEIGHT_INF 2147483647 9 | 10 | typedef struct 11 | { 12 | unsigned from, to; 13 | GRAPH_WEIGHT_T weight; 14 | } Edge; 15 | 16 | typedef struct 17 | { 18 | GRAPH_WEIGHT_T **edges; 19 | unsigned V, E; 20 | } Graph; 21 | 22 | Graph G_init(unsigned numberOfVertices) 23 | { 24 | Graph g = {.V = numberOfVertices, .E = 0}; 25 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.V); 26 | for (unsigned i = 0; i < g.V; i++) 27 | { 28 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.V); 29 | for (unsigned j = 0; j < g.V; j++) 30 | g.edges[i][j] = GRAPH_WEIGHT_INF; 31 | } 32 | return g; 33 | } 34 | 35 | void G_free(Graph g) 36 | { 37 | for (unsigned i = 0; i < g.V; i++) 38 | free(g.edges[i]); 39 | free(g.edges); 40 | } 41 | 42 | void G_insert(Graph *g, Edge e) 43 | { 44 | if (e.from > g->V || e.to > g->V) 45 | return; 46 | 47 | g->E += (g->edges[e.from][e.to] == GRAPH_WEIGHT_INF); 48 | g->edges[e.from][e.to] = e.weight; 49 | } 50 | 51 | int G_numberOfEdges(Graph g) 52 | { 53 | return g.E; 54 | } 55 | 56 | int G_numberOfVertices(Graph g) 57 | { 58 | return g.V; 59 | } 60 | 61 | void G_components(Graph g, int start, int components[]) 62 | { 63 | if (components[start] < 0) 64 | components[start] = start; 65 | for (unsigned i = 0; i < g.V; i++) 66 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && components[i] < 0) 67 | { 68 | int mn = ((int)i < components[start] ? (int)i : components[start]); 69 | components[start] = mn; 70 | components[i] = mn; 71 | G_components(g, i, components); 72 | } 73 | } 74 | 75 | int co[5001], freq[5001]; 76 | char s[5001][32]; 77 | 78 | void solve() 79 | { 80 | int v, c; 81 | scanf(" %d %d", &v, &c); 82 | if (!v && !c) 83 | return; 84 | 85 | for (int i = 0; i < v; i++) 86 | co[i] = -1, freq[i] = 0; 87 | 88 | for (int i = 0; i < v; i++) 89 | scanf(" %s", s[i]); 90 | 91 | Graph g = G_init(v); 92 | 93 | for (int i = 0; i < c; i++) 94 | { 95 | char a[32], b[32]; 96 | scanf(" %s %s", a, b); 97 | int ai = -1, bi = -1; 98 | for (int j = 0; j < v && (ai == -1 || bi == -1); j++) 99 | { 100 | if (ai == -1 && strcmp(s[j], a) == 0) 101 | ai = j; 102 | else if (bi == -1 && strcmp(s[j], b) == 0) 103 | bi = j; 104 | } 105 | G_insert(&g, (Edge){.from = bi, .to = ai, .weight = 1}); 106 | G_insert(&g, (Edge){.from = ai, .to = bi, .weight = 1}); 107 | } 108 | 109 | for (int i = 0; i < v; i++) 110 | G_components(g, i, co); 111 | G_free(g); 112 | 113 | int ans = 0; 114 | for (int i = 0; i < v; i++) 115 | if (++freq[co[i]] > ans) 116 | ans = freq[co[i]]; 117 | 118 | printf("%d\n", ans); 119 | 120 | solve(); 121 | } 122 | 123 | int main() 124 | { 125 | solve(); 126 | 127 | return 0; 128 | } 129 | -------------------------------------------------------------------------------- /Lista 7/G.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define GRAPH_WEIGHT_T int 6 | #define GRAPH_WEIGHT_SUM(a, b) (a + b) 7 | #define GRAPH_WEIGHT_LESS(a, b) (a < b) 8 | #define GRAPH_WEIGHT_INF 2147483647 9 | 10 | typedef struct 11 | { 12 | unsigned from, to; 13 | GRAPH_WEIGHT_T weight; 14 | } Edge; 15 | 16 | typedef struct 17 | { 18 | GRAPH_WEIGHT_T **edges; 19 | unsigned V, E; 20 | } Graph; 21 | 22 | Graph G_init(unsigned numberOfVertices) 23 | { 24 | Graph g = {.V = numberOfVertices, .E = 0}; 25 | g.edges = malloc(sizeof(GRAPH_WEIGHT_T *) * g.V); 26 | for (unsigned i = 0; i < g.V; i++) 27 | { 28 | g.edges[i] = malloc(sizeof(GRAPH_WEIGHT_T) * g.V); 29 | for (unsigned j = 0; j < g.V; j++) 30 | g.edges[i][j] = GRAPH_WEIGHT_INF; 31 | } 32 | return g; 33 | } 34 | 35 | void G_free(Graph g) 36 | { 37 | for (unsigned i = 0; i < g.V; i++) 38 | free(g.edges[i]); 39 | free(g.edges); 40 | } 41 | 42 | void G_insert(Graph *g, Edge e) 43 | { 44 | if (e.from > g->V || e.to > g->V) 45 | return; 46 | 47 | g->E += (g->edges[e.from][e.to] == GRAPH_WEIGHT_INF); 48 | g->edges[e.from][e.to] = e.weight; 49 | } 50 | 51 | int G_numberOfEdges(Graph g) 52 | { 53 | return g.E; 54 | } 55 | 56 | int G_numberOfVertices(Graph g) 57 | { 58 | return g.V; 59 | } 60 | 61 | void G_components(Graph g, int start, int components[]) 62 | { 63 | if (components[start] < 0) 64 | components[start] = start; 65 | for (unsigned i = 0; i < g.V; i++) 66 | if (g.edges[start][i] != GRAPH_WEIGHT_INF && components[i] < 0) 67 | { 68 | int mn = ((int)i < components[start] ? (int)i : components[start]); 69 | components[start] = mn; 70 | components[i] = mn; 71 | G_components(g, i, components); 72 | } 73 | } 74 | 75 | void G_transitiveClosure(Graph g, int transitive[][2001]) 76 | { 77 | for (unsigned i = 0; i < g.V; i++) 78 | { 79 | for (unsigned j = 0; j < g.V; j++) 80 | transitive[i][j] = g.edges[i][j] != GRAPH_WEIGHT_INF; 81 | transitive[i][i] = 1; 82 | } 83 | 84 | for (unsigned i = 0; i < g.V; i++) 85 | for (unsigned j = 0; j < g.V; j++) 86 | if (transitive[j][i] == 1) 87 | for (unsigned k = 0; k < g.V; k++) 88 | if (transitive[i][k] == 1) 89 | transitive[j][k] = 1; 90 | } 91 | 92 | int tr[2001][2001]; 93 | 94 | void solve() 95 | { 96 | int n, m; 97 | scanf(" %d", &n); 98 | if (!n) 99 | return; 100 | scanf(" %d", &m); 101 | 102 | Graph g = G_init(n); 103 | for (int i = 0, v, w, p; i < m; i++) 104 | { 105 | scanf(" %d %d %d", &v, &w, &p); 106 | v--, w--; 107 | G_insert(&g, (Edge){.from = v, .to = w, .weight = 1}); 108 | if (p == 2) 109 | G_insert(&g, (Edge){.from = w, .to = v, .weight = 1}); 110 | } 111 | 112 | for (int i = 0; i < n; i++) 113 | for (int j = 0; j < n; j++) 114 | tr[i][j] = 0; 115 | 116 | G_transitiveClosure(g, tr); 117 | G_free(g); 118 | 119 | int ans = 1; 120 | for (int i = 0; i < n && ans; i++) 121 | for (int j = 0; j < n && ans; j++) 122 | if (!tr[i][j]) 123 | ans = 0; 124 | 125 | printf("%d\n", ans); 126 | 127 | solve(); 128 | } 129 | 130 | int main() 131 | { 132 | solve(); 133 | 134 | return 0; 135 | } 136 | -------------------------------------------------------------------------------- /Prova 1/10pontos (3).c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void merge(int *v,int l,int r1,int r2){ 4 | int *v2= malloc(sizeof(int)*(r2-l+1)); 5 | int k=0; 6 | int i = l; 7 | int j = r1+1; 8 | while(i<=r1 && j<=r2){ 9 | if(v[i]=r)return; 26 | int meio = (l+r)/2; 27 | mergesort(v,l,meio); 28 | mergesort(v,meio+1,r); 29 | merge(v,l,meio,r); 30 | 31 | } 32 | int BuscaBinaria(int *vetor, int procurado, int tamanho){ 33 | int inicio = 0; 34 | int fim = tamanho; 35 | int meio; 36 | while(inicio <= fim){ 37 | meio = (inicio + fim)/2; 38 | if(procurado > vetor[meio]){ 39 | inicio = meio+1; 40 | } else if(procurado < vetor[meio]){ 41 | fim = meio-1; 42 | }else if (procurado == vetor[meio]){ 43 | return 1; 44 | } 45 | 46 | } 47 | 48 | return -1; 49 | } 50 | 51 | int main(){ 52 | int n; 53 | int input; 54 | int *v; 55 | scanf("%d", &n); 56 | 57 | v=malloc(sizeof(int)*n); 58 | 59 | for(int i=0; i 2 | #include 3 | typedef int Item; 4 | #define less(A,B) ((A) < (B)) 5 | #define lesseq(A,B) ((A) <= (B)) 6 | #define exch(A,B) { Item t; t=A;A=B;B=t; } 7 | #define cmpexch(A,B) { if (less(B,A)) exch(A,B); } 8 | 9 | int separa(int *V,int l,int r) 10 | { 11 | int c=V[r]; 12 | int j=l; 13 | int aux; 14 | for(int k=l;kk)quickselect(v,l,i-1,k); 45 | if(i 2 | #include 3 | #include 4 | 5 | typedef struct Saida{ 6 | int quantidade; 7 | int posicao; 8 | char letra; 9 | }Saida; 10 | merge(struct Saida *v,int l,int r1,int r2){ 11 | struct Saida *v2=malloc(sizeof(Saida)*(r2-l+1)); 12 | int k=0; 13 | int i = l; 14 | int j = r1+1; 15 | while(i<=r1 && j<=r2){ 16 | if(v[i].quantidade=r)return; 33 | int meio = (l+r)/2; 34 | mergesort(v,l,meio); 35 | mergesort(v,meio+1,r); 36 | merge(v,l,meio,r); 37 | 38 | } 39 | 40 | 41 | int main(){ 42 | char frase[100001]; 43 | scanf("%s", frase); 44 | int j=0; 45 | int z=0; 46 | struct Saida a[strlen(frase)]; 47 | a[z].quantidade=0; 48 | for(int i=0;i=0; i--){ 61 | printf(" %d %c %d\n", a[i].quantidade, a[i].letra, a[i].posicao); 62 | } 63 | 64 | 65 | 66 | 67 | 68 | return 0; 69 | } 70 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # EDA2_FGA_UnB 2 | EDA1_FGA_UnB 📚-Repositório Criado para a disciplina de Estrutura de Dados e Algoritmos 2 do Professor Bruno Ribas da FGA-UnB 3 | # Colaboradores 4 | Eu,Lucas Ramon, e os camaradas Felipe Alef e Thalisson Alves unimos esforços para deixar alguns problemas do [CD-MOJ](https://moj.naquadah.com.br/cgi-bin/index.sh) resolvidos e ajudar uma geração de outros camaradas que estão sofrendo para solucionar estes mesmos problemas. Use com sabedoria, meu(minha) jovem pois há o plagiator que identifica plágios e o seu coleguinha também tem acesso a este repositório. A ideia é mostrar o caminho das pedras. Um abraço e que você possa aprender muito com esse repositório !!! 5 | - [Lucas Ramon](https://github.com/lramon2001); 6 | - [Felipe Alef](https://github.com/Alef012); 7 | - [Thalisson Alves](https://github.com/Thalisson-Alves). 8 | 9 | 10 | ## 1ª Lista de EDA-2 2021/2 - Desenferrujando para o semestre 11 | A Lista 1 foi, basicamente, uma revisão de Algoritmos e programação de computadores. Com 11 problemas de resolução puramente algorítmica na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 12 | - A: [Olá Mundo](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/olamundo.pdf); 13 | - B1: [Soma 2](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/soma2.html); 14 | - B2: [Soma N](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/soma.html); 15 | - C: [EOF](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/eof.html); 16 | - D: [Ansiedade](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/ansiedade.html); 17 | - E: [ctrl z](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/ctrl-z.html); 18 | - F: [Conta 7](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/count7.html); 19 | - G: [Ultrapassaminimamente](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/ultrapassaminimamente.html); 20 | - H1: [Soma String](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-lista1-relembrando/soma_string.html); 21 | - H2: [Quem vai ser reprovado](https://br.spoj.com/problems/PLACAR.pdf); 22 | - I: [Frequência na Aula](https://br.spoj.com/problems/FREQUE12.pdf). 23 | 24 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%201) para ver as soluções. 25 | ## 2ª Lista de EDA-2 2021/2- Ordenação Elementar 26 | A Lista 2 foi, basicamente, solucionar problemas de ordenação. Com 5 problemas de implementações de algoritmos de ordenação na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 27 | - A: [Ordenação por Bolha](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-ordena-elementar/ordenasimples-bolha.html); 28 | - B: [Ordenação por Seleção](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-ordena-elementar/ordenasimples-selecao.html); 29 | - C: [Ordenação por Inserção (simples)](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-ordena-elementar/ordenasimples-insercao.html); 30 | - D: [Ordenação por Inserção](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-ordena-elementar/ordenainsercao.html); 31 | - E: [Pesquisa Instruções](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-ordena-elementar/pesquisa-instrucoes.html). 32 | 33 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%202) para ver as soluções. 34 | ## 3ª Lista de EDA-2 2021/2- Mergesort 35 | A Lista 3 foi, basicamente, solucionar problemas de ordenação utilzando o mergesort . Com 7 problemas de implementações do mergesort na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 36 | - A: [Intercala8](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/intercala8.html); 37 | - B: [Implemente o MergeSort](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/ordenaelaborado.html); 38 | - C: [Implemente o MergeSort 2](https://www.spoj.com/problems/MERGSORT.pdf); 39 | - D: [Busca Binaria](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/busca-binaria-1.html); 40 | - E: [Busca Binaria](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/busca-binaria-2.html); 41 | - F: [Número Proibido](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/proibido.html); 42 | - G: [Remoção](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-mergesort/remocao.html). 43 | 44 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%203) para ver as soluções. 45 | 46 | ## 4ª Lista de EDA-2 2021/2- QuickSort 47 | A Lista 4 foi, basicamente, solucionar problemas de ordenação utilzando o quicksort . Com 7 problemas de implementações do quicksort na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 48 | - A: [Números Malucos Únicos Reinseridos](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/nmur.html); 49 | - B: [Implemente o QuickSort](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/ordenaelaborado.html); 50 | - C: [Sanidade](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/sanidade.html); 51 | - D: [O fantástico Jáspion](https://br.spoj.com/problems/JASPION.pdf); 52 | - E: [Eleição U.R.S.A.L](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/eleicao-ursal.html); 53 | - F: [Classificados de Sementes](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/classificado-agronomia.html); 54 | - G: [kk-página](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-quicksort/kk-pagina.html). 55 | 56 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%204) para ver as soluções. 57 | 58 | ## PROVA 1 de EDA-2 2021/2 59 | A prova 1 foi, basicamente, solucionar problemas utilizando os algoritmos de ordenação ou tabela hash . Com 3 problemas de implementações na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 60 | - 10pontos: [Número Proibido](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-prova-1/proibido.html); 61 | - 15pontos: [kk-página](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-prova-1/kk-pagina.html); 62 | - 75pontos: [Analisando Dados de Degustação](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-prova-1/sequencia-desgustacao.html). 63 | 64 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Prova%201) para ver as soluções. 65 | 66 | ## 5ª Lista de EDA-2 2021/2- Hashing 67 | A Lista 5 foi, basicamente, solucionar problemas de contagem utilizando tabela hash . Com 5 problemas de implementações de tabela hash na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 68 | - A: [Desfile dos Patos](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/desfile.html); 69 | - B: [Diga-me a frequência](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/digafrequencia.html); 70 | - C: [Eleição U.R.S.A.L](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/eleicao-ursal-big.html); 71 | - D: [Eleição U.R.S.A.L - BIG](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/eleicao-ursal-big.html); 72 | - E: [Notas Curiosas](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/notas.html); 73 | - F: [Notas](https://br.spoj.com/problems/NOTAS14.pdf); 74 | - G: [HashIT](https://www.spoj.com/problems/HASHIT.pdf); 75 | - H: [Hash](https://br.spoj.com/problems/HASHADIQ.pdf); 76 | - I: [Mensagens Nlogoniences](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-hash/mensagens.html). 77 | 78 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%205) para ver as soluções. 79 | 80 | ## 6ª Lista de EDA-2 2021/2- Priority Queue 81 | A Lista 5 foi, basicamente, solucionar problemas utilizando filas de prioridade . Com 2 problemas de implementações de Priority Queue na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 82 | - A:[Menores Placas](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-pq/menores-placas.html); 83 | - B:[Churrascarias da Avenida](https://br.spoj.com/problems/CHURRASC.pdf). 84 | 85 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%206) para ver as soluções. 86 | 87 | ## 7ª Lista de EDA-2 2021/2- Grafos 88 | A Lista 5 foi, basicamente, solucionar problemas utilizando Grafos . Com 7 problemas de implementações de Grafos na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 89 | - A: [Eu vou estar lá!](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-grafos/euvouestarla.html); 90 | - B: [Estradas asfaltadas](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-grafos/grafo-nucleos-cidades.html); 91 | - C: [Estradas asfaltadas - viagem aérea](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-grafos/grafo-ajude-joao.html); 92 | - D: [Estradas asfaltadas - perguntando conexões](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-grafos/grafo-nlogonia-conexoes.html); 93 | - E: [Cai fora LAG](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-grafos/grafo-chp.html); 94 | - F: [Natureza](https://br.spoj.com/problems/NATUREZA.pdf); 95 | - G: [Ir e Vir](https://br.spoj.com/problems/IREVIR.pdf). 96 | 97 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Lista%207) para ver as soluções. 98 | 99 | ## TRABALHO de EDA-2 2021/2 100 | O trablho foi, basicamente, solucionar problemas utilizando Grafos e Tabela Hash. Com 3 problemas de implementações na linguagem C. Os problemas serão listados a seguir e há links associados a eles. 101 | - 20pontos: [Aeroporto](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-trabalho/aeroporto.html); 102 | - 35pontos: [Transmissão de energia](https://br.spoj.com/problems/ENERGIA.pdf); 103 | - 45pontos: [Caminho das Pontes](https://moj.naquadah.com.br/contests/bcr-EDA2-2021_2-trabalho/pontes.html). 104 | 105 | Clique [aqui](https://github.com/lramon2001/EDA2_FGA_UnB/tree/main/Trabalho) para ver as soluções. 106 | -------------------------------------------------------------------------------- /Trabalho/A.c: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /Trabalho/Aeroporto_4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct consulta 5 | { 6 | int *vetor; 7 | int maximo; 8 | int tamanho; 9 | } Consulta; 10 | 11 | Consulta *inicia_consulta (int tamanho) 12 | { 13 | 14 | Consulta *consulta; 15 | consulta = (Consulta*) malloc(sizeof(Consulta)); 16 | consulta->maximo = 0; 17 | consulta->tamanho = tamanho; 18 | consulta->vetor = (int*) calloc(tamanho,sizeof(int)); 19 | 20 | return consulta; 21 | } 22 | 23 | void adiciona_consulta(Consulta *consulta,int viagem) 24 | { 25 | consulta->vetor[viagem]++; 26 | if(consulta->vetor[viagem]>consulta->maximo) 27 | { 28 | consulta->maximo = consulta->vetor[viagem]; 29 | } 30 | } 31 | 32 | void imprime(Consulta *consulta, int maximo) 33 | { 34 | for(int i=0;itamanho;i++) 35 | { 36 | if(consulta->vetor[i] == maximo) 37 | { 38 | printf("%d ",i); 39 | } 40 | } 41 | printf("\n"); 42 | } 43 | 44 | 45 | int main() 46 | { 47 | Consulta *consulta; 48 | 49 | 50 | int A,V,X,Y,teste=1; 51 | 52 | do 53 | { 54 | 55 | //Lendo o numero de aeroportos 56 | scanf("%d",&A); 57 | //Lendo o numero de voos 58 | scanf("%d",&V); 59 | consulta = inicia_consulta(A+1); 60 | 61 | if(A==0 && V==0) 62 | { 63 | break; 64 | } 65 | printf("Teste %d\n",teste); 66 | 67 | 68 | for(int i=0;imaximo); 81 | printf("\n"); 82 | 83 | } 84 | while(1); 85 | 86 | } -------------------------------------------------------------------------------- /Trabalho/Transmissão de energia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct grafo 5 | { 6 | int numero_de_vertices; 7 | int eh_ponderado; 8 | int grau_maximo; 9 | int **arestas; 10 | float **pesos; 11 | int *grau; 12 | }Grafo; 13 | 14 | Grafo *inicia_grafo(int numero_de_vertices, int eh_ponderado, int grau_maximo) 15 | { 16 | Grafo *grafo = (Grafo*) malloc (sizeof(Grafo)); 17 | if(grafo!=NULL) 18 | { 19 | int i; 20 | grafo->numero_de_vertices = numero_de_vertices; 21 | grafo->eh_ponderado = (eh_ponderado!=0)?1:0; 22 | grafo->grau_maximo = grau_maximo; 23 | grafo-> grau = (int*)calloc(numero_de_vertices,sizeof(int)); 24 | grafo->arestas = (int**)malloc(numero_de_vertices*sizeof(int*)); 25 | for( i=0; iarestas[i] =(int*) malloc(grau_maximo*sizeof(int)); 28 | } 29 | if(eh_ponderado) 30 | { 31 | grafo->pesos = (float**) malloc(numero_de_vertices*sizeof(int)); 32 | for(i=0;ipesos[i] = (float*)malloc(numero_de_vertices*sizeof(float*)); 35 | } 36 | } 37 | } 38 | return grafo; 39 | } 40 | 41 | void adiciona_aresta(Grafo *grafo,int origem,int destino, int peso,int eh_digrafo) 42 | { 43 | if(grafo == NULL) 44 | { 45 | return; 46 | } 47 | 48 | if(origem<0 || origem>= grafo->numero_de_vertices) 49 | { 50 | return; 51 | } 52 | 53 | if(destino<0 || destino>= grafo->numero_de_vertices) 54 | { 55 | return; 56 | } 57 | grafo->arestas[origem][grafo->grau[origem]] = destino; 58 | 59 | if(grafo->eh_ponderado) 60 | { 61 | grafo->pesos[origem][grafo->grau[origem]]=peso; 62 | } 63 | grafo->grau[origem]++; 64 | if(!eh_digrafo) 65 | { 66 | adiciona_aresta(grafo,destino,origem,0,1); 67 | } 68 | } 69 | 70 | void remove_aresta(Grafo *grafo, int origem,int destino, int eh_digrafo) 71 | { 72 | if(grafo == NULL) 73 | { 74 | return; 75 | } 76 | 77 | if(origem<0 || origem>= grafo->numero_de_vertices) 78 | { 79 | return; 80 | } 81 | 82 | if(destino<0 || destino>= grafo->numero_de_vertices) 83 | { 84 | return; 85 | } 86 | 87 | int i=0; 88 | 89 | while(inumero_de_vertices && grafo->arestas[origem][i]!=destino) 90 | { 91 | i++; 92 | } 93 | if(i== grafo->grau[origem]) 94 | { 95 | return; 96 | } 97 | grafo->grau[origem]--; 98 | 99 | grafo->arestas[origem][i] = grafo->arestas[origem][grafo->grau[origem]]; 100 | 101 | if(grafo->eh_ponderado) 102 | { 103 | grafo->pesos[origem][i] = grafo->arestas[origem][grafo->grau[origem]]; 104 | } 105 | 106 | if(!eh_digrafo) 107 | { 108 | remove_aresta(grafo,destino,origem,1); 109 | } 110 | } 111 | void busca_em_profundidade(Grafo *grafo,int inicial, int *visitados, int contador) 112 | { 113 | int i; 114 | visitados[inicial] = contador; 115 | 116 | for(i =0; igrau[inicial]; i++) 117 | { 118 | if(!visitados[grafo->arestas[inicial][i]]) 119 | { 120 | busca_em_profundidade(grafo,grafo->arestas[inicial][i],visitados,contador+1); 121 | } 122 | } 123 | 124 | } 125 | int conta_ilhas(Grafo *grafo,int *visitados) 126 | { 127 | int contador=0; 128 | int i; 129 | int count=1; 130 | for(int j=0; jnumero_de_vertices;j++){ 131 | visitados[j]=0; 132 | } 133 | 134 | 135 | for(i=0;inumero_de_vertices;i++) 136 | { 137 | if(visitados[i]==0) 138 | { 139 | busca_em_profundidade(grafo,i,visitados,count); 140 | contador++; 141 | } 142 | } 143 | 144 | return contador; 145 | 146 | } 147 | 148 | int main(){ 149 | int E, L; 150 | int e1,e2; 151 | int cont =0; 152 | int ilhas=0; 153 | scanf("%d %d", &E, &L); 154 | 155 | while(E!= 0 && L!= 0){ 156 | cont++; 157 | int vetor[E]; 158 | Grafo *grafo= inicia_grafo(E,0,L); 159 | for(int i=0; i1){ 167 | printf("falha\n"); 168 | }else{ 169 | printf("normal\n"); 170 | } 171 | printf("\n"); 172 | scanf("%d %d", &E, &L); 173 | } 174 | 175 | 176 | 177 | return 0; 178 | } 179 | -------------------------------------------------------------------------------- /Trabalho/caminho_das_pontes2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct grafo 5 | { 6 | int numero_de_vertices; 7 | int eh_ponderado; 8 | int grau_maximo; 9 | int **arestas; 10 | int **pesos; 11 | int *grau; 12 | }Grafo; 13 | 14 | Grafo *inicia_grafo(int numero_de_vertices, int eh_ponderado, int grau_maximo) 15 | { 16 | Grafo *grafo = (Grafo*) malloc (sizeof(Grafo)); 17 | if(grafo!=NULL) 18 | { 19 | int i; 20 | grafo->numero_de_vertices = numero_de_vertices; 21 | grafo->eh_ponderado = (eh_ponderado!=0)?1:0; 22 | grafo->grau_maximo = grau_maximo; 23 | grafo-> grau = (int*)calloc(numero_de_vertices,sizeof(int)); 24 | grafo->arestas = (int**)malloc(numero_de_vertices*sizeof(int*)); 25 | for( i=0; iarestas[i] =(int*) malloc(grau_maximo*sizeof(int)); 28 | } 29 | 30 | if(eh_ponderado) 31 | { 32 | grafo->pesos = (int**) malloc(numero_de_vertices*sizeof(int*)); 33 | for(i=0;ipesos[i] = (int*)malloc(numero_de_vertices*sizeof(int*)); 36 | } 37 | } 38 | } 39 | return grafo; 40 | } 41 | 42 | void adiciona_aresta(Grafo *grafo,int origem,int destino, int peso,int eh_digrafo) 43 | { 44 | if(grafo == NULL) 45 | { 46 | return; 47 | } 48 | 49 | if(origem<0 || origem>= grafo->numero_de_vertices) 50 | { 51 | return; 52 | } 53 | 54 | if(destino<0 || destino>= grafo->numero_de_vertices) 55 | { 56 | return; 57 | } 58 | grafo->arestas[origem][grafo->grau[origem]] = destino; 59 | 60 | 61 | grafo->pesos[origem][grafo->grau[origem]]=peso; 62 | 63 | grafo->grau[origem]++; 64 | if(!eh_digrafo) 65 | { 66 | adiciona_aresta(grafo,destino,origem,peso,1); 67 | } 68 | } 69 | 70 | void imprime_grafo(Grafo *grafo) 71 | { 72 | for(int i=0;inumero_de_vertices;i++) 73 | { 74 | printf("[%d]: ",i); 75 | for(int j=0;jgrau[i];j++) 76 | { 77 | printf("[%d: %d]-> ",grafo->arestas[i][j],grafo->pesos[i][j]); 78 | 79 | } 80 | printf("\n"); 81 | 82 | } 83 | } 84 | 85 | int procura_menor_distancia(int *distancia,int *visitado,int numero_de_vertices) 86 | { 87 | int menor =-1; 88 | int primeiro =1; 89 | 90 | for(int i=0; i< numero_de_vertices;i++) 91 | { 92 | if(distancia[i]>=0 && visitado[i] == 0) 93 | { 94 | if(primeiro) 95 | { 96 | menor = i; 97 | primeiro =0; 98 | } 99 | else 100 | { 101 | if(distancia[menor] > distancia[i]) 102 | { 103 | menor =i; 104 | } 105 | } 106 | } 107 | } 108 | return menor; 109 | } 110 | 111 | void menor_caminho_grafo(Grafo*grafo, int inicial, int *anterior, int *distancia) 112 | { 113 | int i, contador, numero_de_vertices, indice, *visitado,u; 114 | contador= numero_de_vertices = grafo->numero_de_vertices; 115 | visitado = (int*) malloc(numero_de_vertices*sizeof(int)); 116 | for(int i=0;i< numero_de_vertices; i++) 117 | { 118 | anterior[i] = -1; 119 | distancia[i] = -1; 120 | visitado[i] = 0; 121 | } 122 | 123 | distancia[inicial] = 0; 124 | 125 | while(contador>0) 126 | { 127 | u = procura_menor_distancia(distancia, visitado,numero_de_vertices); 128 | if(u == -1) 129 | { 130 | break; 131 | } 132 | visitado[u] = 1; 133 | contador--; 134 | for(int i=0; igrau[u];i++) 135 | { 136 | indice = grafo->arestas[u][i]; 137 | if(distancia[indice]<0) 138 | { 139 | distancia[indice] = distancia[u] + grafo->pesos[u][i]; 140 | anterior[indice] = u; 141 | } 142 | else 143 | { 144 | if(distancia[indice] > distancia[u] +grafo->pesos[u][i]) 145 | { 146 | distancia[indice] = distancia[u] +grafo->pesos[u][i]; 147 | 148 | anterior[indice] =u; 149 | 150 | } 151 | } 152 | } 153 | } 154 | free(visitado); 155 | 156 | } 157 | void imprime_matriz_de_pesos(Grafo *grafo) 158 | { 159 | 160 | for(int i=0;inumero_de_vertices;i++) 161 | { 162 | 163 | for(int j=0;jnumero_de_vertices;j++) 164 | { 165 | printf(" %d ",grafo->pesos[i][j]); 166 | 167 | } 168 | printf("\n"); 169 | 170 | } 171 | } 172 | 173 | int main() 174 | { 175 | int N,M,S,T,B; 176 | scanf("%d %d",&N,&M); 177 | 178 | 179 | Grafo *grafo = inicia_grafo(N+2,1,N+2); 180 | 181 | for(int i=0;inumero_de_vertices * sizeof(int)); 187 | int *anterior = malloc(grafo->numero_de_vertices * sizeof(int)); 188 | int *visitado = malloc(grafo->numero_de_vertices * sizeof(int)); 189 | menor_caminho_grafo(grafo,0,anterior,distancia); 190 | 191 | 192 | printf("%d\n",distancia[grafo->numero_de_vertices-1]); 193 | 194 | 195 | 196 | 197 | } --------------------------------------------------------------------------------