use umap_WT

Author: lxylxy123456

BellmanFord.cpp

@@ -61,8 +61,7 @@ void InitializeSingleSource(GT& G, T s, umap<T, RelaxInfo<T, WT>>& inf) {
 }
 
 template <typename T, typename WT>
-void Relax(T u, T v, umap<Edge<T>, WT, EdgeHash<size_t>>& w, 
-			umap<T, RelaxInfo<T, WT>>& inf) {
+void Relax(T u, T v, umap_WT& w, umap<T, RelaxInfo<T, WT>>& inf) {
 	WT weight = w[Edge<T>(u, v, true)]; 
 	if (inf[v] > inf[u] + weight) {
 		inf[v].set_d(inf[u] + weight); 
@@ -71,8 +70,7 @@ void Relax(T u, T v, umap<Edge<T>, WT, EdgeHash<size_t>>& w,
 }
 
 template <typename GT, typename T, typename WT>
-bool BellmanFord(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& w, T s, 
-				umap<T, RelaxInfo<T, WT>>& ans) {
+bool BellmanFord(GT& G, umap_WT& w, T s, umap<T, RelaxInfo<T, WT>>& ans) {
 	InitializeSingleSource(G, s, ans); 
 	for (size_t i = 0; i < G.V.size() - 1; i++)
 		for (auto j = G.all_edges(); !j.end(); j++)

DagShortestPaths.cpp

@@ -31,8 +31,7 @@
 #include "BellmanFord.cpp"
 
 template <typename GT, typename T, typename WT>
-void DagShortestPaths(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& w, T s, 
-				umap<T, RelaxInfo<T, WT>>& ans) {
+void DagShortestPaths(GT& G, umap_WT& w, T s, umap<T, RelaxInfo<T, WT>>& ans) {
 	std::deque<T> order; 
 	TopologicalSort(G, order); 
 	InitializeSingleSource(G, s, ans); 

Dijkstra.cpp

@@ -30,8 +30,7 @@
 #include "BellmanFord.cpp"
 
 template <typename GT, typename T, typename WT>
-void Dijkstra(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& w, T s, 
-				umap<T, RelaxInfo<T, WT>>& ans) {
+void Dijkstra(GT& G, umap_WT& w, T s, umap<T, RelaxInfo<T, WT>>& ans) {
 	using QT = std::pair<RelaxInfo<T, WT>, T>; 
 	InitializeSingleSource(G, s, ans); 
 	uset<T> S; 

FordFulkerson.cpp

@@ -29,8 +29,7 @@
 #include "BFS.cpp"
 
 template <typename GT, typename T, typename WT>
-void FordFulkerson(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& c, 
-					T s, T t, umap<Edge<T>, WT, EdgeHash<size_t>>& f) {
+void FordFulkerson(GT& G, umap_WT& c, T s, T t, umap_WT& f) {
 	for (auto i = G.all_edges(); !i.end(); i++)
 		f[*i] = 0; 
 	auto get_c = [&G, &c, &f](T u, T v) mutable -> WT {

Graph.cpp

@@ -33,6 +33,7 @@
 
 #define uset typename std::unordered_set
 #define umap typename std::unordered_map
+#define umap_WT typename std::unordered_map<Edge<T>, WT, EdgeHash<T>>
 
 template <typename T>
 class Edge {
@@ -496,7 +497,7 @@ void random_dag(Graph<T>& G, T v, size_t e) {
 }
 
 template <typename WT, typename T, typename GT>
-void random_weight(GT& G, umap<Edge<T>, WT, EdgeHash<T>>& w, WT l, WT u) {
+void random_weight(GT& G, umap_WT& w, WT l, WT u) {
     std::random_device rd; 
     std::uniform_int_distribution<T> d(l, u); 
 	for (auto i = G.all_edges(); !i.end(); i++)

Johnson.cpp

@@ -30,12 +30,12 @@
 #include "Dijkstra.cpp"
 
 template <typename GT, typename T, typename WT>
-Matrix<Weight<WT>> Johnson(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& w) {
+Matrix<Weight<WT>> Johnson(GT& G, umap_WT& w) {
 	static_assert(std::is_same<T, size_t>::value, "Only supports T = size_t"); 
 	const size_t n = G.V.size(); 
 	T s; 
 	GT G_prime = G; 
-	umap<Edge<T>, WT, EdgeHash<size_t>> w_prime = w; 
+	umap_WT w_prime = w; 
 	for (s = n; G.V.find(s) != G.V.end(); s++); 
 	for (auto i = G.V.begin(); i != G.V.end(); i++) {
 		G_prime.add_edge(s, *i); 
@@ -49,7 +49,7 @@ Matrix<Weight<WT>> Johnson(GT& G, umap<Edge<T>, WT, EdgeHash<size_t>>& w) {
 		assert(!BF_ans[v].d.inf); 
 		h[v] = BF_ans[v].d.val; 
 	}
-	umap<Edge<T>, WT, EdgeHash<size_t>> w_hat; 
+	umap_WT w_hat; 
 	for (auto i = G.all_edges(); !i.end(); i++)
 		w_hat[*i] = w[*i] + h[i.s()] - h[i.d()]; 
 	Matrix<Weight<WT>> D(n, n, WT());