Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Minimum Cost Flow

Find the minimum cost to send a certain amount of flow through a flow network.

The flow network is a directed graph where each edge $e$ has capacity $c(e)$ and cost $d(e)$. Each edge $e$ can send an amount of flow $f(e)$ where $f(e) \leq c(e)$. Find the minimum value of $\sum_{e} (f(e) \times d(e))$ to send an amount of flow $F$ from source $s$ to sink $t$.

Input

A flow network $G(V,E)$ is given in the following format.

$|V|\;|E|\;F$

$u_0\;v_0\;c_0\;d_0$

$u_1\;v_1\;c_1\;d_1$

:

$u_{|E|1}\;v_{|E|-1}\;c_{|E|-1}\;d_{|E|-1}$

$|V|$, $|E|$, $F$ are the number of vertices, the number of edges, and the amount of flow of the flow network respectively. The vertices in $G$ are named with the numbers $0, 1,..., |V|−1$. The source is $0$ and the sink is $|V|−1$.

$u_i$, $v_i$, $c_i$, $d_i$ represent $i$-th edge of the flow network. A pair of $u_i$ and $v_i$ denotes that there is an edge from $u_i$ to $v_i$, and $c_i$ and $d_i$ are the capacity and the cost of $i$-th edge respectively.

Output

Print the minimum value in a line. If it is impossible to send the flow from the source $s$ to the sink $t$, print -1.

Constraints

2 ≤ $|V|$ ≤ 100

1 ≤ $|E|$ ≤ 1000

0 ≤ $F$ ≤ 1000

0 ≤ $c_i$, $d_i$ ≤ 1000

$u_i$ $\ne$ $v_i$

If there is an edge from vertex $x$ to vertex $y$, there is no edge from vertex $y$ to vertex $x$.

Sample Input

4 5 2
0 1 2 1
0 2 1 2
1 2 1 1
1 3 1 3
2 3 2 1

Sample Output

6

Solution in Rust (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(non_snake_case, unused)]

use std::cmp::*;
use std::collections::*;
use std::ops::*;

// https://atcoder.jp/contests/hokudai-hitachi2019-1/submissions/10518254

macro_rules! eprint {
	($($t:tt)*) => {{
		use ::std::io::Write;
		let _ = write!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! eprintln {
	() => { eprintln!(""); };
	($($t:tt)*) => {{
		use ::std::io::Write;
		let _ = writeln!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! dbg {
	($v:expr) => {{
		let val = $v;
		eprintln!("[{}:{}] {} = {:?}", file!(), line!(), stringify!($v), val);
		val
	}}
}

macro_rules! mat {
	($($e:expr),*) => { Vec::from(vec![$($e),*]) };
	($($e:expr,)*) => { Vec::from(vec![$($e),*]) };
	($e:expr; $d:expr) => { Vec::from(vec![$e; $d]) };
	($e:expr; $d:expr $(; $ds:expr)+) => { Vec::from(vec![mat![$e $(; $ds)*]; $d]) };
}

macro_rules! ok {
	($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => {
		$a$([$i])*.$f($($t),*)
	};
	($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { {
		let t = $e;
		ok!($a$([$i])*.$f($($es),*)$(@$t)*@t)
	} };
}

pub fn readln() -> String {
	let mut line = String::new();
	::std::io::stdin().read_line(&mut line).unwrap_or_else(|e| panic!("{}", e));
	line
}

macro_rules! read {
	($($t:tt),*; $n:expr) => {{
		let stdin = ::std::io::stdin();
		let ret = ::std::io::BufRead::lines(stdin.lock()).take($n).map(|line| {
			let line = line.unwrap();
			let mut it = line.split_whitespace();
			_read!(it; $($t),*)
		}).collect::<Vec<_>>();
		ret
	}};
	($($t:tt),*) => {{
		let line = readln();
		let mut it = line.split_whitespace();
		_read!(it; $($t),*)
	}};
}

macro_rules! _read {
	($it:ident; [char]) => {
		_read!($it; String).chars().collect::<Vec<_>>()
	};
	($it:ident; [u8]) => {
		Vec::from(_read!($it; String).into_bytes())
	};
	($it:ident; usize1) => {
		$it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1
	};
	($it:ident; [usize1]) => {
		$it.map(|s| s.parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1).collect::<Vec<_>>()
	};
	($it:ident; [$t:ty]) => {
		$it.map(|s| s.parse::<$t>().unwrap_or_else(|e| panic!("{}", e))).collect::<Vec<_>>()
	};
	($it:ident; $t:ty) => {
		$it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<$t>().unwrap_or_else(|e| panic!("{}", e))
	};
	($it:ident; $($t:tt),+) => {
		($(_read!($it; $t)),*)
	};
}


pub fn main() {
	let _ = ::std::thread::Builder::new().name("run".to_string()).stack_size(32 * 1024 * 1024).spawn(run).unwrap().join();
}

const MOD: u32 = 1_000_000_007;
const INF: i64 = std::i64::MAX/3;

#[derive(Copy,Clone)]
struct Edge {
	to: usize,
	cap: i64,
	cost: i64,
	rev: usize,
}

struct MinCostFlow {
	edge: Vec<Vec<Edge>>,
	n: usize,
}

impl MinCostFlow {
	pub fn new(n: usize) -> Self {
		MinCostFlow {
			edge: vec![vec![];n],
			n: n,
		}
	}

	pub fn add_edge(&mut self, s: usize, t: usize, cap: i64, cost: i64) {
		let mut tmp = self.edge[t].len();
		self.edge[s].push(Edge{to: t, cap: cap, cost: cost, rev: tmp});
		let mut tmp = self.edge[s].len();
		self.edge[t].push(Edge{to: s, cap: 0, cost: -cost, rev: tmp-1});
	}

	pub fn add_multi_edge(&mut self, s: usize, t: usize, cap: i64, cost: i64) {
		let mut tmp = self.edge[t].len();
		self.edge[s].push(Edge{to: t, cap: cap, cost: cost, rev: tmp});
		let mut tmp = self.edge[s].len();
		self.edge[t].push(Edge{to: s, cap: cap, cost: -cost, rev: tmp-1});
	}

	pub fn calc(&mut self, s: usize, t: usize, flow: usize) -> i64{
		let mut res = flow;
		let mut cost = 0;
		for k in 0..flow {
			let mut dist = vec![INF;self.n];
			let mut prev = vec![self.n;self.n];
			dist[s] = 0;
			for x in 0..self.n{
				for i in 0..self.n {
					for &e in &self.edge[i] {
						if e.cap<=0 {
							continue;
						}
						let d = dist[i] + e.cost;
						if d < dist[e.to] {
							dist[e.to] = d;
							prev[e.to] = i;
						}
					}
				}
			}
			if dist[t]==INF {
				return INF;
			}
			let mut cur = t;
			let mut seen = vec![false;self.n];
			loop {
				seen[cur] = true;
				if cur==s {
					break;
				}
				for i in 0..self.edge[cur].len() {
					let e = self.edge[cur][i];
					if seen[e.to] {
						continue;
					}
					if e.to == prev[cur] {
						self.edge[cur][i].cap += 1;
						self.edge[e.to][e.rev].cap -= 1;
						cost += self.edge[e.to][e.rev].cost;
						cur = e.to;
						break;
					}
				}
			}
		}
		cost
	}

}

fn solve() {
	let (n,m,f) = read!(usize,usize,usize);
	let e = read!(usize,usize,i64,i64;m);
	let mut mcf = MinCostFlow::new(n);
	for (s,t,c,d) in e {
		mcf.add_edge(s,t,c,d);
	}
	let val = mcf.calc(0,n-1,f);
	if val==INF {
		println!("-1");
	}
	else{
		println!("{}",val);
	}
}

fn run() {
    solve();
}