请用c语言实现，流水问题：现在有m个池塘(从1到m开始编号，1为源点，m为汇点)及n条水渠。假设已经给出这n条水渠所连接的池塘和所能流过的水量，设计算法求水渠中所能流过的水的最大容量。示例如下： 输入： 4 5 //池塘数m和水渠数n 1 2 40 //所连接的池塘和所能流过的水量 1 4 20 2 4 20 2 3 30 3 4 10 输出：50 //最大流水量

这是一个经典的最大流问题，可以使用网络流算法来解决。

以下是使用 Edmonds-Karp 算法求解最大流问题的 C 语言实现代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define MAXN 1005
#define INF INT_MAX

typedef struct {
    int to, cap, rev;
} Edge;

int n, m;
int s = 1, t;
int used[MAXN], level[MAXN];
Edge graph[MAXN][MAXN];
int edge_count[MAXN];

void add_edge(int from, int to, int cap) {
    graph[from][edge_count[from]] = (Edge){to, cap, edge_count[to]};
    graph[to][edge_count[to]] = (Edge){from, 0, edge_count[from]};
    edge_count[from]++;
    edge_count[to]++;
}

int bfs(int s, int t) {
    memset(level, -1, sizeof(level));
    level[s] = 0;
    int queue[MAXN], head = 0, tail = 0;
    queue[tail++] = s;
    while (head != tail) {
        int v = queue[head++];
        for (int i = 0; i < edge_count[v]; i++) {
            Edge *e = &graph[v][i];
            if (e->cap > 0 && level[e->to] < 0) {
                level[e->to] = level[v] + 1;
                queue[tail++] = e->to;
            }
        }
    }
    return level[t] >= 0;
}

int dfs(int v, int t, int f) {
    if (v == t) {
        return f;
    }
    for (int i = used[v]; i < edge_count[v]; i++) {
        used[v] = i;
        Edge *e = &graph[v][i];
        if (e->cap > 0 && level[v] < level[e->to]) {
            int d = dfs(e->to, t, fmin(f, e->cap));
            if (d > 0) {
                e->cap -= d;
                graph[e->to][e->rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t) {
    int flow = 0;
    while (bfs(s, t)) {
        memset(used, 0, sizeof(used));
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}

int main() {
    scanf("%d%d", &n, &m);
    t = n;
    for (int i = 0; i < m; i++) {
        int u, v, cap;
        scanf("%d%d%d", &u, &v, &cap);
        add_edge(u, v, cap);
    }
    printf("%d\n", max_flow(s, t));
    return 0;
}

代码中使用了邻接表存储图，每个结点维护一个边集，由于每条边在正向和反向都要保存，因此需要维护每个结点的出边数和入边数，即 `edge_count` 数组。

在 `add_edge` 函数中，每次添加一条边时，需要同时添加这条边的反向边，存储在对应的结点中，这样可以在 Edmonds-Karp 算法中进行反向搜索。

在 `bfs` 函数中，使用 BFS 搜索能够到达汇点的结点，并记录每个结点的距离，作为后面 DFS 搜索的参考。

在 `dfs` 函数中，使用 DFS 搜索增广路径，每次搜索到汇点时返回增广流量，更新边的容量，并在反向边中增加流量。

在 `max_flow` 函数中，不断进行 BFS 和 DFS 搜索，直到无法到达汇点为止，返回最大流量。

最后在 `main` 函数中读入数据，构建图，调用 `max_flow` 函数进行求解，并输出结果。