最大流与费用流模板

用没有注释掉的 比注释掉的 快几十倍

template<typename T>
struct FlowGraph {
	int s, t, vtot;
	int h[V], idx;
	int d[V], cur[V];
	int e[E*2];
	int ne[E*2];
	int f[E*2];
	/*struct edge {
		int v, nxt;
		T f;
	} e[E * 2];
	void addedge(int u,int v, T f){
		e[etot]= {v, head[u], f}; head[u] = etot++;
		e[etot]= {u, head[v], 0}; head[v] = etot++;
	}*/
	void add(int a,int b,int c){
	e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
	e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
	}
   
	bool bfs() {
		for (int i = 1; i <= vtot; i++) {
			d[i] = 0;
			cur[i] = h[i];
		}
		queue<int> q;
		q.push(s); d[s] = 1;
		while (!q.empty()) {
			int u = q.front(); q.pop();
			for (int i =h[u]; ~i; i = ne[i]) {
				int v=e[i];
				if (f[i] && !d[v]) {
					d[v] = d[u] + 1;
					if (v == t) return true;
					q.push(v);
				}
			}
		}
		return false;
	}
/*
	T dfs(int u, T m) {
		if (u == t) return m;
		T flow = 0;
		for (int i = cur[u]; ~i; cur[u] = i = ne[i]){
			int v=e[i];
			if (f[i] && d[v] == d[u] + 1) {
				T t = dfs(v, min(m-flow, f[i]));
				if(!t)d[v]=-1;
				f[i] -= t;
				f[i ^ 1] += t;
				flow+=t;
			}
		}
		return flow;
	}*/
	T dfs(int u, T m) {
		if (u == t) return m;
		T flow = 0;
		for (int i = cur[u]; ~i; cur[u] = i = ne[i])
			if (f[i] && d[e[i]] == d[u] + 1) {
				T t = dfs(e[i], min(m, f[i]));
				f[i] -= t;
				f[i ^ 1] += t;
				m -= t;
				flow += t;
				if (!m) break;
			}
		if (!flow) d[u] = -1;
		return flow;
	}
	T dinic(){
		T flow=0;
		while (bfs()) flow += dfs(s, numeric_limits<T>::max());
		return flow;
	}
	void init(int s_, int t_, int vtot_) {
		s = s_;
		t = t_;
		vtot = vtot_;
		idx = 0;
		for (int i = 1; i <= vtot; i++) h[i] = -1;
	}
};

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

const int V = 20100;
const int E = 201000;

template<typename T>
struct MinCostGraph {
	int s, t, vtot;
	int h[V], idx;
	T d[V], flow, cost;
	int pre[V];
	bool vis[V];
	int f[E*2];
	int w[E*2];
	int e[E*2];
	int ne[E*2];
	/*	struct edge {
			int v, nxt;
			T f, c;
		} e[E * 2];
		/*void addedge(int u,int v, T f, T c, T f2 = 0) {
			e[etot]= {v, head[u], f, c};
			head[u] = etot++;
			e[etot]= {u, head[v], f2, -c};
			head[v] = etot++;
		}*/
	void add(int a, int b, int c, int d) {
		e[idx] = b, f[idx] = c, w[idx] = d, ne[idx] = h[a], h[a] = idx ++ ;
		e[idx] = a, f[idx] = 0, w[idx] = -d, ne[idx] = h[b], h[b] = idx ++ ;
	}

	bool spfa() {
		T inf = numeric_limits<T>::max() / 2;
		for (int i = 1; i <= vtot; i++) {
			d[i] = inf;
			vis[i] = false;
			pre[i] = -1;
		}
		d[s] = 0;
		vis[s] = true;
		queue<int> q;
		q.push(s);
		while (!q.empty()) {
			int u = q.front();
			q.pop();
			vis[u] = false;
			for(int i=h[u]; ~i; i=ne[i]) {
				int v = e[i];
				if (f[i] && d[v] > d[u] + w[i]) {
					d[v] = d[u] + w[i];
					pre[v] = i;
					if (!vis[v]) {
						vis[v] = 1;
						q.push(v);
					}
				}
			}
		}
		return d[t] != inf;
	}

	void augment() {
		int u = t;
		T q = numeric_limits<T>::max();
		while (~pre[u]) {
			q = min(q, f[pre[u]]);
			u = e[pre[u] ^ 1];
		}
		flow += q;
		cost += q * d[t];
		u = t;
		while (~pre[u]) {
			f[pre[u]] -= q;
			f[pre[u] ^ 1] += q;
			u = e[pre[u] ^ 1];
		}
	}

	pair<T, T> solve() {
		flow = 0;
		cost = 0;
		while (spfa()) augment();
		return {flow, cost};
	}
	void init(int s_, int t_, int vtot_) {
		s = s_;
		t = t_;
		vtot = vtot_;
		idx = 0;
		for (int i = 1; i <= vtot; i++) h[i] = -1;
	}
};

MinCostGraph<int> g;
int n, m;
array<int, 3> e[E];
int main() {
	scanf("%d%d", &n, &m);
	g.init(1, n, n);
	for (int i = 1; i <= m; i++) {
		int u, v, f, c;
		scanf("%d%d%d%d", &u, &v, &f, &c);
		g.add(u, v, f, c);
	}
	auto [flow, cost] = g.solve();
	printf("%d %d\n", flow, cost);
}