hdu 1839 Delay Constrained Maximum Capacity Path（最短路+二分）

Delay Constrained Maximum Capacity Path

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=1839

解题思路：

题目大意：

有n个点，点1为珍贵矿物的采矿区， 点n为加工厂，有m条双向连通的边连接这些点。走每条边的运输容量为C，运送时间为D。

他们要选择一条从1到n的路径运输， 这条路径的运输总时间要在T之内，在这个前提之下，要让这条路径的运输容量尽可能地大。

一条路径的运输容量取决与这条路径中的运输容量最小的那条边。
算法思想：

因为每条路径的容量取决于这条路径中所有边中的最小容量，所以我们可以以此枚举最小容量。

但是如果一个一个容量的枚举，那明显效率太低了。

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

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

然后进行二分，很快便能算出答案。

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;

struct Edge{
    int to,cap,cost;
};
vector<Edge> edge[50005];
int n,m,maxcost;
int vis[10005];
int dis[10005];//最短距离

void SPFA(int cap){
    queue<int>  q;
    int i;
    memset(vis,0,sizeof(vis));
    for(i = 0; i <= n; i++)
        dis[i] = INF;
    dis[1] = 0;
    vis[1] = 1;
    q.push(1);
    while(!q.empty()){
        int cur = q.front();
        q.pop();
        vis[cur] = 0;
        int l = edge[cur].size();
        for(i = 0; i < l; i++){
            int tmp = edge[cur][i].to;
            if(dis[tmp] > dis[cur] + edge[cur][i].cost && edge[cur][i].cap >= cap){
                dis[tmp] = dis[cur] + edge[cur][i].cost;
                if(!vis[tmp]){
                    q.push(tmp);
                    vis[tmp] = 1;
                }
            }
        }
    }
}

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d",&n,&m,&maxcost);
        for(int i = 0; i <= n; i++)
            edge[i].clear();
        int u,v,cap,cost;
        Edge tmp;
        int maxn = 0,minn = INF;
        for(int i = 0; i < m; i++){
            scanf("%d%d%d%d",&u,&v,&cap,&cost);
            maxn = max(maxn,cap);
            minn = min(minn,cap);
            tmp.to = v;tmp.cap = cap;tmp.cost = cost;
            edge[u].push_back(tmp);
            tmp.to = u;
            edge[v].push_back(tmp);
        }
        int ans;
        while(minn <= maxn){
            int mid = (minn+maxn)>>1;
            SPFA(mid);
            if(dis[n] <= maxcost){
                minn = mid+1;
                ans = mid;
            }
            else
                maxn = mid-1;
        }
        printf("%d\n",ans);
    }
    return 0;
}