poj 2391(最大流+二分+拆点)

wa的真心给跪了,,,,
也是先Floyd，然后二分答案做最大流。。

题意：有n块草地，一些奶牛在草地上吃草，草地间有m条路，一些草地上有避雨点，每个避雨点能容纳的奶牛是有限的，给出通过每条路的时间，问最少需要多少时间能让所有奶牛进入一个避雨点。
思路：拆点建图，每个点的(in)和(out)间容量inf，源点向每个有牛的点(in)连边，容量为该点的牛数，每个有避雨点的点(out)向汇点连边，容量为避雨点能容纳的牛数。然后二分答案做最大流，满流就说明当前值可以让所有牛避雨成功，不断二分缩小答案
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;
const __int64 maxn=1000;
const __int64  inf=9999999999999999;
struct node
{
    __int64  v,next;
    __int64 val;
}s[maxn*maxn*2];


__int64 level[maxn];//顶点的层次
__int64 p[maxn];
__int64 que[maxn*10];//BFS中用于遍历的顶点，DFS求增广中记录边
__int64 out[10*maxn];//DFS用于几乎定点的分支
__int64 ind;
void insert(__int64 x,__int64 y,__int64 z)
{
    s[ind].v=y;
    s[ind].val=z;
    s[ind].next=p[x];
    p[x]=ind++;
    s[ind].v=x;
    s[ind].val=0;
    s[ind].next=p[y];
    p[y]=ind++;
}
void init()
{
    ind=0;
    memset(p,-1,sizeof(p));
}
__int64 max_flow(__int64 n,__int64 source,__int64 sink)
{
    __int64 ret=0;
    __int64 h=0,r=0;
    while(1)//DFS
    {
        __int64 i;
        for(i=0;i<=n;++i)
        level[i]=0;
         h=0,r=0;
        level[source]=1;
        que[0]=source;
        while(h<=r)//BFS
        {
            int  t=que[h++];
            for(i=p[t];i!=-1;i=s[i].next)
            {
                if(s[i].val&&level[s[i].v]==0)
                {
                    level[s[i].v]=level[t]+1;
                    que[++r]=s[i].v;
                }
            }
        }
        //topset=r;//记录原点的集合个数
        if(level[sink]==0)break;//找不到汇点
        for(i=0;i<=n;++i)
        out[i]=p[i];
        __int64  q=-1;
        while(1)
        {
            if(q<0)
            {
                __int64  cur=out[source];
                for(;cur!=-1;cur=s[cur].next)
                {
                    if(s[cur].val&&out[s[cur].v]!=-1&&level[s[cur].v]==2)
                    {
                        break;
                    }
                }
                if(cur>=0)
                {
                    que[++q]=cur;
                    out[source]=s[cur].next;
                }
                else
                {
                    break;
                }
            }
            __int64  u=s[que[q]].v;
            if(u==sink)//一条增广路
            {
                __int64  dd=inf;
                __int64  index=-1;
                for(i=0;i<=q;i++)
                {
                    if(dd>s[que[i]].val)
                    {
                        dd=s[que[i]].val;
                        index=i;
                    }
                }
                ret+=dd;
                //cout<<ret<<endl;
                for(i=0;i<=q;i++)
                {
                    s[que[i]].val-=dd;
                    s[que[i]^1].val+=dd;
                }
                for(i=0;i<=q;i++)
                {
                    if(s[que[i]].val==0)
                    {
                        q=index-1;
                        break;
                    }
                }
            }
            else
            {
                __int64 cur=out[u];
                for(;cur!=-1;cur=s[cur].next)
                {
                    if(s[cur].val&&out[s[cur].v]!=-1&&level[u]+1==level[s[cur].v])
                    {
                        break;
                    }
                }
                if(cur!=-1)
                {
                    que[++q]=cur;
                    out[u]=s[cur].next;
                }
                else
                {
                    out[u]=-1;
                    q--;
                }
            }
        }
    }
    return ret;
}
__int64 n,m;
__int64 star[maxn];
__int64 col[maxn];
__int64 map[maxn][maxn];
__int64 mm;
void floyd()
{
    for(int k=1;k<=n;k++)
     for(int i=1;i<=n;i++)
      for(int j=1;j<=n;j++)
      {
          if(map[i][k]+map[k][j]<map[i][j]&&map[i][k]!=inf&&map[k][j]!=inf)
          map[i][j]=map[i][k]+map[k][j];
      }
}


void built(int mid)
{
    init();
    for(int i=1;i<=n;i++)
     insert(0,i,star[i]);
    for(int j=1;j<=n;j++)
     insert(j+n,2*n+1,col[j]);
    //for(int i=1;i<=n;i++)
     //insert(i,i+n,inf);


       for(int i=1;i<=n;i++)
           for(int j=1;j<=n;j++)
               if(map[i][j]<=mid)
                   insert(i,j+n,inf);
               else
                   insert(i,j+n,0);
}
int main()
{
    cin>>n>>m;
    __int64 sum=0;
    __int64 e=0;
    for(int i=1;i<=n;i++)
    {
     cin>>star[i]>>col[i];
     sum+=star[i];
     e+=col[i];
    }
    __int64 u,v,c;
    for(int i=1;i<=n;i++)
    {
      for(int j=1;j<=n;j++)
       map[i][j]=inf;
       map[i][i]=0;
    }




    for(int j=1;j<=m;j++)
    {
        cin>>u>>v>>c;
        mm+=c;
        if(c<map[u][v])
        map[u][v]=map[v][u]=c;
    }
    floyd();
    int ans, sign = 0;
    __int64 l = 0, r = mm + 1, mid;
    while (l < r)
    {
        mid = (l + r) >> 1;
         built( mid);
         ans = max_flow(2*n+2, 0, 2*n+1);
         if (ans == sum)
         {
             r = mid;
             sign = 1;
         }
         else
         {
             l = mid + 1;
         }
    }
    if (sign)//如果没有满足所有牛都进牛棚会输出-1
    {
        printf("%I64d\n", r);
    }
    else
    {
        printf("-1\n");
    }
    return 0;
}