COIN-OR::LEMON - Graph Library

source: lemon-0.x/test/preflow_test.cc @ 2260:4274224f8a7d

Last change on this file since 2260:4274224f8a7d was 2260:4274224f8a7d, checked in by Alpar Juttner, 13 years ago

concept -> concepts (namespace & directory)

  • Property exe set to *
File size: 4.9 KB
Line 
1/* -*- C++ -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library
4 *
5 * Copyright (C) 2003-2006
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
12 *
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
15 * purpose.
16 *
17 */
18
19#include <fstream>
20#include <string>
21
22#include "test_tools.h"
23#include <lemon/smart_graph.h>
24#include <lemon/dimacs.h>
25#include <lemon/preflow.h>
26#include <lemon/concepts/graph.h>
27#include <lemon/concepts/maps.h>
28
29using namespace lemon;
30
31void check_Preflow()
32{
33  typedef int VType;
34  typedef concepts::Graph Graph;
35
36  typedef Graph::Node Node;
37  typedef Graph::Edge Edge;
38  typedef concepts::ReadMap<Edge,VType> CapMap;
39  typedef concepts::ReadWriteMap<Edge,VType> FlowMap;
40  typedef concepts::ReadWriteMap<Node,bool> CutMap;
41 
42  typedef Preflow<Graph, int, CapMap, FlowMap> PType;
43
44  Graph g;
45  Node n;
46  CapMap cap;
47  FlowMap flow;
48  CutMap cut;
49
50  PType preflow_test(g,n,n,cap,flow);
51
52  preflow_test.run();
53  preflow_test.flowValue();
54  preflow_test.source(n);
55  preflow_test.flowMap(flow);
56
57  preflow_test.phase1(PType::NO_FLOW);
58  preflow_test.minCut(cut);
59
60  preflow_test.phase2();
61  preflow_test.target(n);
62  preflow_test.capacityMap(cap);
63  preflow_test.minMinCut(cut);
64  preflow_test.maxMinCut(cut);
65}
66
67int cut_value ( SmartGraph& g, SmartGraph::NodeMap<bool>& cut,
68                SmartGraph::EdgeMap<int>& cap) {
69 
70  int c=0;
71  for(SmartGraph::EdgeIt e(g); e!=INVALID; ++e) {
72    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
73  }
74  return c;
75}
76
77int main() {
78
79  typedef SmartGraph Graph;
80 
81  typedef Graph::Node Node;
82  typedef Graph::NodeIt NodeIt;
83  typedef Graph::EdgeIt EdgeIt;
84  typedef Graph::EdgeMap<int> CapMap;
85  typedef Graph::EdgeMap<int> FlowMap;
86  typedef Graph::NodeMap<bool> CutMap;
87
88  typedef Preflow<Graph, int> PType;
89
90  std::string f_name;
91  if( getenv("srcdir") )
92    f_name = std::string(getenv("srcdir"));
93  else f_name = ".";
94  f_name += "/test/preflow_graph.dim";
95 
96  std::ifstream file(f_name.c_str());
97 
98  check(file, "Input file '" << f_name << "' not found.");
99 
100  Graph g;
101  Node s, t;
102  CapMap cap(g);
103  readDimacs(file, g, cap, s, t);
104
105  FlowMap flow(g,0);
106
107 
108
109  PType preflow_test(g, s, t, cap, flow);
110  preflow_test.run(PType::ZERO_FLOW);
111   
112  CutMap min_cut(g,false);
113  preflow_test.minCut(min_cut);
114  int min_cut_value=cut_value(g,min_cut,cap);
115   
116  CutMap min_min_cut(g,false);
117  preflow_test.minMinCut(min_min_cut);
118  int min_min_cut_value=cut_value(g,min_min_cut,cap);
119   
120  CutMap max_min_cut(g,false);
121  preflow_test.maxMinCut(max_min_cut);
122  int max_min_cut_value=cut_value(g,max_min_cut,cap);
123
124  check(preflow_test.flowValue() == min_cut_value &&
125        min_cut_value == min_min_cut_value &&
126        min_min_cut_value == max_min_cut_value,
127        "The max flow value is not equal to the three min cut values.");
128
129  int flow_value=preflow_test.flowValue();
130
131
132
133  for(EdgeIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
134  preflow_test.capacityMap(cap); 
135
136  preflow_test.phase1(PType::PRE_FLOW);
137
138  CutMap min_cut1(g,false);
139  preflow_test.minCut(min_cut1);
140  min_cut_value=cut_value(g,min_cut1,cap);
141   
142  check(preflow_test.flowValue() == min_cut_value &&
143        min_cut_value == 2*flow_value,
144        "The max flow value or the min cut value is wrong.");
145
146  preflow_test.phase2();
147
148  CutMap min_cut2(g,false);
149  preflow_test.minCut(min_cut2);
150  min_cut_value=cut_value(g,min_cut2,cap);
151   
152  CutMap min_min_cut2(g,false);
153  preflow_test.minMinCut(min_min_cut2);
154  min_min_cut_value=cut_value(g,min_min_cut2,cap);
155 
156  preflow_test.maxMinCut(max_min_cut);
157  max_min_cut_value=cut_value(g,max_min_cut,cap);
158
159  check(preflow_test.flowValue() == min_cut_value &&
160        min_cut_value == min_min_cut_value &&
161        min_min_cut_value == max_min_cut_value &&
162        min_cut_value == 2*flow_value,
163        "The max flow value or the three min cut values were not doubled");
164
165
166
167  EdgeIt e(g);
168  for( int i=1; i==10; ++i ) {
169    flow.set(e,0);
170    ++e;
171  }
172
173  preflow_test.flowMap(flow);
174
175  NodeIt tmp1(g,s);
176  ++tmp1;
177  if ( tmp1 != INVALID ) s=tmp1;
178
179  NodeIt tmp2(g,t);
180  ++tmp2;
181  if ( tmp2 != INVALID ) t=tmp2;
182
183  preflow_test.source(s);
184  preflow_test.target(t);
185 
186  preflow_test.run();
187
188  CutMap min_cut3(g,false);
189  preflow_test.minCut(min_cut3);
190  min_cut_value=cut_value(g,min_cut3,cap);
191   
192  CutMap min_min_cut3(g,false);
193  preflow_test.minMinCut(min_min_cut3);
194  min_min_cut_value=cut_value(g,min_min_cut3,cap);
195   
196  preflow_test.maxMinCut(max_min_cut);
197  max_min_cut_value=cut_value(g,max_min_cut,cap);
198
199  check(preflow_test.flowValue() == min_cut_value &&
200        min_cut_value == min_min_cut_value &&
201        min_min_cut_value == max_min_cut_value,
202        "The max flow value or the three min cut values are incorrect.");
203}
Note: See TracBrowser for help on using the repository browser.