ZOJ 2364 Data Transmission (最大流：Dinic+贪心预流)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2364

裸的最大流。。。

用了Dinic、ISAP、HLPP都TLE。。。

然后在网上看到了个贪心预流的优化，就AC了，2030ms

贪心预流仅用于预处理分层图网络流

HLPP一般适合处理分层图，但是怎么加了贪心预流还是T了。。DINIC和ISAP加了贪心预流就AC了。。

同时附上Dinic和贪心预流模板~

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<list>
#include<map>
#include<iterator>
#include<cstdlib>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
#include<functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
//const int maxn=0;
//const int inf=0x3f3f3f3f;
const LL inf64=0x3f3f3f3f3f3f3f3fLL;
const double INF=1e30;
const double eps=1e-6;
/**
*最大流最小割：加各种优化的Dinic算法($O(V^2E)$)
*输入：图(链式前向星),n(顶点个数,包含源汇),st(源),ed(汇)
*输出：Dinic(NdFlow)(最大流),MinCut()(最小割)(需先求最大流)
*打印路径方法：按反向边(i&1)的flow 找，或者按边的flow找
*/
const int maxn=1510;
const int maxm=600010;
const int inf=0x3f3f3f3f;
struct Edge
{
    int u,v;
    int cap,flow;
    int next;
} edge[maxm];
int head[maxn],edgeNum;//需初始化
int n,m,d[maxn],cur[maxn];
int st,ed;
bool vis[maxn];
void addSubEdge(int u,int v,int cap,int flow)
{
    edge[edgeNum].u=u;
    edge[edgeNum].v=v;
    edge[edgeNum].cap=cap;
    edge[edgeNum].flow=flow;
    edge[edgeNum].next=head[u];
    head[u]=edgeNum++;
    cur[u]=head[u];
}
void addEdge(int u,int v,int cap)
{
    addSubEdge(u,v,cap,0);
    addSubEdge(v,u,0,0);//注意加反向0 边
}
bool BFS()
{
    queue<int> Q;
    memset(vis, 0, sizeof(vis));
    Q.push(st);
    d[st]=0;
    vis[st]=1;
    while (!Q.empty())
    {
        int u=Q.front();
        Q.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            int w=edge[i].cap-edge[i].flow;
            if(w>0 && !vis[v])
            {
                vis[v]=1;
                Q.push(v);
                d[v]=d[u]+1;
                if(v==ed) return 1;
            }
        }
    }
    return false;
}
int Aug(int u, int a)
{
    if (u==ed) return a;
    int aug=0, delta;
    for(int &i=cur[u]; i!=-1; i=edge[i].next)
    {
        int v=edge[i].v;
        int w=edge[i].cap-edge[i].flow;
        if (w>0 && d[v]==d[u]+1)
        {
            delta = Aug(v, min(a,w));
            if (delta)
            {
                edge[i].flow += delta;
                edge[i^1].flow -= delta;
                aug += delta;
                if (!(a-=delta)) break;
            }
        }
    }
    if (!aug) d[u]=-1;
    return aug;
}
int Dinic(int NdFlow)
{
    int flow=0;
    while (BFS())
    {
        memcpy(cur,head,sizeof(int)*(n+1));
        flow += Aug(st,inf);
        /*如果超过指定流量就return 掉*/
        if(NdFlow==inf) continue;
        if(flow > NdFlow) break;
    }
    return flow;
}
/*残余网络*/
void Reduce()
{
    for(int i=0; i<edgeNum; i++) edge[i].cap-=edge[i].flow;
}
/*清空流量*/
void ClearFlow()
{
    for(int i=0; i<edgeNum; i++) edge[i].flow=0;
}
/*求最小割*/
vector<int> MinCut()
{
    BFS();
    vector<int> ans;
    for(int u=0; u<n; u++)
    {
        if(!vis[u]) continue;
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            if(i&1) continue;/*忽略反向边*/
            int v=edge[i].v;
            int w=edge[i].cap;
            if(!vis[v]&&w>0) ans.push_back(i);
        }
    }
    return ans;
}

/**
*贪心预流：用于分层图Dinic预处理(从0到n-1)
*输入：图(链式前向星),n(顶点个数,包含源汇),st(源),ed(汇),rk[i]=i,level[](分层图的层次)
*输出：GreedyPreFlow()(预处理Dinic)
*/
int in[maxn],out[maxn];
int level[maxn],rk[maxn];
bool cmp(const int &i,const int &j)
{
    return level[i]<level[j];
}
void GreedyPreFlow()
{
    memset(in, 0, sizeof (in));
    memset(out, 0, sizeof (out));
    sort(rk, rk+n, cmp);
    in[st] = inf;
    for (int i = 0; i < n; ++i)
    {
        int u = rk[i];
        for (int j = head[u]; j!=-1; j = edge[j].next)
        {
            int v = edge[j].v, w = edge[j].cap-edge[j].flow;
            if (!(j & 1) && in[u] > out[u])
            {
                int f = min(w, in[u]-out[u]);
                in[v] += f, out[u] += f;
            }
        }
    }
    memset(in, 0, sizeof (in));
    in[ed] = inf;
    for (int i = n-1; i >= 0; --i)
    {
        int v = rk[i];
        for (int j = head[v]; j!=-1; j = edge[j].next)
        {
            int u = edge[j].v, w = edge[j^1].cap-edge[j^1].flow;
            if (j & 1 && out[u] > in[u])
            {
                int f = min(w, min(out[u]-in[u], in[v]));
                in[u] += f, in[v] -= f;
                edge[j].flow -= f, edge[j^1].flow += f;
            }
        }
    }
}

int N,M,L;
void init()
{
    memset(head,-1,sizeof(head));
    edgeNum=0;
}
void input()
{
    scanf("%d%d%d",&N,&M,&L);
    int x=0;
    int idx=0;
    st=0,ed=0;
    for(int i=0; i<N; i++)
    {
        scanf("%d",&x);
        rk[i]=i;
        level[i]=x;
        if(x==1) st=i;
        if(x==L) ed=i;
    }
    for(int i=0; i<M; i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        u--,v--;
        addEdge(u,v,w);
    }
    n=N;
}
void solve()
{
    GreedyPreFlow();
    ISAP(inf);
//    cout<<HLPP()<<endl;
//    cout<<Dinic(inf)<<endl;
    for(int i=0; i<edgeNum; i+=2) printf("%d\n",edge[i].flow);
}
void output()
{
    //
}
int main()
{
//    std::ios_base::sync_with_stdio(false);
//    freopen("in.cpp","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}