bzoj 3931: [CQOI2015]网络吞吐量

题目描述
路由是指通过计算机网络把信息从源地址传输到目的地址的活动，也是计算机网络设计中的重点和难点。网络中实现
路由转发的硬件设备称为路由器。为了使数据包最快的到达目的地，路由器需要选择最优的路径转发数据包。例如，
在常用的路由算法OSPF(开放式最短路径优先)中，路由器会使用经典的Dijkstra算法计算最短路径，然后尽量沿最短
路径转发数据包。
现在，若已知一个计算机网络中各路由器间的连接情况，以及各个路由器的最大吞吐量（即每秒能转发的数据包数
量），假设所有数据包一定沿最短路径转发，试计算从路由器1到路由器n的网络的最大吞吐量。计算中忽略转发及传
输的时间开销，不考虑链路的带宽限制，即认为数据包可以瞬间通过网络。路由器1到路由器n作为起点和终点，自身
的吞吐量不用考虑，网络上也不存在将1和n直接相连的链路。
输入格式
输入文件第一行包含两个空格分开的正整数n和m，分别表示路由器数量和链路的数量。网络中的路由器使用1到n编
号。
接下来m行，每行包含三个空格分开的正整数a、b和d，表示从路由器a到路由器b存在一条距离为d的双向链路。
接下来n行，每行包含一个正整数c，分别给出每一个路由器的吞吐量。
输出格式
输出一个整数，为题目所求吞吐量。
输入样例
7 10
1 2 2
1 5 2
2 4 1
2 3 3
3 7 1
4 5 4
4 3 1
4 6 1
5 6 2
6 7 1
11
00
20
50
20
60
1
输出样例
70
数据范围
对于30%的数据，n≤100，m≤1000

对于100%的数据，n≤500，m≤100000，d,c≤10^9

题目格式就这样吧....

裸的最大流。先跑出最短路图。然后拆点限制流量跑最大流就可以了

记得开longlong。一开始莫名其妙T了一次

#include<queue>
#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
inline int min(int x,int y)
{
     if(x<y)
          return x;
     return y;
}
int head[100001],exhead[100001];
struct map
{
	 long long f;
	 int s,t;
     int next;
}a[400001],exa[400001];
int edge,exedge;
int p;
int q[400001],d[400001];
inline void add1(int s,int t,int f,int xxx)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].f=f;
}
inline void add(int s,int t,long long f)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].f=f;
}
inline void exadd(int s,int t,long long f)
{
     exa[exedge].next=exhead[s];
     exhead[s]=exedge;
     exa[exedge].s=s;
     exa[exedge].t=t;
     exa[exedge].f=f;
}
inline bool bfs()
{
     int l=0,r=0;
     memset(q,0,sizeof(q));
     r++;
     q[r]=1;
     memset(d,-1,sizeof(d));
     d[1]=0;
     int i,k;
     while(l<r)
     {
     	  l++;
          int k=q[l];
          for(i=head[k];i!=0;i=a[i].next)
          {
               if(a[i].f>0&&d[a[i].t]==-1)
               {
                    d[a[i].t]=d[k]+1;
                    r++;
                    q[r]=a[i].t;
               }
          }
     }
     if(d[p]>=0)
          return true;
     return false;
}
inline long long dfs(int k,long long s)
{
     if(k==p)
          return s;
     long long t=s;
     int i;
     for(i=head[k];i!=0;i=a[i].next)
     {
          if(d[a[i].t]==d[k]+1&&a[i].f>0)
          {
               long long xx=dfs(a[i].t,min(s,a[i].f));
               a[i].f-=xx;
               if(i%2==0)
                    a[i-1].f+=xx;
               else
                    a[i+1].f+=xx;
               s-=xx;
          }
     }
     return t-s;
}
inline long long maxflow()
{
     long long s=0;
     while(bfs())
          s+=dfs(1,(long long)1000000000*(long long)5000);
     return s;
}
long long dis[501];
bool v[501];
inline void spfa()
{
	 int i;
	 for(i=1;i<=500;i++)
	      dis[i]=(long long)1000000000*(long long)5000;
	 memset(v,false,sizeof(v));
     queue <int>Q;
     while(!Q.empty())
          Q.pop();
     Q.push(1);
     dis[1]=0;
     v[1]=true;
     while(!Q.empty())
     {
          int d=Q.front();
          v[d]=false;
          Q.pop();
          int i;
          for(i=exhead[d];i!=0;i=exa[i].next)
          {
               int t=exa[i].t;
               if(dis[d]+exa[i].f<dis[t])
               {
                    dis[t]=dis[d]+exa[i].f;
                    if(!v[t])
                    {
                         Q.push(t);
                         v[t]=true;
                    }
               }
          }
     }
}
int b[100001];
int main()
{
     int T;
          memset(head,0,sizeof(head));
          memset(a,0,sizeof(a));
          memset(exhead,0,sizeof(exhead));
          memset(exa,0,sizeof(exa));
          edge=0;
          exedge=0;
		  int n,m;
          scanf("%d%d",&n,&m);
          int i;
          int s,t,x;
          for(i=1;i<=m;i++)
          {
               scanf("%d%d%d",&s,&t,&x);
               exedge++;
               exadd(s,t,x);
               exedge++;
               exadd(t,s,x);
          }
          spfa();
          p=n;
          for(i=1;i<=n;i++)
          {
               scanf("%d",&b[i]);
               long long lim=b[i];
               if(i==1||i==n)
                    lim=(long long)1000000000*(long long)5000;
               edge++;
               add(i,i+p,lim);
               edge++;
               add(i+p,i,0);
          }
          for(i=1;i<=exedge;i++)
          {
               if(dis[exa[i].s]+exa[i].f==dis[exa[i].t])
               {
                    edge++;
                    add(exa[i].s+p,exa[i].t,2100000000);
                    edge++;
                    add(exa[i].t,exa[i].s+p,0);
               }
          }
          p=n*2;
          long long ans=maxflow();
          printf("%lld\n",ans);
     return 0;
}