用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 //最大流水量使用网络流算法

这个问题可以使用网络流算法来解决，具体来说，可以使用Ford-Fulkerson算法或者Edmonds-Karp算法，这里我们使用Edmonds-Karp算法。

首先，我们需要建立一个邻接矩阵来表示池塘和水渠之间的连接关系以及流量限制，初始化所有的边的流量为0。然后，我们使用BFS来找到从源点到汇点的一条增广路径，也就是一条路径上所有边的流量都能被增加。如果存在增广路径，我们就沿着这条路径增加流量，并更新所有边的剩余容量。我们重复这个过程，直到不存在增广路径为止。最后，我们可以计算出池塘1到池塘m的最大流量，即为所求答案。

下面是使用C语言实现的代码：

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

#define MAX_M 100
#define MAX_N 1000

int n, m;
int capacity[MAX_M][MAX_M]; // 储存边的容量
int flow[MAX_M][MAX_M]; // 储存边的流量
int parent[MAX_M]; // 储存增广路径
bool visited[MAX_M]; // 标记是否已经访问过

// 使用BFS寻找增广路径
bool bfs(int s, int t) {
    memset(visited, false, sizeof(visited));
    memset(parent, -1, sizeof(parent));
    visited[s] = true;
    int queue[MAX_M];
    int front = 0, rear = 0;
    queue[rear++] = s;
    while (front < rear) {
        int u = queue[front++];
        for (int v = 1; v <= m; v++) {
            if (!visited[v] && capacity[u][v] > flow[u][v]) {
                visited[v] = true;
                parent[v] = u;
                queue[rear++] = v;
                if (v == t) {
                    return true;
                }
            }
        }
    }
    return false;
}

// 计算最大流量
int max_flow(int s, int t) {
    int total_flow = 0;
    while (bfs(s, t)) {
        int path_flow = INT_MAX;
        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            path_flow = path_flow < capacity[u][v] - flow[u][v] ? path_flow : capacity[u][v] - flow[u][v];
        }
        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            flow[u][v] += path_flow;
            flow[v][u] -= path_flow;
        }
        total_flow += path_flow;
    }
    return total_flow;
}

int main() {
    scanf("%d%d", &m, &n);
    memset(capacity, 0, sizeof(capacity));
    memset(flow, 0, sizeof(flow));
    for (int i = 0; i < n; i++) {
        int u, v, c;
        scanf("%d%d%d", &u, &v, &c);
        capacity[u][v] += c;
    }
    printf("%d\n", max_flow(1, m));
    return 0;
}

注意，这个算法的时间复杂度是O(nm^2)，其中n为边的数量，m为顶点的数量。在实际应用中，为了加快速度，可以使用更高效的算法，如Dinic算法或者Push-Relabel算法。