牛客多校1——Minimum-cost Flow

题意：

　　给定一个n点m边的带费用的网络和q次询问，每次询问会对该网络的每条边的容量进行再定义，求每次改完边的容量后，图中流通一单位流量所需要的最小花费是多少。

 

做法：

　　因为n和m的大小，无法跑多次的MCMF，所以考虑先把整个网络边容积设成1，跑一次MCMF，在MCMF的过程中记录一下，跑到第i条增广路时的花费为多少。此举相当于，在边容积为1的网络上发送一单位的流量时，花费为多少。

　　之后，对于每次修改边容积成 u/v，可以看做是在边的容积为u的网络上，发送v流量所消耗的mincost。

　　此举意味着，之前所记录的每条增广路的花费cost[i]*u，即可得到每发送v流量所需要的mincost。

　　也就是说，共所需 v/u 组流量为u的增广路，加上 v%u 组流量为1的增广路

　　显然此时网络的最大流为原网络的最大流*u，如果maxflow < v，说明无解

　　有解情况下的mincost = 前v/u组增广路的mincost * u + v % u组流量为1的mincost

　　对于mincost/v约分，即可得到最终答案

 

CODE

 

#include <bits/stdc++.h>
#define dbg(x) cout << #x << " = " << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;
const int maxn =  1e3 +7;
const int inf  =  0x3f3f3f3f;

template<class T>inline void read(T &res)
{
    char c;T flag = 1;
    while((c = getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

LL n,m,s,t,cnt;
LL mincost;
LL head[maxn], dis[maxn], vis[maxn], cur[maxn];
LL sum[maxn << 1];

vector<LL>path;

struct edge {
    LL to, next, cap, cost;
}e[maxn << 1];

void add(LL x,LL y,LL z,LL c) {
    e[cnt].to = y;
    e[cnt].cap = z;
    e[cnt].cost = c;
    e[cnt].next = head[x];
    head[x] = cnt++;
}

void BuildGraph(LL x,LL y,LL z,LL c) {
    add(x,y,z,c);
    add(y,x,0,-c);
}

bool spfa()
{
    //cout << '!' << endl;
    queue<int>q;
    for(LL i=1;i<=n;i++)
        dis[i] = inf;
    memset(vis,0,sizeof(vis));
    dis[s] = 0;
    vis[s] = 1;
    q.push(s);
    while(!q.empty())
    {
        //cout << '?' << endl;
        LL u = q.front();
        q.pop();
        vis[u] = 0;
        for(LL i = head[u]; i != -1; i = e[i].next) {
            LL v = e[i].to;
           // dbg(u);dbg(v);
            if(e[i].cap>0 && dis[u]+e[i].cost < dis[v]) {
                dis[v] = dis[u]+e[i].cost;
                if(!vis[v]) {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    if(dis[t] != inf)
        return 1;
    return 0;
}

LL dfs(LL u,LL flow) {
    vis[u] = 1;
    if(u == t)
        return flow;
    for(LL& i = cur[u];i != -1;i = e[i].next) {
        LL v = e[i].to;
        if(e[i].cap>0&&dis[v] == dis[u]+e[i].cost&&!vis[v])
        {
            LL di = dfs(v, min(flow, e[i].cap));
            if(di>0) {
                e[i].cap -= di;
                e[i^1].cap += di;
                mincost += di*e[i].cost;
                return di;
            }
        }
    }
    vis[u] = 0;
    return 0;
}

LL dinic() {
    LL maxflow = 0;
    path.clear();
    while(spfa()) {
        //cout << '!' << endl;
        path.push_back(dis[t]);
        memcpy(cur,head,sizeof(head));
        while(LL d = dfs(s,inf))
            maxflow += d;
    }
    return maxflow;
}

int main() {
    while(cin >> n >> m) {
        cnt = 0;
        s = 1, t = n;
        mincost = 0;
        memset(head, -1, sizeof(head));
        for ( int i  =  1; i <=  m; ++i ) {
            int a, b;
            int c;
            read(a); read(b);
            read(c);
            BuildGraph(a, b, 1, c);
        }
        dinic();
        int pathnum  =  path.size();
        //dbg(pathnum);
        for ( int i = 0; i <= pathnum - 1; ++i ) {
            sum[i + 1] = sum[i] + path[i];
        }
        int q;
        read(q);
        while(q--) {
            LL u, v, maxflow;
            read(u); read(v);
            maxflow = u * pathnum;
            //dbg(u);dbg(maxflow);
            // for ( int i   =   1; i <  =   cnt; ++i ) {
            //     printf("w: e[%d]:%lf\n",i,e[i].w);
            // }
            
            //dbg(a);dbg(b);
            // dbg(maxflow);
            // dbg(mincost);
            if(maxflow < v) {
                puts("NaN");
            }
            else {
                int a = v / u, b = v - u * a;
                mincost = sum[a] * u + path[a] * b;
                LL temp = __gcd(mincost, v);
                mincost /= temp, v /= temp;
                printf("%lld/%lld\n",mincost,v);
            }
        }
    }
    return 0;
}