HDU 4280Island Transport（Dinc非STL 模板）

题意： n岛m条路，然后是 n个岛的坐标，然后是m条双向路，包括 岛和 岛 之间 最大客流量，让求 最左边的岛 到右边的岛 最大客流量

分析： 建图 以 左边的岛为原点，最右边的为终点求最大客流量。

刘汝佳STL会超时，因为vector牵扯到 复制操作

然后看大神的将stl全换了 http://www.cnblogs.com/xiao-xin/articles/4452306.html

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int Max = 100000 + 10;
struct Edge
{
    int to, flow, Next;
};
struct Dinic
{
    int n, s, t, now;
    Edge edges[Max * 2];
    bool vis[Max];
    int d[Max], head[Max], q[Max];
    void init(int _s, int _t, int _n)
    {
        s = _s; t = _t; n = _n;
        memset(head, -1, sizeof(head));
        now = 0;
    }
    void addEdge(int from, int to, int flow)
    {
        edges[now].to = to; edges[now].flow = flow;
        edges[now].Next = head[from]; head[from] = now++;

        edges[now].to = from; edges[now].flow = flow;
        edges[now].Next = head[to]; head[to] = now++;
    }
    bool BFS()
    {
        memset(vis, 0, sizeof(vis));
        int Front =0, rear = 0;
        q[rear++] = s;
        d[s] = 0;
        vis[s] = 1;
        while (Front < rear)
        {
            int x = q[Front++];
            for (int i = head[x]; i != -1; i = edges[i].Next)
            {
                if ( vis[edges[i].to] == 0 && edges[i].flow > 0)
                {
                    vis[edges[i].to] = 1;
                    d[ edges[i].to ] = d[x] + 1;
                    q[ rear++ ] = edges[i].to;
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a)
    {
        if (x == t || a == 0)
            return a;
        int flow = 0, f;
        for (int i = head[x]; i != -1; i = edges[i].Next)
        {
            if (d[x] + 1 == d[edges[i].to] && edges[i].flow > 0)
            {
                f = DFS(edges[i].to, min(a - flow, edges[i].flow));
                edges[i].flow -= f;
                edges[i ^ 1].flow += f;
                flow += f;
                if (flow == a)
                    return flow;
            }
        }
        if (flow == 0)
            d[x] = 0;
        return flow;
    }
    int MaxFlow()
    {
        int flow = 0;
        while ( BFS() )
        {
            flow += DFS(s, INF);
        }
        return flow;
    }

}g;
/*
struct Dinic
{
    int n, s, t;
    vector<Edge> edges;
    vector<int> G[Max];
    bool vis[Max];
    int d[Max];
    int cur[Max];
    void init(int _n, int _s, int _t)
    {
        n = _n;
        s = _s;
        t = _t;
        edges.clear();
        for (int i = 0; i <= n; i++)
            G[i].clear();
    }
    void addEdge(int from, int to, int cap)
    {
        Edge edge;
        edge.from = from;
        edge.to = to;
        edge.cap = cap;
        edge.flow = 0;
        edges.push_back(edge);
        edge.from = to;
        edge.to = from;
        edge.cap = cap;
        edge.flow = 0;
        edges.push_back(edge);
        int m = (int) edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }
    bool BFS()
    {
        memset(vis, 0, sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for (int i = 0; i < (int) G[x].size(); i++)
            {
                Edge & e = edges[ G[x][i] ];
                if (!vis[e.to] && e.cap > e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a)
    {
        if (x == t || a == 0)
            return a;
        int flow = 0, f;
        for (int& i = cur[x]; i < (int)G[x].size(); i++)
        {
            Edge & e = edges[ G[x][i] ];
            if (d[x] + 1 == d[e.to] && (f = DFS(e.to,  min(a, e.cap - e.flow))) > 0)
            {
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (a == 0)
                    break;
            }
        }
        return flow;
    }
    int MaxFlow()
    {
        int flow = 0;
        while( BFS() )
        {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }


}g;
*/
int main()
{
    int T, n, m, east, west;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &n, &m);
        int maxx = -INF, minx = INF;
        int x, y, w;
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d", &x, &y);
            if (x > maxx)
            {
                maxx = x;
                west = i;
            }
            if (x < minx)
            {
                minx = x;
                east = i;
            }
        }
        g.init(east, west, n);
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &x, &y, &w);
            g.addEdge(x, y, w);
        }
        printf("%d
", g.MaxFlow());
    }
    return 0;
}