Thuyền trưởng haddock

Thuyền trưởng Haddock

#include
>

#define MAX 100

#define WHITE 0
#define GRAY 1
#define BLACK 2

typedef struct {
int u, v;

}Edge;

typedef struct {
int n, m;
Edge edges[MAX];

}Graph;

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;

}

void add_edge(Graph* pG, int u, int v) {
pG->edges[pG->m].u = u;

pG->edges[pG->m].v = v;
pG->m++;

}

int adjacent(Graph* pG, int u, int v) {
for (int e = 0; e < pG->m; e++)
if ((pG->edges[e].u == u && pG->edges[e].v

== v)) return 1;

return 0;
}

int color[MAX];
int has_circle;

void DFS(Graph* pG, int s, int p) {
color[s] = GRAY;

for (int v = 1; v <= pG->n; v++)
if (adjacent(pG, s, v)) {
if (color[v] == WHITE)
DFS(pG, v, s);
else if (color[v] == GRAY) {
has_circle = 1;
}
}

color[s] = BLACK;

}

int main() {
int n, m;
scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 1; e <= m; e++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(&G, u, v);
}

for (int u = 1; u <= n; u++) {
color[u] = WHITE;

}

has_circle = 0;
for (int u = 1; u <= n; u++) {

if (color[u] == WHITE) {
DFS(&G, u, -1);

}
}
if (has_circle == 1) printf("NO");
else printf("YES");
return 0;
}

#Kiểm tra chu trình_đồ thị vơ hướng

#include
>

#define MAX 100

#define WHITE 0
#define GRAY 1
#define BLACK 2

typedef struct {
int u, v;

}Edge;

typedef struct {
int n, m;
Edge edges[MAX];

}Graph;

void init_graph(Graph* pG, int n) {

pG->n = n;
pG->m = 0;
}

void add_edge(Graph* pG, int u, int v) {
pG->edges[pG->m].u = u;
pG->edges[pG->m].v = v;
pG->m++;

}

int adjacent(Graph* pG, int u, int v) {
for (int e = 0; e < pG->m; e++)
if ((pG->edges[e].u == u && pG->edges[e].v == v)
|| (pG->edges[e].u == v && pG->edges[e].v

== u))
return 1;

return 0;
}

int parent[MAX];
int color[MAX];
int has_circle;

void DFS(Graph* pG, int s, int p) {
color[s] = GRAY;
parent[s] = p;

for (int v = 1; v <= pG->n; v++)
if (adjacent(pG, s, v)) {
if (v == p) continue;
if (color[v] == WHITE)

DFS(pG, v, s);
else if (color[v] == GRAY) {
has_circle = 1;
}
}

color[s] = BLACK;
}

int main() {
int n, m;
scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 1; e <= m; e++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(&G, u, v);
}

for (int u = 1; u <= n; u++) {
color[u] = WHITE;
parent[u] = -1;

}

has_circle = 0;
for (int u = 1; u <= n; u++) {

if (color[u] == WHITE) {

DFS(&G, u, -1);

}
}
if (has_circle == 1) printf("YES");
else printf("NO");
return 0;
}

# duyệt đồ thị _dựng cây duyệt đồ thị
1. Cho một đồ thị vô hướng đơn. Hãy dựng (các) cây DUYỆT ĐỒ THỊ khi duyệt
đồ thị theo chiều rộng bắt đầu từ đỉnh 1.
Nếu vẫn còn đỉnh chưa duyệt sau khi duyệt xong lần 1, tìm đỉnh có chỉ số nhỏ
nhất chưa duyệt mà duyệt nó, và cứ tiếp tục như thế cho đến khi tất cả các đỉnh
đều được duyệt.

#include <stdio.h>

#define MAX 100

typedef struct {
int u, p;

}elementype;

typedef struct {
int u, v;

}Edge;

typedef struct {
int n, m;
Edge edges[MAX];

}Graph;

typedef struct {
elementype data[MAX];
int front, rear;

}queue;

void make_null_queue(queue* pQ) {
pQ->front = 0;
pQ->rear = -1;

}

void enqueue(queue* pQ, elementype u) {
pQ->rear++;
pQ->data[pQ->rear] = u;

}

void dequeue(queue* pQ) {
pQ->front++;

}

elementype front(queue Q) {

return Q.data[Q.front];

}

int empty(queue Q) {
return Q.front > Q.rear;

}

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;

}

void add_edge(Graph* pG, int u, int v) {
pG->edges[pG->m].u = u;
pG->edges[pG->m].v = v;
pG->m++;

}

int adjacent(Graph* pG, int u, int v) {
for (int e = 0; e < pG->m; e++)
if ((pG->edges[e].u == u && pG->edges[e].v == v)
|| (pG->edges[e].u == v && pG->edges[e].v == u))
return 1;

return 0;
}

int mark[MAX];
int parent[MAX];

void BFS(Graph* pG, int s) {
queue Q;
make_null_queue(&Q);
elementype pair;
pair.u = s; pair.p = -1;
enqueue(&Q, pair);
while (!empty(Q)) {
elementype pair = front(Q); dequeue(&Q);
int u = pair.u, p = pair.p;
if (mark[u] != 0)
continue;

mark[u] = 1;
parent[u] = p;

for (int v = 1; v <= pG->n; v++)
if (adjacent(pG, u, v)) {
elementype pair = { v, u };
enqueue(&Q, pair);
}

}
}

int main() {
int n, m;

scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 1; e <= m; e++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(&G, u, v);
}
for (int u = 1; u <= n; u++) {
mark[u] = 0;
parent[u] = -1;
}

for (int u = 1; u <= n; u++)
if (mark[u] == 0)
BFS(&G, u);

for (int u = 1; u <= n; u++)
printf("%d %d\n", u, parent[u]);

return 0;
}

# Cho một đồ thị vô hướng đơn. Hãy dựng (các) cây DUYỆT ĐỒ THỊ khi duyệt đồ
thị theo chiều sâu (dùng NGĂN XẾP) bắt đầu từ đỉnh 1.
Nếu đồ thị không liên thông, sau khi duyệt xong lần 1, tìm đỉnh có chỉ số nhỏ
nhất chưa duyệt mà duyệt nó, và cứ tiếp tục như thế cho đến khi tất cả các đỉnh
đều được duyệt.

#include

>

#define MAX 100

typedef struct {
int u, v;

}Edge;

typedef struct {
int n, m;
Edge edges[MAX];

}Graph;

typedef struct {
int u, p;

}elementtype;

typedef struct {
elementtype data[MAX];
int top_id;

}stack;

void make_null_stack(stack* pS) {
pS->top_id = -1;

}

void push_back(stack* pS, elementtype x) {
pS->top_id++;
pS->data[pS->top_id] = x;

}

void pop_back(stack* pS) {
pS->top_id--;

}

elementtype back(stack S) {
return S.data[S.top_id];

}

int empty(stack S) {
return S.top_id == -1;

}

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;

}

void add_edge(Graph* pG, int u, int v) {

pG->edges[pG->m].u = u;
pG->edges[pG->m].v = v;
pG->m++;

}

int adjacent(Graph* pG, int u, int v) {
for (int e = 0; e < pG->m; e++)
if ((pG->edges[e].u == u && pG->edges[e].v == v)
|| (pG->edges[e].u == v && pG->edges[e].v

== u))
return 1;

return 0;
}

int mark[MAX];
int parent[MAX];
void DFS(Graph* pG, int s) {

stack S;
make_null_stack(&S);
elementtype pair = { s, 0 };
push_back(&S, pair);

while (!empty(S)) {
elementtype pair = back(S);
pop_back(&S);

int u = pair.u, p = pair.p;

if (mark[u] != 0)
continue;

mark[u] = 1;
parent[u] = p;
for (int v = 1; v <= pG->n; v++)

if (adjacent(pG, u, v)) {
elementtype pair = { v, u };
push_back(&S, pair);

}
}
}

int main() {
int n, m;
scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 1; e <= m; e++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(&G, u, v);
}

for (int u = 1; u <= n; u++) {
mark[u] = 0;

parent[u] = 0;

}

for (int u = 1; u <= n; u++)
if (mark[u] == 0)
DFS(&G, u);

for (int u = 1; u <= n; u++)
printf("%d %d\n", u, parent[u]);

return 0;
}

3. Cho một đồ thị vô hướng đơn. Hãy dựng (các) cây DUYỆT ĐỒ THỊ khi duyệt
đồ thị theo chiều sâu (dùng ĐỆ QUY) bắt đầu từ đỉnh 1.
Nếu đồ thị không liên thơng, sau khi duyệt xong lần 1, tìm đỉnh có chỉ số nhỏ
nhất chưa duyệt mà duyệt nó, và cứ tiếp tục như thế cho đến khi tất cả các đỉnh
đều được duyệt.

#include
>

#define MAX 100

typedef struct {
int u, v;

}Edge;

typedef struct {
int n, m;
Edge edges[MAX];

}Graph;

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;

}

void add_edge(Graph* pG, int u, int v) {
pG->edges[pG->m].u = u;
pG->edges[pG->m].v = v;
pG->m++;

}

int adjacent(Graph* pG, int u, int v) {
for (int e = 0; e < pG->m; e++)
if ((pG->edges[e].u == u && pG->edges[e].v == v)
|| (pG->edges[e].u == v && pG->edges[e].v

== u))
return 1;

return 0;
}

int mark[MAX];
int parent[MAX];

void DFS(Graph* pG, int s, int p) {
mark[s] = 1;
parent[s] = p;
for (int v = 1; v <= pG->n; v++)
if (adjacent(pG, s, v) && mark[v] == 0) {
DFS(pG, v, s);
}

}

int main() {
int n, m;
scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 1; e <= m; e++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(&G, u, v);
}

for (int u = 1; u <= n; u++) {
mark[u] = 0;
parent[u] = 0;

}

for (int u = 1; u <= n; u++)
if (mark[u] == 0)
DFS(&G, u, 0);

for (int u = 1; u <= n; u++)
printf("%d %d\n", u, parent[u]);

return 0;
}

#đường đi ngắn nhất check đc.
#include <stdio.h>

#define NO_EDGE -1

typedef struct {
int n, m;
int W[100][100];

}Graph;

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;
for (int u = 1; u <= n; u++) {
for (int v = 1; v <= n; v++) {
pG->W[u][v] = NO_EDGE;
}
}

}

void add_edge(Graph* pG, int u, int v, int w) {
pG->W[u][v] = w;
pG->W[v][u] = w;
pG->m++;

}

#define oo 999999
int mark[100], p[100], pi[100];

void Dijkstra(Graph* pG, int s) {
for (int u = 1; u <= pG->n; u++) {
mark[u] = 0;
pi[u] = oo;
}
pi[s] = 0;
p[s] = -1;
int u;
for (int i = 1; i < pG->n; i++) {
int minpi = oo;
for (int v = 1; v <= pG->n; v++) {
if (!mark[v] && pi[v] < minpi) {
minpi = pi[v];
u = v;
}
}
mark[u] = 1;

for (int v = 1; v <= pG->n; v++) {
if (!mark[v] && pG->W[u][v] != NO_EDGE) {
if (pi[u] + pG->W[u][v] < pi[v]) {

pi[v] = pi[u] + pG->W[u][v];
p[v] = u;
}
}
}
}
}

int main() {
int n, m;
scanf("%d %d", &n, &m);
Graph G;
init_graph(&G, n);
for (int e = 0; e < m; e++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
add_edge(&G, u, v, w);
}
Dijkstra(&G, 1);
if (pi[n] < oo)
printf("%d", pi[n]);
else
printf("-1");
return 0;

}

#Mê cung số

#include

>

#define NO_EDGE -1

typedef struct {
int n, m;
int W[100][100];

}Graph;

void init_graph(Graph* pG, int n) {
pG->n = n;
pG->m = 0;
for (int u = 1; u <= n; u++) {
for (int v = 1; v <= n; v++) {
pG->W[u][v] = NO_EDGE;
}
}

}

void add_edge(Graph* pG, int u, int v, int w) {
pG->W[u][v] = w;
pG->m++;

}

#define oo 999999
int mark[100], p[100], pi[100];

void Dijkstra(Graph* pG, int s) {
for (int u = 1; u <= pG->n; u++) {
mark[u] = 0;
pi[u] = oo;
}
pi[s] = 0;
p[s] = -1;
int u;
for (int i = 1; i < pG->n; i++) {
int minpi = oo;

NO_EDGE) { for (int v = 1; v <= pG->n; v++) {
{ if (!mark[v] && pi[v] < minpi) {
[v]; minpi = pi[v];
u = v;
} }
}
}
mark[u] = 1;
for (int v = 1; v <= pG->n; v++) {

if (!mark[v] && pG->W[u][v] !=

if (pi[u] + pG->W[u][v] < pi[v])

pi[v] = pi[u] + pG->W[u]

p[v] = u;
}
}
}

int main() {
int n, m;
scanf("%d %d", &m, &n);
Graph G;
init_graph(&G, n * m);
for (int i = 1; i <= n * m; i++) {
int w;
scanf("%d", &w);
if (i > n) {
add_edge(&G, i - n, i, w);
if (i + n <= n * m)
add_edge(&G, i + n, i, w);
}
if ((i - 1) % n != 0)
add_edge(&G, i - 1, i, w);
if (i % n != 0)
add_edge(&G, i + 1, i, w);
}
Dijkstra(&G, 1);

printf("%d", pi[n*m]);