[Lemon-commits] [lemon_svn] athos: r389 - in hugo/trunk/src: include work/athos
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:39:10 CET 2006
Author: athos
Date: Fri Apr 2 16:53:05 2004
New Revision: 389
Added:
hugo/trunk/src/work/athos/graph_wrapper.h
- copied, changed from r387, /hugo/trunk/src/work/marci/graph_wrapper.h
hugo/trunk/src/work/athos/suurballe.cc
hugo/trunk/src/work/athos/suurballe.h
Modified:
hugo/trunk/src/include/dijkstra.h
Log:
suurballe fordulo es segfaultolo(!) valtozata
Modified: hugo/trunk/src/include/dijkstra.h
==============================================================================
--- hugo/trunk/src/include/dijkstra.h (original)
+++ hugo/trunk/src/include/dijkstra.h Fri Apr 2 16:53:05 2004
@@ -205,7 +205,8 @@
heap.pop();
distance.set(v, oldvalue);
- for(OutEdgeIt e(G,v); G.valid(e); G.next(e)) {
+ for(OutEdgeIt e = G.template first<OutEdgeIt>(v);
+ G.valid(e); G.next(e)) {
Node w=G.head(e);
switch(heap.state(w)) {
Copied: hugo/trunk/src/work/athos/graph_wrapper.h (from r387, /hugo/trunk/src/work/marci/graph_wrapper.h)
==============================================================================
--- /hugo/trunk/src/work/marci/graph_wrapper.h (original)
+++ hugo/trunk/src/work/athos/graph_wrapper.h Fri Apr 2 16:53:05 2004
@@ -950,6 +950,9 @@
GraphWrapper::OutEdgeIt OldOutEdgeIt;
typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
GraphWrapper::InEdgeIt OldInEdgeIt;
+
+ typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
+ GraphWrapper::Edge OldEdge;
protected:
//const Graph* graph;
//GraphWrapper gw;
@@ -992,7 +995,13 @@
return (!u.out_or_in || u.out!=v.out);
else
return (u.out_or_in || u.in!=v.in);
- }
+ }
+ operator OldEdge() {
+ if(out_or_in)
+ return out;
+ else
+ return in;
+ }
};
@@ -1208,11 +1217,11 @@
}
Number resCap(OldOutEdgeIt out) const {
- return (capacity->get(out)-flow->get(out));
+ return ( (*capacity)[out] - (*flow)[out]);
}
Number resCap(OldInEdgeIt in) const {
- return (flow->get(in));
+ return ( (*flow)[in] );
}
// template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> {
Added: hugo/trunk/src/work/athos/suurballe.cc
==============================================================================
--- (empty file)
+++ hugo/trunk/src/work/athos/suurballe.cc Fri Apr 2 16:53:05 2004
@@ -0,0 +1,126 @@
+// -*- c++ -*-
+//#include <iostream>
+//#include <vector>
+//#include <string>
+
+#include <list_graph.h>
+#include <suurballe.h>
+
+using namespace hugo;
+
+
+int main()
+{
+
+
+ typedef ListGraph::Node Node;
+ typedef ListGraph::Edge Edge;
+
+ ListGraph graph;
+
+ /*
+ //Marci példája
+
+
+ NodeIt s=graph.addNode();
+ NodeIt v1=graph.addNode();
+ NodeIt v2=graph.addNode();
+ NodeIt v3=graph.addNode();
+ NodeIt v4=graph.addNode();
+ NodeIt t=graph.addNode();
+
+
+ EdgeIt s_v1=graph.addEdge(s, v1);
+ EdgeIt s_v2=graph.addEdge(s, v2);
+ EdgeIt v1_v2=graph.addEdge(v1, v2);
+ EdgeIt v2_v1=graph.addEdge(v2, v1);
+ EdgeIt v1_v3=graph.addEdge(v1, v3);
+ EdgeIt v3_v2=graph.addEdge(v3, v2);
+ EdgeIt v2_v4=graph.addEdge(v2, v4);
+ EdgeIt v4_v3=graph.addEdge(v4, v3);
+ EdgeIt v3_t=graph.addEdge(v3, t);
+ EdgeIt v4_t=graph.addEdge(v4, t);
+
+ ListGraph::EdgeMap<int> length(graph);
+
+ length.set(s_v1, 16);
+ length.set(s_v2, 13);
+ length.set(v1_v2, 10);
+ length.set(v2_v1, 4);
+ length.set(v1_v3, 12);
+ length.set(v3_v2, 9);
+ length.set(v2_v4, 14);
+ length.set(v4_v3, 7);
+ length.set(v3_t, 20);
+ length.set(v4_t, 4);
+ */
+
+
+ //Ahuja könyv példája
+
+ Node s=graph.addNode();
+ Node v2=graph.addNode();
+ Node v3=graph.addNode();
+ Node v4=graph.addNode();
+ Node v5=graph.addNode();
+ Node t=graph.addNode();
+
+ Edge s_v2=graph.addEdge(s, v2);
+ Edge s_v3=graph.addEdge(s, v3);
+ Edge v2_v4=graph.addEdge(v2, v4);
+ Edge v2_v5=graph.addEdge(v2, v5);
+ Edge v3_v5=graph.addEdge(v3, v5);
+ Edge v4_t=graph.addEdge(v4, t);
+ Edge v5_t=graph.addEdge(v5, t);
+
+ //Kis modositas
+ //edge_iterator v2_s=graph.add_edge(v2, s);
+
+ ListGraph::EdgeMap<int> length(graph);
+
+ length.set(s_v2, 10);
+ length.set(s_v3, 10);
+ length.set(v2_v4, 5);
+ length.set(v2_v5, 8);
+ length.set(v3_v5, 5);
+ length.set(v4_t, 8);
+ length.set(v5_t, 8);
+
+ //Kis modositas
+ //length.put(v2_s, 100);
+
+
+
+
+ /*Egyszerû példa
+ NodeIt s=flow_test.add_node();
+ NodeIt v1=flow_test.add_node();
+ NodeIt v2=flow_test.add_node();
+ NodeIt t=flow_test.add_node();
+
+ node_property_vector<list_graph, std::string> node_name(flow_test);
+ node_name.put(s, "s");
+ node_name.put(v1, "v1");
+ node_name.put(v2, "v2");
+ node_name.put(t, "t");
+
+ edge_iterator s_v1=flow_test.add_edge(s, v1);
+ edge_iterator v1_v2=flow_test.add_edge(v1, v2);
+ edge_iterator v2_t=flow_test.add_edge(v2, t);
+
+ edge_property_vector<list_graph, int> length(flow_test);
+
+ length.put(s_v1, 16);
+ length.put(v1_v2, 10);
+ length.put(v2_t, 4);
+ */
+
+ std::cout << "Suurballe algorithm test..." << std::endl;
+
+
+ int k=1;
+ Suurballe<ListGraph, int> surb_test(graph, length);
+ std::cout << surb_test.run(s,t,k)<<std::endl;
+
+ return 0;
+}
Added: hugo/trunk/src/work/athos/suurballe.h
==============================================================================
--- (empty file)
+++ hugo/trunk/src/work/athos/suurballe.h Fri Apr 2 16:53:05 2004
@@ -0,0 +1,133 @@
+// -*- c++ -*-
+#ifndef HUGO_SUURBALLE_H
+#define HUGO_SUURBALLE_H
+
+#include <iostream>
+#include <dijkstra.h>
+#include <graph_wrapper.h>
+namespace hugo {
+
+
+///\brief Implementation of Suurballe's algorithm
+///
+/// The class \ref hugo::Suurballe "Suurballe" implements
+/// Suurballe's algorithm which seeks for k edge-disjoint paths
+/// from a given source node to a given target node in an
+/// edge-weighted directed graph having minimal total cost.
+///
+///
+
+
+ template <typename Graph, typename T,
+ typename LengthMap=typename Graph::EdgeMap<T> >
+ class Suurballe {
+
+
+ //Writing maps
+ class ConstMap {
+ public :
+ typedef int ValueType;
+ int operator[](typename Graph::Edge e) const {
+ return 1;
+ }
+ };
+ /*
+ // template <typename Graph, typename T>
+ class ModLengthMap {
+ typedef typename Graph::EdgeMap<T> EdgeMap;
+ typedef typename Graph::NodeMap<T> NodeMap;
+
+ const EdgeMap &ol;
+ const NodeMap &pot;
+ public :
+ typedef typename EdgeMap::KeyType KeyType;
+ typedef typename EdgeMap::ValueType ValueType;
+
+ double operator[](typename Graph::EdgeIt e) const {
+ return 10;//ol.get(e)-pot.get(v)-pot.get(u);
+ }
+
+ ModLengthMap(const EdgeMap &o,
+ const NodeMap &p) :
+ ol(o), pot(p){};
+ };
+ */
+
+
+ typedef typename Graph::Node Node;
+ typedef typename Graph::NodeIt NodeIt;
+ typedef typename Graph::Edge Edge;
+ typedef typename Graph::OutEdgeIt OutEdgeIt;
+ typedef ResGraphWrapper< Graph,T,typename Graph::EdgeMap<int>, ConstMap > ResGraphType;
+
+ const Graph& G;
+ const LengthMap& length;
+
+
+ //auxiliary variables
+
+ typename Graph::EdgeMap<int> reversed;
+ typename Graph::NodeMap<T> dijkstra_dist;
+
+ public :
+
+
+ Suurballe(Graph& _G, LengthMap& _length) : G(_G),
+ length(_length), reversed(_G), dijkstra_dist(_G){ }
+
+ ///Runs Suurballe's algorithm
+ ///Returns true iff there are k edge-disjoint paths from s to t
+ bool run(Node s, Node t, int k) {
+
+ LengthMap mod_length_c = length;
+ ConstMap const1map;
+ //ResGraphWrapper< Graph,T,typename Graph::EdgeMap<int>, ConstMap>
+ ResGraphType res_graph(G, reversed, const1map);
+ //ModLengthMap modified_length(length, dijkstra_dist);
+ //Dijkstra<ResGraphType, ModLengthMap> dijkstra(res_graph, modified_length);
+ //ResGraphWrapper< Graph,T,typename Graph::EdgeMap<int>, ConstMap>
+ Dijkstra<ResGraphType, LengthMap> dijkstra(res_graph, mod_length_c);
+
+ for (int i=0; i<k; ++i){
+ dijkstra.run(s);
+ if (!dijkstra.reached(t)){
+ //There is no k path from s to t
+ return false;
+ };
+ {
+ //We have to copy the potential
+ typename ResGraphType::EdgeIt e;
+ for ( res_graph.first(e) ; res_graph.valid(e) ; res_graph.next(e) ) {
+ //dijkstra_dist[e] = dijkstra.distMap()[e];
+ mod_length_c[Edge(e)] = mod_length_c[Edge(e)] -
+ dijkstra.distMap()[res_graph.head(e)] +
+ dijkstra.distMap()[res_graph.tail(e)];
+ }
+ }
+
+ //Reversing the sortest path
+ Node n=t;
+ Edge e;
+ while (n!=s){
+ e=dijkstra.pred(n);
+ n=dijkstra.predNode(n);
+ reversed[e] = 1-reversed[e];
+ }
+
+
+ }
+ return true;
+ }
+
+
+
+
+
+ };//class Suurballe
+
+
+
+
+} //namespace hugo
+
+#endif //HUGO_SUURBALLE_H
More information about the Lemon-commits
mailing list