2020牛客多校第1场H-Minimum-cost Flow

---

解题思路：

---

首先我们要从费用流mcmf的算法入手：因为它每次增广是再费用增广路上跑的，根据贪心的思想费用小的路基本上能运多少就尽量运多少，所以我们可以假设初始的边容量是1，只跑一遍mcmf.记录一下每次增广路径的费用[因为费用和边的容量是没有什么关系的]

---

现在题目要在边容量是$\frac{u}{v}$的情况下运送1流量的物体的最小问题，那么我们可以将问题放大$v$倍，就是求在边容量是$u$的情况下，运送v的流量最小费用是多少，答案再除以v就好了

---

因为每条边的容量都是一样的所以每一条增广路径每条边都是漫满流。我们假设$v=a\ast u+b$说明前a条增广路径是跑满的，$a+1$条路径是跑了b流量的

---

#include <iostream>
#include <cstdio>
#include <stack>
#include <sstream>
#include <limits.h>
#include <vector>
#include <map>
#include <cstring>
#include <deque>
#include <cmath>
#include <iomanip>
#include <queue>
#include <algorithm>
#include <set>
#define mid ((l + r) >> 1) 
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define _for(i,a,b) for( int i = (a); i < (b); ++i)
#define _rep(i,a,b) for( int i = (a); i <= (b); ++i)
#define for_(i,a,b) for( int i = (a); i >= (b); -- i)
#define rep_(i,a,b) for( int i = (a); i > (b); -- i)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define hash Hash
#define next Next
#define pb push_back
#define f first
#define s second
using namespace std;
const int N = 3e5+10, mod = 1e9 + 9;
const long double eps = 1e-5;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
template<typename T> void read(T &x)
{
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) 
{
    read(first);
    read(args...);
}
const int MAXN = 5001;
const int MAXM = 50001;
int n, m, edge_sum = 1;
ll maxflow, mincost;
int dis[MAXN], head[MAXN], incf[MAXN], pre[MAXN];//dis表示最短路，incf表示当前增广路上最小流量，pre表示前驱
bool vis[MAXN];
struct Edge {
	int next, to, dis, flow;
}edge[MAXM << 1];
inline void addedge(int from, int to, int flow, int dis) {
	edge[++edge_sum].next = head[from];
	edge[edge_sum].to = to;
	edge[edge_sum].dis = dis;
	edge[edge_sum].flow = flow;
	head[from] = edge_sum;
}
inline bool spfa() {//关于SPFA，他诈尸了
	queue <int> q;
	memset(dis, 0x3f, sizeof(dis));
	memset(vis, 0, sizeof(vis));
	q.push(1);
	dis[1] = 0;
	vis[1] = 1;
	incf[1] = 1 << 30;
	while(!q.empty()) {
		int u = q.front();
		vis[u] = 0;
		q.pop();
		for(register int i = head[u]; i; i = edge[i].next) {
			if(!edge[i].flow) continue;//没有剩余流量
			int v = edge[i].to;
			if(dis[v] > dis[u] + edge[i].dis) {
				dis[v] = dis[u] + edge[i].dis;
				incf[v] = min(incf[u], edge[i].flow);//更新incf
				pre[v] = i;
				if(!vis[v]) vis[v] = 1, q.push(v);
			}
		}
	}
	if(dis[n] == 1061109567) return 0;
	return 1;
}
vector<ll> res;
inline void MCMF() {
	while(spfa()) {//如果有增广路
		int x = n;
		maxflow += incf[n];
		mincost += dis[n] * incf[n];
		res.pb(dis[n]);
		int i;
		while(x != 1) {//遍历这条增广路，正向边减流反向边加流
			i = pre[x];
			edge[i].flow -= incf[n];
			edge[i^1].flow += incf[n];
			x = edge[i^1].to;
		}
	}
}

inline void init()
{
    res.clear();
    ms(pre,0);
    ms(incf,INF);
    ms(head,0);
    edge_sum = 1;
    maxflow = mincost = 0;
}

int main()
{
   while(scanf("%d%d",&n,&m)!=EOF)
   {
       init();
       while(m --)
       {
           int l, r, c;
           read(l,r,c);
          addedge(l,r,1,c);
          addedge(r,l,0,-c);
       }
       int q;
       scanf("%d",&q);
       MCMF();
       while(q --)
       {
           int u, v;
           scanf("%d%d",&u,&v);
           if(maxflow * u < v) printf("NaN\n");
           else
           {
              ll ans = 0;
              ll tmp = v;
              for(auto it : res)
                  if(v > u)
                  {
                      v -= u;
                      ans += u * it;
                  }
                  else
                  {
                      ans += v * it;
                      break;
                  }
              ll G = __gcd(ans,tmp);
              printf("%lld/%lld\n",ans/G,tmp/G);
           }
       }
   }
   return 0;
}