2020牛客多校（第一场）- H.Minimum-cost Flow

大致题意：

给定 $n$ 个点 $m$ 条边的网络，每条边给出单位流量的花费，现在有 $q$ 次询问，每次给出 $u,v$ 表示把所有边的容量设定为 $\frac{u}{v}$ ，问能否从点 $1$ 到 $n$ 流过 一单位流量，可以的话给出最小花费；
$2\le n\le 50$
$1\le m\le 100$
$1\le a_i,b_i\le n$
$1\le c_i\le 10^5$
$1\le q\le 10^5$
$0\le u_i\le v_i\le 10^9,v_i>0$

分析：

比较明显，是费用流，暴力些就是每次询问都根据容量重新构造边，然后跑一遍费用流，但肯定会 $T$ ；可以把容量设置为 $1$ 跑一遍费用流，那每次求出一条增广路径 即 最终流量 $+1$ ；所以有多少条增广路径，即最终流量为多少，把它们的花费从小到大排序，这样询问中就可以按照给出容量置换比例求了；

代码：

#include
#include
#include
#include 
#define ll long long
#define rg register
#define I inline
using namespace std;

I ll rd(){
    ll x=0,f=0; char c=getchar();
    while(c<'0'||c>'9'){f|=c=='-';c=getchar();}
    while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+(c-48);c=getchar();}
    return f?-x:x;
}

ll gcd(ll a,ll b){
	if(a==0) return b;
	if(b%a==0) return a;
	return gcd(b%a,a);
}

const int N = 100+10;
const int M = 1000+10;
const ll INF = 1E18;
#define P pair 

ll lnk[N],ter[M],nxt[M],cap[M],cost[M],tot=1,cpy[M];
ll n,m,cur[N],dis[N];
bool vis[N];

I void add(int u,int v,ll w,ll c){
    ter[++tot] = v,
      nxt[tot] = lnk[u],
      cap[tot] = w, 
     cost[tot] = c,
	    lnk[u] = tot;
}
I void addedge(int u,int v,ll w,ll c){   
    add(u,v,w, c), 
    add(v,u,0,-c);
}

ll q[M],ANS,RET,S,T;

I bool spfa(){
	for(rg int i=0;i<=T;i++) dis[i]=INF,vis[i]=0;
  
    int l=0,r=0;q[0]=S;
    dis[S]=0,vis[S]=1;
    
    while(l<=r)
	{
        int u=q[l++]; vis[u]=0;
        for (rg int i=lnk[u];i;i=nxt[i]){
            int v=ter[i];
            if(cap[i]&&dis[v]>dis[u]+cost[i])
			{
                dis[v]=dis[u]+cost[i];
                if(!vis[v]) q[++r]=v,vis[v]=1;
            }
        }
    }
    return dis[T]<INF;
}

ll dfs(int u,ll flow){
    if(u==T)
    {
	    return flow; 
    }
    vis[u]=1;
    ll ans=0;
    for(rg ll &i=cur[u];i;i=nxt[i])
	{
        int v=ter[i]; if(vis[v]) continue;
        if(cap[i]&&dis[v]==dis[u]+cost[i]){
            ll x=dfs(v,min(cap[i],flow));
            ans+=x,cap[i^1]+=x,cap[i]-=x,flow-=x;
            if(!flow) break;
        }
    }
    vis[u]=0;
    return ans;
}

vector<ll>VT; 

void mcmf(){
	
    while(spfa()){
        for(rg int i=0;i<=T;i++) cur[i]=lnk[i];
        ll minF=dfs(S,INF);
        VT.push_back(minF*dis[T]);
    }
    //sort(VT.begin(),VT.end());
    //其实不用排序，因为增广路径的寻找本来就是按照花费从小到大的
}

void init()
{
	tot=1;
	memset(lnk,0,sizeof(lnk));
}

int main()
{
    while(~scanf("%d",&n))
    {
    	m=rd();
    	init();
    	for(int i=1;i<=m;i++)
		{
            int a=rd(),b=rd(),c=rd();
            addedge(a,b,1,c);
        }
        
        S=1,T=n;
        VT.clear(); 
        mcmf();
    
	    ll len=VT.size();
        vector<ll>pre;
        pre.resize(len); pre[0]=VT[0];
        for(int i=1;i<len;i++) pre[i]=pre[i-1]+VT[i];
        
        int qq=rd();
        while(qq--)
        {
        	ll u=rd(),v=rd();
            if(u*len<v){
            	printf("NaN\n");
            	continue;
			}
			
            ll need = v/u;
            
            ll ans=0; 
			if(need) ans=pre[need-1]*u;    
            if(v%u) ans+=(v%u)*VT[need];
            
        	printf("%lld/%lld\n",ans/gcd(ans,v),v/gcd(ans,v));
		}
    }
}