hdu 4280 Island Transport 【图论-网络流-ISAP+栈优化】

                                Island Transport
        Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Problem Description
　　In the vast waters far far away, there are many islands. People are living on the islands, and all the transport among the islands relies on the ships.
　　You have a transportation company there. Some routes are opened for passengers. Each route is a straight line connecting two different islands, and it is bidirectional. Within an hour, a route can transport a certain number of passengers in one direction. For safety, no two routes are cross or overlap and no routes will pass an island except the departing island and the arriving island. Each island can be treated as a point on the XY plane coordinate system. X coordinate increase from west to east, and Y coordinate increase from south to north.
　　The transport capacity is important to you. Suppose many passengers depart from the westernmost island and would like to arrive at the easternmost island, the maximum number of passengers arrive at the latter within every hour is the transport capacity. Please calculate it.

Input
　　The first line contains one integer T (1<=T<=20), the number of test cases.
　　Then T test cases follow. The first line of each test case contains two integers N and M (2<=N,M<=100000), the number of islands and the number of routes. Islands are number from 1 to N.
　　Then N lines follow. Each line contain two integers, the X and Y coordinate of an island. The K-th line in the N lines describes the island K. The absolute values of all the coordinates are no more than 100000.
　　Then M lines follow. Each line contains three integers I1, I2 (1<=I1,I2<=N) and C (1<=C<=10000) . It means there is a route connecting island I1 and island I2, and it can transport C passengers in one direction within an hour.
　　It is guaranteed that the routes obey the rules described above. There is only one island is westernmost and only one island is easternmost. No two islands would have the same coordinates. Each island can go to any other island by the routes.

Output
　　For each test case, output an integer in one line, the transport capacity.

Sample Input
2
5 7
3 3
3 0
3 1
0 0
4 5
1 3 3
2 3 4
2 4 3
1 5 6
4 5 3
1 4 4
3 4 2
6 7
-1 -1
0 1
0 2
1 0
1 1
2 3
1 2 1
2 3 6
4 5 5
5 6 3
1 4 6
2 5 5
3 6 4

Sample Output
9
6

题目大意： 有n个小岛，m条连接小岛的航路，先给出每条航路的最大载客量，现在游客从最西边的岛出发，到达最东边的岛，请你计算单位时间运输游客的最大量
输入：
第一行包含一个整数T（1 <= T <= 20），测试用例数。
　　然后T测试案例。每个测试用例的第一行包含两个整数N和M（2 <= N，M <= 100000），岛数和航路数。岛的编号为1到N，
　　然后N行。每行包含两个整数，分别表示一个岛的X和Y坐标。N行中的第K行描述岛K.所有坐标的绝对值不大于100000.
　　接着是M行。每行包含三个整数I1，I2（1 <= I1，I2 <= N）和C（1 <= C <= 10000）。这意味着岛I1和岛I2之间有一条航路，并且该航路的载客量为C。
　　保证输入数据符合上述规则。并且最西边只有一个岛，最东边也只有一个岛。没有任何两个岛屿具有相同的坐标。每个岛屿都可以通过路线去其他任何岛屿。

输出
　　对于每个测试用例，输出一行中的整数，即传输容量。

AC代码：

//kuangbin的模板
//ISAP + BFS初始化+栈优化  AC
# include <iostream>
# include <cstring>
# include <algorithm>

using namespace std;

# define MAXN 100050
# define INF 1e9 + 100

struct EDGE
{
    int to;
    int cap;
    int flow;
    int next;
}edge[MAXN * 10];

int tot;
int head[MAXN];
int gap[MAXN];
int dep[MAXN];
int pre[MAXN];
int cur[MAXN];

void Init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
}

void Addedge(int u, int v, int w, int rw = 0)
{
    edge[tot].to = v;
    edge[tot].cap = w;
    edge[tot].flow = 0;
    edge[tot].next = head[u];
    head[u] = tot++;

    edge[tot].to = u;
    edge[tot].cap = rw;
    edge[tot].flow = 0;
    edge[tot].next = head[v];
    head[v] = tot++;
}

int Q[MAXN];
void BFS(int start,int end)
{
    memset(dep,-1,sizeof(dep));
    memset(gap,0,sizeof(gap));
    gap[0] = 1;
    int front = 0, rear = 0;
    dep[end] = 0;
    Q[rear++] = end;
    while(front != rear)
    {
        int u = Q[front++];
        for(int i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].to;
            if(dep[v] != -1)continue;
            Q[rear++] = v;
            dep[v] = dep[u] + 1;
            gap[dep[v]]++;
        }
    }
}
int S[MAXN];
int Sap(int start,int end,int N)
{
    BFS(start,end);
    memcpy(cur,head,sizeof(head));
    int top = 0;
    int u = start;
    int ans = 0;
    int i;
    while(dep[start] < N)
    {
        if(u == end)
        {
            int Min = INF;
            int inser;
            for(i = 0;i < top;i++)
                if(Min > edge[S[i]].cap - edge[S[i]].flow)
                {
                    Min = edge[S[i]].cap - edge[S[i]].flow;
                    inser = i;
                }
                for(i = 0;i < top;i++)
                {
                    edge[S[i]].flow += Min;
                    edge[S[i]^1].flow -= Min;
                }
                ans += Min;
                top = inser;
                u = edge[S[top]^1].to;
                continue;
        }
        bool flag = false;
        int v;
        for(i = cur[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u])
            {
                flag = true;
                cur[u] = i;
                break;
            }
        }
        if(flag)
        {
            S[top++] = cur[u];
            u = v;
            continue;
        }
        int Min = N;
        for(i = head[u]; i != -1; i = edge[i].next)
            if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
            {
                Min = dep[edge[i].to];
                cur[u] = i;
            }
            gap[dep[u]]--;
            if(!gap[dep[u]])return ans;
            dep[u] = Min + 1;
            gap[dep[u]]++;
            if(u != start)u = edge[S[--top]^1].to;
    }
    return ans;

}
int main(void)
{
    int k;
    scanf("%d", &k);
    while (k--)
    {
        int i;
        int n, m;
        Init();
        scanf("%d %d", &n, &m);
        int min = INF;
        int s, t;
        int max = -INF;
        for (i = 1; i <= n; i++)
        {
            int x, y;
            scanf("%d %d", &x, &y);
            if (x < min)
            {
                min = x;
                s = i;
            }
            if (x > max)
            {
                max = x;
                t = i;
            }
        }
        for (i = 1; i <= m; i++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            Addedge(u, v, w, w);
        }
        printf("%d\n", Sap(s, t, n));
    }
    return 0;
}

TLE代码：

//ISAP没有进行优化 Time Limit Exceeded
# include <iostream>
# include <cstring>
# include <algorithm>

using namespace std;

# define MAXN 100050
# define INF 1e9 + 100

struct EDGE
{
    int to;
    int cap;
    int flow;
    int next;
}edge[MAXN * 10];

int tot;
int head[MAXN];
int gap[MAXN];
int dep[MAXN];
int pre[MAXN];
int cur[MAXN];

void Init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
}

void Addedge(int u, int v, int w, int rw = 0)
{
    edge[tot].to = v;
    edge[tot].cap = w;
    edge[tot].flow = 0;
    edge[tot].next = head[u];
    head[u] = tot++;

    edge[tot].to = u;
    edge[tot].cap = rw;
    edge[tot].flow = 0;
    edge[tot].next = head[v];
    head[v] = tot++;
}

int Sap(int start,int end,int N)
{
    memset(gap,0,sizeof(gap));
    memset(dep,0,sizeof(dep));
    memcpy(cur,head,sizeof(head));
    int u = start;
    pre[u] = -1;
    gap[0] = N;
    int ans = 0;
    int i;
    while(dep[start] < N)
    {
        if(u == end)
        {
            int Min = INF;
            for(i = pre[u];i != -1; i = pre[edge[i^1].to])
                if(Min > edge[i].cap - edge[i].flow)
                    Min = edge[i].cap - edge[i].flow;
                for(i = pre[u];i != -1; i = pre[edge[i^1].to])
                {
                    edge[i].flow += Min;
                    edge[i^1].flow -= Min;
                }
                u = start;
                ans += Min;
                continue;
        }
        bool flag = false;
        int v;
        for(i = cur[u]; i != -1;i = edge[i].next)
        {
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u])
            {
                flag = true;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if(flag)
        {
            u = v;
            continue;
        }
        int Min = N;
        for(i = head[u]; i != -1;i = edge[i].next)
            if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
            {
                Min = dep[edge[i].to];
                cur[u] = i;
            }
            gap[dep[u]]--;
            if(!gap[dep[u]])return ans;
            dep[u] = Min+1;
            gap[dep[u]]++;
            if(u != start) u = edge[pre[u]^1].to;
    }
    return ans;
}
int main(void)
{
    int k;
    scanf("%d", &k);
    while (k--)
    {
        int i;
        int n, m;
        Init();
        scanf("%d %d", &n, &m);
        int min = INF;
        int s, t;
        int max = -INF;
        for (i = 1; i <= n; i++)
        {
            int x, y;
            scanf("%d %d", &x, &y);
            if (x < min)
            {
                min = x;
                s = i;
            }
            if (x > max)
            {
                max = x;
                t = i;
            }
        }
        for (i = 1; i <= m; i++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            Addedge(u, v, w, w);
        }
        printf("%d\n", Sap(s, t, n));
    }
    return 0;
}