H Minimum-cost Flow（预处理增广费用）

题：https://ac.nowcoder.com/acm/contest/5666/H

题意：给定网络，然后每次询问给定每条边的容量ui/vi，问从节点1到节点n在流过 1 的情况下的最小费用

分析：把图的所有边容量设为1跑费用流，因为这样的话，在ui，vi条件下，可以等价为每条边乘上vi/ui，让每条边固定为1的容量；

　　　而满足条件就是要增广vi/ui（在ui的“进制”下向上取整）次，因为所有边容量相同，而所以每次增广出来的容量是一样的为ui/vi,且费用依次递增；

　　　所以只要预处理费用的前缀和即可（这也是预处理是设流量为1的好处）；

　　　计算时，只要vi/ui(向下取整的部分)*ui 和余下来的部分*ui即为分子部分

#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define MP make_pair
#define lson root<<1,l,midd
#define rson root<<1|1,midd+1,r
typedef long long ll;
const int mod=1e9+7;
const int M=105;
const int inf=0x3f3f3f3f;
struct node{
    int u,v,w,cost,nextt;
}e[30000];
int mincost;
int head[M],cur[M],dis[M],vis[M],tmp[M*100],tot,s,t;
void addedge(int u,int v,int w,int cost){
    e[tot].u=u;
    e[tot].v=v;
    e[tot].w=w;
    e[tot].cost=cost;
    e[tot].nextt=head[u];
    head[u]=tot++;
    e[tot].u=v;
    e[tot].v=u;
    e[tot].w=0;
    e[tot].cost=-cost;
    e[tot].nextt=head[v];
    head[v]=tot++;
}
bool bfs(){
    for(int i=0;i<=t;i++)
        dis[i]=inf;
    queue<int>que;
    que.push(s);
    dis[s]=0;
    while(!que.empty()){
        int u=que.front();
        que.pop();
        vis[u]=0;
        for(int i=head[u];~i;i=e[i].nextt){
            int v=e[i].v;
            if(e[i].w&&dis[u]+e[i].cost<dis[v]){
                dis[v]=dis[u]+e[i].cost;
                if(!vis[v]){
                    vis[v]=1;
                    que.push(v);
                }
            }
        }
    }
    return dis[t]!=inf;
}
int dfs(int u,int fl){
    if(u==t)
        return fl;
    int ans=0;
    vis[u]=1;
    for(int i=cur[u];~i;i=e[i].nextt){
        int v=e[i].v;
        if(dis[v]==dis[u]+e[i].cost&&!vis[v]&&e[i].w){
            cur[u]=i;
            int x=dfs(v,min(e[i].w,fl-ans));
            e[i].w-=x;
            e[i^1].w+=x;
            ans+=x;
            mincost+=x*e[i].cost;
            if(ans==fl)
                break;
        }
    }
    vis[u]=0;
    return ans;
}
int MCMF(){
    int ans=0;
    while(bfs()){
        for(int i=0;i<=t;i++)
            cur[i]=head[i];
        ans+=dfs(s,inf);
        tmp[ans]=tmp[ans-1]+mincost;
        mincost=0;
    }
    return ans;
}
int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        memset(head,-1,sizeof(head));
        s=1,t=n;
        tot=0,mincost=0;
        for(int u,v,cost,i=1;i<=m;i++){
            scanf("%d%d%d",&u,&v,&cost);
            addedge(u,v,1,cost);
        }
        int flow=MCMF();
        int q;
        scanf("%d",&q);
        while(q--){
            ll u,v;
            scanf("%lld%lld",&u,&v);
            if(u==0){
                puts("NaN");
                continue;
            }
            ll need=(v+(u-1))/u;///增广次数
            if(need>flow)///v/u>flow
                puts("NaN");
            else{
                ll UP=1ll*tmp[need-1]*u;
                UP+=1ll*(tmp[need]-tmp[need-1])*(v-(need-1)*u);
                ll DOWM=v;
                ll g=__gcd(UP,DOWM);
                printf("%lld/%lld
",UP/g,DOWM/g);
            }
        }
    }
    return 0;
}