POJ 2391

虽然这道题从网络流的角度来说不算难题，甚至是一道水题，但是还是足足卡了我3天啊，这是我学DINIC的第一道题，最开始第一天刚刚看了DINIC算法，就那这道题练练手，第一天做了一晚上硬是没有出来正常答案（样例），第二天仔细一想发现图建错了，没有拆点，有捣鼓了一晚上终于过样例了，但是。。用二维数组写的果断TLE了。。

今天晚上用边表写了一遍，其实应该拿上就能写出来的，一个是无穷大定义小了，另一个是BFS写错了。。。。早知道就不应数组了。。直接队列。。

不多说，解题思路，注释和过程见代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#define INF 1000000
#define LINF 9999999999999//这个要注意不要定义小了 会WA的。。果断应为这个贡献了一个WA
#define MAXN 205
#define MAXM 405
using namespace std;
__int64 dis[MAXN][MAXN];//这个数组储存两点之间的最短路，观察数据集会发现必须要用LL
int input_date[MAXN],input_num[MAXN];//输入，保存每一个农田的现有奶牛数和可容纳的奶牛数；
struct Edge//边表，这道题不用边表用二维数组会超时，vector应该也会。。所以网络流还是尽量用边表写
{
    int to;
    int next;
    int value;
}edge[MAXM*MAXM*10];//这个随便开的 尽量开大点~~~~
int head[MAXM];//指针数组
int leve[MAXM];//层次网络
int num_point;//边的条数
int F,P,n;
void add_edge(int x,int y,int cost)
{
    edge[num_point].to=y;
    edge[num_point].value=cost;
    edge[num_point].next=head[x];
    head[x]=num_point++;
    edge[num_point].to=x;//方便构建残余网络，所以要反向建边
    edge[num_point].value=0;//初始的容量为0
    edge[num_point].next=head[y];
    head[y]=num_point++;
    return;
}
void build_graph(__int64 min_max)//大致的构图思路:源点到各个农场的容量为农场现有的奶牛数，各个农场拆完点后变为i+n与汇点的边的容量为农场最多可以容纳的奶牛数，其他的边都是INF，之后再说
{
    memset(head,-1,sizeof(head));
    num_point=0;
    for(int i=1;i<=n;i++)
    {
        add_edge(0,i,input_date[i]);
        add_edge(i,i+n,INF);
        add_edge(i+n,n+n+1,input_num[i]);
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j) continue;//这个没有必要应为前面已经连过了
            if(dis[i][j]>min_max) continue;
            if(input_date[i]&&input_num[j]) add_edge(i,j+n,INF);//如果两点之间的距离比二分出来的最大距离短的话并且i还有奶牛j可容纳的奶牛数不为0
        }
    }
    return;
}
bool BFS()//BFS构建层次网络；比较容易懂就不多说了
{
    memset(leve,0,sizeof(leve));
    leve[0]=1;
    int queue_Q[5000],Q_end=0;
    queue_Q[Q_end++]=0;
    for(int k=0;k<Q_end;k++)//说下这个k<Q_end我多加了一个等号找死我了。。。。
    {
        int x=queue_Q[k];
        for(int i=head[x];i!=-1;i=edge[i].next)
        {
            if(!leve[edge[i].to]&&edge[i].value)
            {
                leve[edge[i].to]=leve[x]+1;
                queue_Q[Q_end++]=edge[i].to;
            }
        }
    }
    if(leve[n+n+1]) return true;
    return false;
}
int DFS(int x,int sum)
{
    if(x==n+n+1) return sum;
    int s=0;
    for(int i=head[x];i!=-1;i=edge[i].next)
    {
        if(leve[edge[i].to]==leve[x]+1&&edge[i].value)
        {
            int t=DFS(edge[i].to,min(sum-s,edge[i].value));
            edge[i].value-=t;
            edge[i+1].value+=t;
            s+=t;
        }
    }
    return s;
}
int main()
{
    int x,y,sum;
    __int64 cost,left,right,mid,ans;
    int num_cow;
    while(scanf("%d%d",&F,&P)!=EOF)
    {
        n=F;
        num_cow=0;
        for(int i=1;i<=F;i++)
        {
            scanf("%d%d",&input_date[i],&input_num[i]);
            num_cow+=input_date[i];
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=i+1;j<=n;j++)
            {
                dis[i][j]=dis[j][i]=LINF;
            }
            dis[i][i]=0;
        }
        for(int i=0;i<P;i++)
        {
            scanf("%d%d%I64d",&x,&y,&cost);
            if(dis[x][y]==LINF||dis[x][y]>cost)
                dis[x][y]=dis[y][x]=cost;//记得是双向边；
        }
        right=left=0;
        for(int k=1;k<=n;k++)//FLOYD算出两点之间的最短路；
        {
            for(int i=1;i<=n;i++)
            {
                if(dis[i][k]!=LINF)
                {
                    for(int j=1;j<=n;j++)
                    {
                        dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
                        right=max(right,dis[i][j]);
                    }
                }
            }
        }
        ans=-1;//这个地方要注意，题目中说了没有答案输出-1
        while(left<right)//二分枚举最长路径
        {
            mid=(left+right)/2;
            build_graph(mid);
            sum=0;
            while(BFS())
            {
                sum+=DFS(0,INF);
            }
            if(sum>=num_cow)
            {
                right=mid;
                ans=right;
            }
            else
                left=mid+1;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

感觉这一个学期来自己的心态越来越不同了，以前喜欢切水题，或者看题解，各种A很有成就感，现在一道题憋三天之后自己想出来感觉更加爽~~~~~~~