P5837 [USACO19DEC]Milk Pumping G（dijkstra）

题目描述

Farmer John 最近为了扩张他的牛奶产业帝国而收购了一个新的农场。这一新的农场通过一个管道网络与附近的小镇相连，FJ 想要找出其中最合适的一组管道，将其购买并用来将牛奶从农场输送到小镇。

这个管道网络可以用 N 个接合点（管道的端点）来描述，将其编号为 1…N。接合点 1 表示 FJ 的农场，接合点 N 表示小镇。有 M 条双向的管道，每条连接了两个接合点。使用第 i条管道需要 FJ 花费 $c_i$美元购入，可以支持每秒$f_i$升牛奶的流量。

FJ 想要购买一条管道组成一条单一路径， 路径的两端点分别为接合点 1 和 N 。这条路径的花费等于路径上所有管道的费用之和。路径上的流量等于路径上所有管道的最小流量 （因为这是沿这条路径输送牛奶的瓶颈）。FJ 想要最大化路径流量与路径花费之比。 保证存在从 1到 N之间的路径。

输入格式

输入的第一行包含 N 和 M。以下 M 行每行以四个整数描述一条管道：a 和 b（管道连接的两个不同的接合点），c（管道的花费），以及 f（管道的流量）。花费和流量均为范围 1…1000之内的正整数。
输出格式

输出 $10^6$乘以最优解的值，并向下取整（也就是说，如果这个数本身不是整数，输出小于它的最接近它的整数）。

输入输出样例
输入

3 2
2 1 2 4
2 3 5 3

输出

428571

说明/提示

在这个例子中，仅由一条路径从 1到 N。 它的流量为 min(3,4)=3，花费为 2+5=7。

数据范围
对于 100% 的数据，$2\le N\le 1000,1\le M\le 1000$。

50分暴力搜索代码

      dfs搜索所有可能的路径，并在搜索过程中累加路径上花费、记录路径上的最小流量。搜到终点时更新“$10^6$*流量/总花费”的最大值

//C++代码：
#include<iostream>
#include<cstring>
using namespace std;
const int N=1e4+100,mutil=1e6;

struct edge{
int u,v,c,f;
int next;
}e[N];


int head[N],cnt=0;

void Insert(int u,int v,int c,int f){
cnt++;
e[cnt].u=u;
e[cnt].v=v;
e[cnt].c=c;
e[cnt].f=f;
e[cnt].next=head[u];
head[u]=cnt;
}


int vis[N],res=-1;  


void dfs(int u,int t,int sc,int mf){

if(u==t){  
    //搜到终点时更新最大值 
    res=max(res,(mutil*mf)/sc);
    return;
    }
  vis[u]=1;
for(int i=head[u];i>=0;i=e[i].next){
    if(!vis[e[i].v]){   //如果没有访问过
       //访问出边并累加花费以及更新流量的最小值
        dfs(e[i].v, t ,sc+e[i].c , min(mf,e[i].f));
        vis[e[i].v]=0;     //撤销对v的访问标记
    }
}
}


int main(){
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    int N,M;
    cin>>N>>M;
    int a,b,c,f;
 for(int i=1;i<=M;i++){
        cin>>a>>b>>c>>f;
        Insert(a,b,c,f);
        Insert(b,a,c,f);
  }
  
  dfs(1,N,0,1e6);
  
  cout<<res<<endl;
return 0;
}

满分dijkstra解法

   思路：最小流量与路径上总花费的比值为$\frac{f}{\sum c_i}$。如果最小流量$f$确定（为一个常数），那么路径上的总花费越小则最终的比值就越大。所以不妨枚举所有可能的最小流量（最小流量只可能是网络上的某一个流量值），并在这个最小流量下跑一遍花费的最短路，求得所有的比值后，在所有可能的比值中选一个最大值即可。需要注意的一点就是，当假定了最小流量以后，那些流量小于”最小流量”的边就“不能走了”（不能用于更新最短路）。

#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
const int m=1e6+100,multi=1e6,inf=0x7f7f7f7f;
struct edge{
int u,v,c,f;
int next;
}e[m];


int head[m],cnt=0;
void Insert(int u,int v,int c,int f){
cnt++;
e[cnt].u=u;
e[cnt].v=v;
e[cnt].c=c;
e[cnt].f=f;
e[cnt].next=head[u];
head[u]=cnt;
}

struct node{
int u;
int dis;
bool operator <(const node &b)const{
return dis>b.dis;
}
};

int dist[m],vis[m];

//假设最小流量为x，并在此流量下跑一遍花费的最短路
void dijkstra(int start,int x){
memset(vis,0,sizeof(vis));
memset(dist,0x7f7f7f7f,sizeof(dist));
priority_queue<node>q;
q.push((node){start,0});
dist[start]=0;
node temp;
while(!q.empty()){
    temp=q.top();
    q.pop();
    int u=temp.u;
    if(vis[u]) continue;
    vis[u]=1;
    for(int i=head[u];i>=0;i=e[i].next){
        int v=e[i].v;
        int w=e[i].c;
        int f=e[i].f;
        //若边上的流量大于假定的最小流量x，则不能用这条边更新最短路
        if(dist[v]>dist[u]+w && e[i].f>=x){
            dist[v]=dist[u]+w;
            q.push((node){v,dist[v]});
        }
    }
}

}

int main(){

    memset(head,-1,sizeof(head));
    int N,M;
    cin>>N>>M;
    int a,b,c,f,F[M];
    
 for(int i=1;i<=M;i++){
        cin>>a>>b>>c>>f;
        Insert(a,b,c,f);
        Insert(b,a,c,f);
        F[i]=f;  //记录所有可能的流量值
  }
  
  int res=-1;
  
  //对所有可能的流量跑一遍最短路，得相应比值
  for(int i=1;i<=M;i++) {
    dijkstra(1,F[i]);
    //(multi*F[i])/dist[N]为“假定最小流量为x”时的比值
    res=max(res,(multi*F[i])/dist[N]);
  }

 cout<<res<<endl;
return 0;
}