hdu 1839 Delay Constrained Maximum Capacity Path（二分+SPFA）

题目大意：
有N个点，点1为珍贵矿物的采矿区， 点N为加工厂，有M条双向连通的边连接这些点。走每条边的运输容量为C，运送时间为D。
他们要选择一条从1到N的路径运输， 这条路径的运输总时间要在T之内，在这个前提之下，要让这条路径的运输容量尽可能地大。
一条路径的运输容量取决与这条路径中的运输容量最小的那条边。

分析与总结：

因为每条路径的容量取决于这条路径中所有边中的最小容量，所以我们可以以此枚举最小容量。
但是如果一个一个容量的枚举，那明显效率太低了。

通过分析，可以看出，如果最低容量越大，那么符合要求的路径就越少，所以，根据容量的大小，路径数量是单调的。

有了单调性，就可以利用二分法了。

只要把容量从大到小进行排序，然后二分之，很快便能算出答案。

不过注意需要双向建边

#include <set>
#include <map>
#include <queue>
#include <deque>
#include <cmath>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF 0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-9
#define maxn 1000010
#define MOD 1000000007

struct Edge
{
int to,next,cap,time;
bool operator<(const Edge &a)const
{
return time < a.time;
}
}edge[100010];
int n,m,k;
int dis[10010],Cost[50010],ans;
int headlist[10010],vis[10010];

void SPFA(int u,int limit)
{
queue<int> q;
memset(vis,0,sizeof(vis));
memset(dis,INF,sizeof(dis));
q.push(u);
vis[u] = 1;
dis[u] = 0;
while(!q.empty())
{
int x = q.front();
q.pop();
vis[x] = 0;
for(int i = headlist[x]; i != -1; i = edge[i].next)
{
int y = edge[i].to;
if(dis[y] > dis[x] + edge[i].time && edge[i].cap >= limit)
{
dis[y] = dis[x] + edge[i].time;
if(!vis[y])
{
q.push(y);
vis[y] = 1;
}
}
}
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&n,&m,&k);
memset(headlist,-1,sizeof(headlist));
for(int i = 0; i < m; i++)
{
int x,y,c,w;
scanf("%d%d%d%d",&x,&y,&c,&w);
edge[2*i].to = y;
edge[2*i].cap = c;
edge[2*i].time = w;
edge[2*i].next = headlist[x];
headlist[x] = 2*i;
edge[2*i+1].to = x;
edge[2*i+1].cap = c;
edge[2*i+1].time = w;
edge[2*i+1].next = headlist[y];
headlist[y] = 2*i+1;
Cost[i] = c;
}
sort(Cost,Cost+m);
int left = 0,right = m-1;
ans = 0;
while(left <= right)
{
int mid = (left + right) / 2;
SPFA(1,Cost[mid]);
if(dis
> k)
right = mid - 1;
else
{
left = mid + 1;
ans = max(ans,Cost[mid]);
}
}
printf("%d\n",ans);
}
return 0;
}