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 =  + ;
 struct Edge
 {
     int to, flow, Next;
 };
 struct Dinic
 {
     int n, s, t, now;
     Edge edges[Max * ];
     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, -, sizeof(head));
         now = ;
     }
     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, , sizeof(vis));
         int Front =, rear = ;
         q[rear++] = s;
         d[s] = ;
         vis[s] = ;
         while (Front < rear)
         {
             int x = q[Front++];
             for (int i = head[x]; i != -; i = edges[i].Next)
             {
                 if ( vis[edges[i].to] ==  && edges[i].flow > )
                 {
                     vis[edges[i].to] = ;
                     d[ edges[i].to ] = d[x] + ;
                     q[ rear++ ] = edges[i].to;
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a)
     {
         if (x == t || a == )
             return a;
         int flow = , f;
         for (int i = head[x]; i != -; i = edges[i].Next)
         {
             if (d[x] +  == d[edges[i].to] && edges[i].flow > )
             {
                 f = DFS(edges[i].to, min(a - flow, edges[i].flow));
                 edges[i].flow -= f;
                 edges[i ^ ].flow += f;
                 flow += f;
                 if (flow == a)
                     return flow;
             }
         }
         if (flow == )
             d[x] = ;
         return flow;
     }
     int MaxFlow()
     {
         int flow = ;
         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 = ; 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 = ; i <= m; i++)
         {
             scanf("%d%d%d", &x, &y, &w);
             g.addEdge(x, y, w);
         }
         printf("%d\n", g.MaxFlow());
     }
     return ;
 }