Dat2a G2 Korteste vej med betingelser. Espen Højsgaard Rune Højsgaard Bo Bendtsen

Transkript

1 Dat2a G2 Korteste vej med betingelser Espen Højsgaard Rune Højsgaard Bo Bendtsen 1

2 Indhold Indhold 2 1 Sammenfatning 3 2 Opgave Opgave Opgave Opgave Opgave Opgave Litteratur 9 A Kildetekst 10 B Uddata - variabel λ 21 C Uddata - statisk beregnet λ 25 D Uddata - statisk λ =

3 1 Sammenfatning Dette er en besvarelse af den anden godkendelsesopgave på kurset Datalogi 2A 2003/2004, Københavns Universitet [1]. Læseren forventes at have læst opgaveformuleringen samt - som minimum - at have samme forudsætninger som en elev, der har fulgt kurset. Den praktiske del af opgaven - implementation af og eksperimenter med en branch & bound algoritme til løsning af begrænset korteste vej problemet - er løst. De instanser, som programmet kan løse på mindre end 5 min., findes der optimale løsninger til. Den teoretiske del er hovedsageligt løst. Vi har fundet en reduktion, der viser at SUBSET- SUM P BKV. Desuden har vi vist at L(λ) er en nedre grænseværdi for λ 0 og at L(λ) kan findes ved at løse et ubetinget korteste vej problem. Desværre er det ikke lykkedes os at finde en løsning for, hvorvidt man kan undgå en komplet ubetinget korteste vej beregning hver gang man ændrer λ. 3

4 2 Opgave 1 Afgørlighedsversionen af det betingede korteste vej problem er at afgøre hvorvidt en given graf har en vej fra s til t med en forsinkelse d og en vægt = k. Sproget for dette afgørlighedsproblem er BKV = { G, s, t, d, a, c, k : G = (V, E) er en orienteret graf, s, t V, a er en funktion fra V V R +, d R +, w er en funktion fra V V R +, k R +, G har en simpel vej fra s til t med forsinkelse på højest a og vægt k. For at bevise at det betingede korteste vej problem er NP-fuldstændig vil vi først vise at BKV hører til NP. Given en instans af problemet, kan vi bruge rækkefølgen af knuder i den simple vej som certifikat. Efterprøvningsalgoritmen undersøger at kanterne der følges kun er udgående kanter fra den knude man er nået til, at rækkefølgen højest indeholder hver knude én gang, samt om summen af forsinkelserne er højest d og vægten k. Dette kan åbenlyst gøres i polynomiel tid. For at vise at BKV er NP-hård viser vi at SUBSET-SUM P BKV. Lad S, t være en instans af SUBSET-SUM. Vi konstruerer en instans af BKV som følger; Vi initialiserer V = {v i, i {1,..., S + 1. Fra knude v i til v i+1 tilføjes to kanter. Den ene kant e i1 har vægt w(e i1 ) = s i og forsinkelsen a(e i1 ) = 0, mens den anden kant e i2 har vægt w(e i2 ) = 0 og forsinkelse a(e i2 ) = s i. e i1 svarer til at man tager tallet med i summen og den anden kant e i2 svarer til at man ikke tager tallet med i summen. Vi kan se at det er lovlig omformning da E = 2 S og V = 1 + S dvs. problemet kan omskrives i lineær tid og vokser også kun lineært. Vores graf bliver opbygget på en måde at summen af vægt og forsinkelse k + d altid vil være s S s lige meget hvilken vej man tager igennem grafen. Vi kan nu vise at der kun findes en delmængdesum på t hvis og kun hvis der findes en korteste vej med en vægten k = t og forsinkelsen d = ( s S s) t. Nu mangler vi at vise at en ja-instans i SUBSET-SUM S, t forbliver en ja-instans efter omformingen, og ditto for nej-instanser. SUBSET-SUM problemet har en delmængdesum t 4

5 hvis og kun hvis vores opbyggede BKV-graf har en korteste vej med vægt t og forsinkelsen ( s S s) t. Hvert par af kanter i G repræsentere et tal i S og værdierne k og d kan kun opfyldes hvis og kun hvis delmængden t findes i S. Så hvis en sti p kan opfylde kravene til vores BKV så kan p også bruges som et certifikat for vores originale SUBSET-SUM problem S. 3 Opgave 2 Vi betragter en mulig vej p til begrænset korteste vej problemet. For λ = 0 er L(λ) åbenlyst nedre grænseværdi for vægten af den begrænsede korteste vej, da den repræsenterer den billigste mulige vej ifht. vægt fra s til t. Da p er en mulig løsning er a(p) A 0 hvilket betyder at w(p) + λ(a(p) A) w(p) hvorfor L(λ) w(p). Altså er L(λ) en nedre grænse for p. Vi kan finde L(λ) ved at finde den ubetingede korteste vej i en graf der kombinere vægten w(e) og forsinkelsen a(e) til én omkostning w(e) + λa(e). Den korteste vej p fra s til t i denne graf har således omkostningen E p w(e)+ E p λa(e) = w(p )+λa(p ), hvorfra vi kan beregne L(λ) ved at subtrahere λa. 5

6 4 Opgave 3 Vores implementation af algoritmen er at finde i kildeteksten (bilag A) - funktionen hedder LofLambda. Vi vil ikke kommentere den yderligere her. For at maksimere L(λ) ved at ændre lambda vil vi benytte følgende strategi: Beregne værdien for λ = 0 og for λ =. Hvis p 0 = p vil vi benytte λ = 0. Ellers vil vi for hver vej p 0 og p beregne den lineære funktion der beskriver L(λ) for P = {p i, i {0,. Mindsteværdien af disse funktioner beskriver så L(λ) for P = {p 0, p : Vi vil efterfølgende finde vejen p i for L(λ) hvor λ = max λ (L(λ), P = {p 0, p ). Er p i P betragter vi den fundne λ som optimal. Er p i ikke i P tilføjes den og proceduren gentages indtil p i findes i P. Figuren viser et eksempel, hvor λ = q har samme vej, som λ = m, hvorfor L(q) betragtes som optimal.: Vi burde egentligt beregne max λ (L(λ), P = P ), men vi forventer at denne metode vil give et godt bud i langt de fleste tilfælde. Vores implementation af denne algoritmen er at finde i kildeteksten (bilag A) og hedder optimal_lambda. Den beregner ikke max(l(λ)), men max λ (L(λ)), der i kombination med lagbound kan approksimere max(l(λ)). 6

7 5 Opgave 4 Vi har overvejet følgende strategier for valg af kanten e = (s, v): Baseret på laveste/højeste vægt w(e) eller laveste/højeste forsinkelse a(e). Disse s- trategier afvejer dog ikke det modsatte komponents betydning, hvorfor vi ikke kan finde nogen fornuftig brug for dem. Baseret på mindste w(e) + λa(e). Denne strategi tilgodeser begge elementer, og vil derfor have en bedre chance for at finde gode øvre grænseværdier hurtigt. Baseret på vejen for L(λ). Her vil vi vælge den første kant i den vej som L(λ) benytter. Da vi i en sådan løsning vil beregne L(λ) for hvert valg, er det ikke nødvendigt med en sekundær strategi. Strategien er god, da den altid følger den vej der ser mest lovende ud for delproblemet. For strategi for valg af λ har vi gjort os følgende overvejelser: Samme λ i alle knuder i branch & bound træet, har den fordel at det ikke er nødvendigt at genudregne λ for hver knude, hvilket potentielt kan være meget dyrt. Omvendt vil det betyde, at delproblemer der ikke ligger på vejen p λ (langt de fleste), ikke umiddelbart vil kunne forkastes da deres grænseværdi nemt vil ligge under z, selv når delproblemet er håbløst. En grænseværdi af ovenstående er λ = 0. I dette tilfælde ignoreres omkostningen aldeles. Konsekvensen er den samme som ovenfor, at vi vil betragte en masse håbløse delproblemer (dem der har den bedst mulige vej). Basalt set finder metoden den bedste vej fra s til t, på next-to brute force metoden. Forskellig λ i alle knuder. Denne metode kan være dyr, da man bør foretage en komplet korteste vej beregning. Omvendt kan man hele tiden vælge den mest lovende vej for delproblemet, og på den måde opnå gode grænseværdier. Hvis man samtidig beregner et passende z til hvert delproblem, kan man meget præcist forkaste håbløse delproblemer. Vi har valgt strategien med variabel λ, beregnet med algoritmen beskrevet i kapitel 4. For delproblemer hvor kanten e vælges, sættes z delproblem til z w(e) - og hvis der findes en bedre z delproblem i delproblemet opdateres z når der returneres til z delproblem + w(e). Strategien forventes at finde en næsten optimal korteste vej hurtigt, men at være forholdsvis regnetung. Vores implementation af CSP_BRANCH er at finde i kildeteksten (bilag A). 7

8 6 Opgave 5 Den obligatoriske uddata fra kørslerne er at finde i bilag B (variabel λ), bilag C (λ fra rodknuden) og bilag D (λ = 0). Vores bedste løsning (λ fra rodknuden) finder den optimale løsning i alle tilfælde pånær av20.txt, av50.txt, eo50.txt, eo100.txt og eo200.txt, hvor den har opbrugt de fem minutter. Den er tæt efterfulgt af vores løsning med variabel λ i hver knude, der løser samme problemer, men ikke når nær så langt i de uløste. Forsøget med λ = 0 i alle knuder, finder som forventet færrest optimale løsninger inden for de fem minutter. Dens branch and bound træer er samtidig meget større end de andre løsningers, hvilket også er forventeligt for en brute force -lignende metode. Løsningen med variabel λ har, som nævnt, for de uløste grafer, fundet en vej der ligger meget tæt på løsningen med fast λ bestemt i rodknuden. Til gengæld har den for de store løsninger kun ca. 1 så mange knuder i sit branch-and-bound træ. Vi forventer derfor, at 2 den vil kunne slå løsningen med fast λ fra rodknuden, hvis vi blot kunne optimerer vores optimal_lambda funktion en lille smule, alternativt finde en anden indgangsvinkel til den. Det er værd at bemærke, at løsningen med variabel λ ikke har færrest knuder i alle tilfælde - for nogle af rcsp-graferne har løsningen med statisk λ fra rodknuden et væsentligt mindre træ. Vi kan ikke forklare dette. 7 Opgave 6 Kan vi undgå at udregne en ny ubetinget kortest vej hver gang vi ændrer λ? Det korte svar er: det ved vi ikke. Vi kan desværre ikke komme på andre måder, at beregne den maksimale grænseværdi på, end den vi har beskrevet i afsnit 4. 8

9 8 Litteratur [1] Martin Zachariasen. Korteste veje med betingelser. Dat2A godkendelsesopgave 2, april

10 A Kildetekst - // Fil : csp_bb.cc // // Beskrivelse : Indlæsning af probleminstanser i OR - library format // til det betingede korteste vej problem. Finder den // betingede korteste vej, vha. Fast lambda, lambda =0 // eller variabel lambda. Argumenter er at finde i // kommentarene til main () // // Forfatter : Rune Højsgaard, // Espen Højsgaard, // & Bo Bendtsen. // // Indlæsning fra read_csp. cc af Martin Zachariasen, DIKU - # include <math.h> # include <stdio.h> # include < fstream.h> # include <LEDA / array.h> # include <LEDA / graph.h> # include <LEDA / edge_array.h> # include <LEDA / shortest_path.h> # include <LEDA / line.h> # include <LEDA / list.h> # include <LEDA / point.h> - // Indlæs en probleminstans der foreligger i OR - Library format. // Disse instanser hedder *. txt, og benytter et enkelt filformat, // der dog indeholder informationer, som ikke skal benyttes i denne // opgave. Disse informationer bliver smidt væk. // Parametrene til denne procedure er følgende : // filnavn : Navn på probleminstans som skal indlæses ( f. eks. " rcsp1. txt ") // G: Graf hvori probleminstansen skal gemmes. // w: Kantvægte // a: Kantforsinkelser // A: Maksinal forsinkelse // Der skal findes en betinget vej fra den første knude i den oprettede // graf, G. first_node (), til den sidste knude, G. last_node (). - void read_csp ( const string & filnavn, graph & G, edge_array < double >& w, edge_array < double >& a, double & A) { ifstream libfile ( filnavn ); int i, j, node1, node2, number_of_nodes, number_of_edges, number_of_resources ; double dummy ; // Er filen blevet åbnet? if (! libfile ) { cerr << " Fejl : Kan ikke åbne filen med navn : " << filnavn << endl ; cerr << " Programmet afsluttes." << endl ; exit (1) ; // Indlæs antal knuder, kanter og antal resourcer libfile >> number_of_nodes >> number_of_edges >> number_of_resources ; // Opret knuder i graf 10

11 array <node > node_ar (1, number_of_nodes ); for ( i = 1; i <= number_of_nodes ; i ++) node_ar [i] = G. new_node (); // I denne opgave betragtes kun problemer med een betingelse if ( number_of_resources > 1) { cerr << " Fejl : Kan ikke håndtere mere end en betingelse.\ n" << endl ; cerr << " Programmet afsluttes." << endl ; exit (1) ; // Nedre grænse for betingelse ( ignoreres ) libfile >> dummy ; // Øvre grænse for betingelse libfile >> A; // Forsinkelse igennem knuder ( ignoreres ) for ( i = 1; i <= number_of_nodes ; i ++) libfile >> dummy ; // Vægt og forsinkelse igennem kanter array <edge > edge_ar (1, number_of_edges ); array < double > w_ar (1, number_of_edges ); array < double > a_ar (1, number_of_edges ); // Indlæs information og opret kanter for ( j = 1; j <= number_of_edges ; j ++) { libfile >> node1 >> node2 >> w_ar [ j] >> a_ar [ j]; edge_ar [j] = G. new_edge ( node_ar [ node1 ], node_ar [ node2 ] ); // Overfør vægte og forsinkelser til edge_arrays som returneres w = edge_array < double >(G); a = edge_array < double >(G); for ( j = 1; j <= number_of_edges ; j ++) { w[ edge_ar [j] ] = w_ar [j]; a[ edge_ar [j] ] = a_ar [j]; libfile. close (); // Spinner der viser programmet arbejder char * spinner = " / -\\ "; int spin = 0, delay = 0; # define SPINNER if (!(++ delay %64) ) cout << spinner [++ spin %4] << "\ e[ D" << flush // Genopretter en node " s" samt alle kanter i listen " restore ", såfremt // deres target / source ( altså modsat s =) ) ikke er skjult! void polite_restore_node ( graph & G, list <edge > & restore, node s) { // Initialiser variable edge k; // Genopretter selve noden G. restore_node (s); while (! restore. empty ()) { k = restore. pop (); // Genopret udgående kanter if (s == G. source (k) &&!G. is_hidden (G. target (k))) { 11

12 G. restore_edge (k); // Genopret indgående kanter if (s == G. target (k) &&!G. is_hidden (G. source (k))) { G. restore_edge (k); // Genopretter alle noder. Returnere en liste over genoprettede noder // så de kan gemmes igen. list <node > restore_hidden_nodes ( graph & G) { // initialiser variable list <node > hidden_nodes ; // Husk gemte noder hidden_nodes = G. hidden_nodes (); // Genopret noder G. restore_all_nodes (); // Returner listen, så de kan gemmes igen return hidden_nodes ; // Gemmer en liste af noder void hide_nodes ( graph & G, list <node > & hidden_nodes ) { // initialiser variable node u; // Gem noderne while (! hidden_nodes. empty ()) { u = hidden_nodes. pop (); G. hide_node (u); // Genopretter alle kanter. Returnere en liste over genoprettede kanter // så de kan gemmes igen. list <edge > restore_hidden_edges ( graph & G) { // initialiser variable list <edge > hidden_edges ; // Husk gemte kanter hidden_edges = G. hidden_edges (); // Genopret kanter G. restore_all_edges (); // Returner listen, så de kan gemmes igen return hidden_edges ; // Gemmer en liste af kanter void hide_edges ( graph & G, list <edge > & hidden_edges ) { // initialiser variable edge e; // Gem kanterne while (! hidden_edges. empty ()) { e = hidden_edges. pop (); G. hide_edge (e); 12

13 // Sammenligner to edge_array <bool > bool operator == ( const edge_array <bool > & a, const edge_array <bool > & b) { // Initialiser variable edge e; // Undersøg at a & b er for samme graf : if (& a. get_graph ()!= & b. get_graph ()) return false ; forall_edges (e, a. get_graph ()) { if ( a[ e]!= b[ e]) return false ; return true ; // Beregner omkostningen c for en given vej. double cost ( const graph & G, const edge_array < double > & c, const edge_array <bool > & path ){ // Initialisere variable double returnvalue = 0.0; edge e; // Beregn vægt og forsinkelses bidrag int i = 0; forall_edges (e, G) { if ( path [e]) { returnvalue += c[ e]; return returnvalue ; // Beregner L( lambda ) // // Hvis der ikke er fundet en vej, er der ingen true in_edges til t double LofLambda ( const graph & G, const node & s, const node & t, const edge_array < double > & w, const edge_array < double > & a, const double & lambda, const double & A, edge_array <bool > & p) { // Initialiser variable edge_array < double > nw(g); node_array <edge > path (G); edge e; node u; double returnvalue = - lambda * A; p. init (G, false ); // Beregn nye kantvægte forall_edges (e, G) { 13

14 nw[e] = w[e] + lambda *a[e]; // Find korteste vej fra s til t i den relakserede graf. DIJKSTRA_T (G, s, t, nw, path ); if (! path [ t]) return 0.0; // Beregn beregn a og w s bidrag, samt konverter til edge_array <bool > u = t; while (u!= s) { e = path [u]; p[e] = true ; returnvalue += w[ e] + lambda * a[ e]; u = G. opposite (e, u); return returnvalue ; // Finder den lambda, der giver den tætteste nedre grænse. // // Hvis der ikke er fundet en vej, er der ingen true in_edges til t // // p holder den funde vej double optimal_lambda2 ( const graph & G, const node & s, const node & t, const edge_array < double > & w, const edge_array < double > & a, const double & A, edge_array <bool > & p ) { // Initialiser variable node_array <edge > path (G); edge_array <bool > temp_p (G, false ); double lambda ; node u; edge e; double wp = 0.0; double ap = 0.0; p. init (G, false ); // Find vejen med mindste forsinkelse DIJKSTRA_T (G, s, t, a, path ); if (! path [ t]) return 0.0; // beregn a[ p] og w[ p] og konverter vejen til et edge_array <bool > u = t; while (u!= s) { e = path [u]; wp += w[e]; p[e] = true ; ap += a[e]; u = G. opposite (e, u); // Vælg første gæt lambda = -wp /(ap -A); for (;;) { // Beregn vejen for den nuværende lambda LofLambda (G, s, t, w, a, lambda, A, temp_p ); 14

15 if ( p == temp_p ) return lambda ; // Beregner den nye lambda lambda = cost (G, w, temp_p )/( cost (G, a, temp_p )-A); p = temp_p ; // Finder den linære funktion for når lambda varieres over en given vej. line linear_of_lambda ( graph & G, const edge_array < double > & w, const edge_array < double > & a, double A, const edge_array <bool > & path ) { // Initialisere variable double at_zero, at_five ; at_zero = at_five = 0.0; edge e; point p, q; // Beregner værdien af L (0) for vejen forall_edges (e, G) { if ( path [e]) { at_zero += w[ e]; p = point (0.0, at_zero ); // Beregner værdien af L (5) for vejen forall_edges (e, G) { if ( path [e]) { at_five += w[ e] + 5.0* a[ e]; at_five -= 5.0* A; q = point (5.0, at_five ); // Returner linien baseret på de to punkter return line (p, q); // Maximere L( lambda ) ved at maksimere over lambda mens der minimeres // over path. Returnerer den optimale lambda. Den optimale vej ( fra slut // til start ) findes i optimal_path. Er der ingen vej fra s til t er // der ingen indående kanter til t, der holder true. double optimal_lambda ( graph & G, node s, node t, const edge_array < double > & w, const edge_array < double > & a, const double A, edge_array <bool > & path_for_tightest_bound ) { // Initialiser variable edge e; bool add_point ; bool stop = true ; double best_lambda ; point p (0.0, 0.0), temp_p (0.0, 0.0), old_p (0.0, 0.0) ; line lowest, highest, new_line, temp_line, temp_line2 ; 15

16 list < point > lowest_intersections ; list < edge_array <bool > > S; list <line > all_lines ; list <node > hidden_nodes ; list <edge > hidden_edges ; edge_array <bool > path (G), path2 (G), temp_path (G), last_part (G); // Find vejen for laveste lambda (0) LofLambda (G, s, t, w, a, 0.0, A, path ); // Afbryd hvis der ikke er en vej fra s til t forall_in_edges (e, t) { if ( path [ e]) stop = false ; if ( stop ) { return 0.0; lowest = linear_of_lambda (G, w, a, A, path ); // tilføj vejen til S S. push ( path ); // Find vejen for den højeste lambda ( burde beregnes som " går mod i // uendelig ", men vi lader som om er uendelig ) LofLambda (G, s, t, w, a, , A, path2 ); highest = linear_of_lambda (G, w, a, A, path2 ); // tilføj vejen til S S. push ( path2 ); // Initialiser all_lines all_lines. push ( highest ); all_lines. push ( lowest ); // Initialiser lowest_intersections if ( lowest. intersection ( highest, p)) { lowest_intersections. push ( p); best_lambda = p. xcoord (); else { // Hvis L( lambda =0) = L( lambda - > uendelig ), så har vi allerede // løsningen. path_for_tightest_bound = S. pop (); best_lambda = 0.0; return best_lambda ; // S er nu initialiserete med en vej for laveste / højeste lambda. // Vi finder nu den optimale vej på følgende måde : // 1) beregn den bedste vej udfra bedste lambda // 2) Hvis vejen er i S er den optimal og der returneres ( optimal vej // gemt i path, lambda som returværdi ) // 3) Hvis vejen ikke er i S tilføjes den. // 4) beregn den nye optimale lambda og gentag proceduren. for (;;) { // Find vejen for best_lambda LofLambda (G, s, t, w, a, best_lambda, A, path_for_tightest_bound ); // undersøg om vejen allerede er undersøgt forall ( temp_path, S){ if ( temp_path == path_for_tightest_bound ) { // I så fald returneres der. return best_lambda ; // Indsæt vejen i S S. push ( path_for_tightest_bound ); // beregn linien new_line = linear_of_lambda (G, w, a, A, path_for_tightest_bound ); 16

17 // Beregn nye laveste skæringspunkter forall ( temp_line, all_lines ) { add_point = true ; // se om linierne skærer if ( new_line. intersection ( temp_line, p)) { // // Hvis punktet har en x- værid ( altså lambda ) >= 0: if (p. xcoord () >= 0.0) { // Undersøg om der er nogle linier under skæringspunktet forall ( temp_line2, all_lines ) { if (( int ) (p. ycoord () *100000) > ( int )( temp_line2. y_proj ( p. xcoord ()) *100000) ) { add_point = false ; // Tilføj evt. punktet til de laveste krydsninger if ( add_point ) { lowest_intersections. push ( p); // indsætter linie i listen all_lines. push ( new_line ); // Fjern alle laveste punkter der ligger over denne forall (p, lowest_intersections ){ if (p. ycoord () > new_line. y_proj (p. xcoord ())){ lowest_intersections. remove ( p); // Sætter nye bedste lambda : temp_p = lowest_intersections. pop (); old_p = temp_p ; forall (p, lowest_intersections ) { if (p. ycoord () > temp_p. ycoord ()) { temp_p = p; lowest_intersections. push ( old_p ); best_lambda = temp_p. xcoord (); - // Finder den første kant ( fra s til næste node ) udfra en bolsk representation // af grafen - void first_edge ( graph & G, node & s, node & next_node, edge & the_edge, edge_array <bool > & path ){ // initialiser variable edge e; forall_out_edges (e, s) { if ( path [e]) { the_edge = e; next_node = G. opposite (e, s); return ; 17

18 // Globale variable double z = 0.0; double lambda = 0.0; edge_array <bool > best_path ; edge_array <bool > path_so_far ; double knude = 0.0; bool recalculate = false ; - // Selve B& B algorytmen der find den optimale vej gennem grafen! Nemlig =) - void csp_branch ( graph & G, node s, node t, edge_array < double > & w, edge_array < double > & a, double A) { // Initialiser variable edge_array <bool > p; list <edge > inout_edges ; list <edge > hidden_edges ; list <node > hidden_nodes ; edge e, chosen_edge ; node v; double l; bool stop = true ; knude ++; static bool timeout = false ; SPINNER ; if ( recalculate ) lambda = optimal_lambda (G, s, t, w, a, A, p); if( used_time () > 300) { timeout = true ; return ; // Finder grænseværdi og tilhærende sti l = LofLambda (G, s, t, w, a, lambda, A, p); // Afbryd, hvis der ingen vej er fra s til t forall_in_edges (e, t) { if (p[e]) { stop = false ; if ( stop ) return ; // Genopretter noder og kanter hidden_nodes = restore_hidden_nodes ( G); hidden_edges = restore_hidden_edges ( G); // Undersøger om delproblemet skal betragtes if ( l+ cost (G, w, path_so_far ) >= z) { // Gemmer noder og kanter igen hide_nodes (G, hidden_nodes ); hide_edges (G, hidden_edges ); return ; hide_nodes (G, hidden_nodes ); hide_edges (G, hidden_edges ); // Vælg kant Strategi : første kant i p first_edge (G, s, v, chosen_edge, p); 18

19 if (A == cost (G, a, p)) { // Tilføj kanter fra p double a_weight = cost (G, w, p); // Genopretter noder og kanter hidden_nodes = restore_hidden_nodes ( G); hidden_edges = restore_hidden_edges ( G); // Opdater z a_weight += cost (G, w, path_so_far ); // Gemmer noder og kanter igen hide_nodes (G, hidden_nodes ); hide_edges (G, hidden_edges ); if ( a_weight < z) { z = a_weight ; best_path = path_so_far ; forall_edges (e, G) { if(p[e]) { best_path [ e] = true ; // Hvis det er sidste kant i vejen, og forsinkelsen ikke er opbrugt : else if ( v == t && a[ chosen_edge ] < A) { // Genopretter noder og kanter hidden_nodes = restore_hidden_nodes ( G); hidden_edges = restore_hidden_edges ( G); double a_weight = cost (G, w, path_so_far ) + w[ chosen_edge ]; // Gemmer noder og kanter igen hide_nodes (G, hidden_nodes ); hide_edges (G, hidden_edges ); if (z > a_weight ) { // Opdater best path best_path = path_so_far ; // Tilføj sidste kant best_path [ chosen_edge ] = true ; // Opdater z z = a_weight ; else { // ---- delproblem : kanten chosen_edge vælges // Gem tilstødende kanter der ikke er skjult forall_inout_edges (e, s) { inout_edges. push (e); path_so_far [ chosen_edge ] = true ; // Skjul noden G. hide_node (s); csp_branch (G, v, t, w, a, A- a[ chosen_edge ]); polite_restore_node (G, inout_edges, s); SPINNER ; if ( timeout ) return ; // ---- delproblem : kanten chosen_edge udelukkes path_so_far [ chosen_edge ] = false ; G. hide_edge ( chosen_edge ); csp_branch (G, s, t, w, a, A); G. restore_edge ( chosen_edge ); return ; 19

20 int main ( int argc, char * argv []) { graph G; edge_array < double > w, a; double A; int n = 2; int nr = 0; if ( argc < 2) { cerr << " Fejl : Filnavn som skal indlæses angives som parameter til programmet." << endl ; cerr << " Programmet afsluttes." << endl ; exit (1) ; n = 2; // Argumentet efter filnavn angiver hvilken strategi der skal benyttes. // Default er beregning af lambda i hvert knudepunkt // 0 = benyt lambda = 0; // 1 = beregn en god nedre grænseværdi, og benyt samme lambda i alle rekursioner // 2 = beregn lambda i hver knude. if ( argc > 2) { n = ( int ) strtod ( argv [2], & argv [3]) ; // Indlæs probleminstans // ( filnavnet er angivet som første parameter til programmet ) read_csp ( argv [1], G, w, a, A); // Initialisere variable best_path. init (G, false ); path_so_far. init (G, false ); node_array <edge > a_path ( G); edge_array <bool > b_path ( G); node u; edge e; if (n > 0 ) { lambda = optimal_lambda (G, G. first_node (), G. last_node (), w, a, A, best_path ); else { lambda = 0.0; cout << " " << endl ; // Hvis bedste vej fra optimal_lambda er lovlig, benyttes denne som initiel øvre grænseværdi if ( cost (G, a, best_path ) > A n == 0) { DIJKSTRA_T (G, G. first_node (), G. last_node (), a, a_path ); u = G. last_node (); best_path. init (G, false ); while (u!= G. first_node ()) { e = a_path [u]; best_path [ e] = true ; u = G. opposite (e, u); z = cost (G, w, best_path ); if (n == 2) { recalculate = true ; cout << " " << endl ; else if (n == 1) { cout << " " << endl ; 20

21 B cout << " Rodknudens ( øvre, nedre ) grænseværdier : (" << z << ", " << LofLambda (G, G. first_node (), G. last_node (), w, a, lambda, A, b_path ) << ")." << endl ; cout << " Beregner korteste vej med højeste forsinkelse på " << A << "." << endl ; cout << " Vent op til fem minutter (CPU - tid ):"; csp_branch (G, G. first_node (), G. last_node (), w, a, A); printf ( "\ ntotal ( CPU ) køretid : %.2 d :%.2 d.", (( int ) used_time ())/60, (( int ) used_time () ) %60) ; if ( used_time () > 300) { cout << " Køretiden (5 min ) er overskredet " << endl << " Rodknudens ( øvre, nedre ) grænseværdier : (" << z << ", " << LofLambda (G, G. first_node (), G. last_node (), w, a, lambda, A, b_path ) << ")." << endl ; else cout << endl ; cout << " Knuder i træet : " << knude << "." << endl ; G. restore_all_nodes (); G. restore_all_edges (); cout << " Funden vejs egenskaber ( vægt, forsinkelse ) : (" << cost (G, w, best_path ) << ", " << cost (G, a, best_path ) << ")." << endl ; Uddata - variabel λ Kører./ csp_bb av10. txt Optimal ( minimal ) vej koster : 681. Rodknudens ( øvre, nedre ) grænseværdier : (1039, 670). Beregner korteste vej med højeste forsinkelse på 485. Total ( CPU ) køretid : 00:01. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (681, 474). Kører./ csp_bb av20. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (8179, 4640). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (4686, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (4686, 3924). Kører./ csp_bb av50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (126199, 66350). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (87295, 66350). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (87295, 41480). Kører./ csp_bb eo10. txt Optimal ( minimal ) vej koster : 274. Rodknudens ( øvre, nedre ) grænseværdier : (448, 273). Beregner korteste vej med højeste forsinkelse på 273. Total ( CPU ) køretid : 00:01. Knuder i træet :

22 Funden vejs egenskaber ( vægt, forsinkelse ) : (274, 272). Kører./ csp_bb eo20. txt Optimal ( minimal ) vej koster : 480. Rodknudens ( øvre, nedre ) grænseværdier : (886, 479). Beregner korteste vej med højeste forsinkelse på 481. Rodknudens ( øvre, nedre ) grænseværdier : (480, 479). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (480, 480). Kører./ csp_bb eo50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (2462, 1235). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (1710, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (1710, 760). Kører./ csp_bb eo100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (4998, 2537). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (4264, 2537). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (4264, 810). Kører./ csp_bb eo200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (10114, 5059). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (9344, 5059). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (9344, 774). Kører./ csp_bb rcsp1. txt. Optimal ( minimal ) vej koster : 131. Rodknudens ( øvre, nedre ) grænseværdier : (142, ). Beregner korteste vej med højeste forsinkelse på 73. : Knuder i træet : 39. Funden vejs egenskaber ( vægt, forsinkelse ) : (131, 44). Kører./ csp_bb rcsp2. txt. Optimal ( minimal ) vej koster : 131. Rodknudens ( øvre, nedre ) grænseværdier : (142, ). Beregner korteste vej med højeste forsinkelse på 65. : Knuder i træet : 39. Funden vejs egenskaber ( vægt, forsinkelse ) : (131, 44). Kører./ csp_bb rcsp3. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (2, 1.5). Beregner korteste vej med højeste forsinkelse på 17. : 22

23 Knuder i træet : 11. Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp4. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (2, 2). Beregner korteste vej med højeste forsinkelse på 15. : Knuder i træet : 1. Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp9. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, ). Beregner korteste vej med højeste forsinkelse på 13. : Knuder i træet : 9. Funden vejs egenskaber ( vægt, forsinkelse ) : (420, 12). Kører./ csp_bb rcsp10. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, 420). Beregner korteste vej med højeste forsinkelse på 12. : Knuder i træet : 3. Funden vejs egenskaber ( vægt, forsinkelse ) : (420, 12). Kører./ csp_bb rcsp11. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 5). Beregner korteste vej med højeste forsinkelse på 27. : Knuder i træet : 3. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). Kører./ csp_bb rcsp12. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, ). Beregner korteste vej med højeste forsinkelse på 24. : Knuder i træet : 3. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). Kører./ csp_bb rcsp17. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, ). Beregner korteste vej med højeste forsinkelse på 198. Total ( CPU ) køretid : 00:04. Knuder i træet : 133. Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp18. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, ). Beregner korteste vej med højeste forsinkelse på 176. Total ( CPU ) køretid : 00:02. Knuder i træet :

24 Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp19. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 4.875). Beregner korteste vej med højeste forsinkelse på 22. Total ( CPU ) køretid : 00:01. Knuder i træet : 47. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb rcsp20. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 6). Beregner korteste vej med højeste forsinkelse på 19. : Knuder i træet : 1. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb sc10. txt Optimal ( minimal ) vej koster : 303. Rodknudens ( øvre, nedre ) grænseværdier : (313, ). Beregner korteste vej med højeste forsinkelse på 269. Knuder i træet : 377. Funden vejs egenskaber ( vægt, forsinkelse ) : (303, 266). Kører./ csp_bb sc20. txt Optimal ( minimal ) vej koster : 535. Rodknudens ( øvre, nedre ) grænseværdier : (1150, ). Beregner korteste vej med højeste forsinkelse på 475. Total ( CPU ) køretid : 00:01. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (535, 475). Kører./ csp_bb sc50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (1375, ). Beregner korteste vej med højeste forsinkelse på Total ( CPU ) køretid : 00:57. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (1361, 1220). Kører./ csp_bb sc100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (2869, ). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (2808, ). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (2808, 2508). Kører./ csp_bb sc200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (5631, ). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (5585, 0). Knuder i træet :

25 Funden vejs egenskaber ( vægt, forsinkelse ) : (5585, 5004). C Uddata - statisk beregnet λ Kører./ csp_bb av10. txt Optimal ( minimal ) vej koster : 681. Rodknudens ( øvre, nedre ) grænseværdier : (1039, 670). Beregner korteste vej med højeste forsinkelse på 485. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (681, 474). Kører./ csp_bb av20. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (8179, 4640). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (4686, 4640). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (4686, 3924). Kører./ csp_bb av50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (126199, 66350). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (84711, 66350). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (84711, 44064). Kører./ csp_bb eo10. txt Optimal ( minimal ) vej koster : 274. Rodknudens ( øvre, nedre ) grænseværdier : (448, 273). Beregner korteste vej med højeste forsinkelse på 273. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (274, 272). Kører./ csp_bb eo20. txt Optimal ( minimal ) vej koster : 480. Rodknudens ( øvre, nedre ) grænseværdier : (886, 479). Beregner korteste vej med højeste forsinkelse på 481. Rodknudens ( øvre, nedre ) grænseværdier : (480, 479). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (480, 480). Kører./ csp_bb eo50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (2462, 1235). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (1662, 1235). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (1662, 808). 25

26 Kører./ csp_bb eo100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (4998, 2537). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (4240, 2537). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (4240, 834). Kører./ csp_bb eo200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (10114, 5059). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (9340, 5059). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (9340, 778). Kører./ csp_bb rcsp1. txt. Optimal ( minimal ) vej koster : 131. Rodknudens ( øvre, nedre ) grænseværdier : (142, ). Beregner korteste vej med højeste forsinkelse på 73. : Knuder i træet : 27. Funden vejs egenskaber ( vægt, forsinkelse ) : (131, 44). Kører./ csp_bb rcsp2. txt. Optimal ( minimal ) vej koster : 131. Rodknudens ( øvre, nedre ) grænseværdier : (142, ). Beregner korteste vej med højeste forsinkelse på 65. : Knuder i træet : 23. Funden vejs egenskaber ( vægt, forsinkelse ) : (131, 44). Kører./ csp_bb rcsp3. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (2, 1.5). Beregner korteste vej med højeste forsinkelse på 17. : Knuder i træet : 25. Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp4. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (2, 2). Beregner korteste vej med højeste forsinkelse på 15. : Knuder i træet : 1. Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp9. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, ). Beregner korteste vej med højeste forsinkelse på 13. : Knuder i træet : 9. Funden vejs egenskaber ( vægt, forsinkelse ) : (420, 12). 26

27 Kører./ csp_bb rcsp10. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, 420). Beregner korteste vej med højeste forsinkelse på 12. : Knuder i træet : 3. Funden vejs egenskaber ( vægt, forsinkelse ) : (420, 12). Kører./ csp_bb rcsp11. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 5). Beregner korteste vej med højeste forsinkelse på 27. Knuder i træet : 85. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). Kører./ csp_bb rcsp12. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, ). Beregner korteste vej med højeste forsinkelse på 24. : Knuder i træet : 41. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). Kører./ csp_bb rcsp17. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, ). Beregner korteste vej med højeste forsinkelse på 198. Knuder i træet : 45. Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp18. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, ). Beregner korteste vej med højeste forsinkelse på 176. Knuder i træet : 45. Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp19. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 4.875). Beregner korteste vej med højeste forsinkelse på 22. Total ( CPU ) køretid : 00:01. Knuder i træet : 193. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb rcsp20. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (6, 6). Beregner korteste vej med højeste forsinkelse på 19. : Knuder i træet : 1. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb sc10. txt Optimal ( minimal ) vej koster :

28 Rodknudens ( øvre, nedre ) grænseværdier : (313, ). Beregner korteste vej med højeste forsinkelse på 269. Knuder i træet : 861. Funden vejs egenskaber ( vægt, forsinkelse ) : (303, 266). Kører./ csp_bb sc20. txt Optimal ( minimal ) vej koster : 535. Rodknudens ( øvre, nedre ) grænseværdier : (1150, ). Beregner korteste vej med højeste forsinkelse på 475. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (535, 475). Kører./ csp_bb sc50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (1375, ). Beregner korteste vej med højeste forsinkelse på Total ( CPU ) køretid : 00:38. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (1361, 1220). Kører./ csp_bb sc100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (2869, ). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (2808, ). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (2808, 2508). Kører./ csp_bb sc200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (5631, ). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (5585, ). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (5585, 5004). D Uddata - statisk λ = 0 Kører./ csp_bb av10. txt Optimal ( minimal ) vej koster : 681. Rodknudens ( øvre, nedre ) grænseværdier : (1155, 0). Beregner korteste vej med højeste forsinkelse på 485. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (681, 474). Kører./ csp_bb av20. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (8610, 0). Beregner korteste vej med højeste forsinkelse på

29 Rodknudens ( øvre, nedre ) grænseværdier : (4708, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (4708, 3902). Kører./ csp_bb av50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (128775, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (128775, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (128775, 0). Kører./ csp_bb eo10. txt Optimal ( minimal ) vej koster : 274. Rodknudens ( øvre, nedre ) grænseværdier : (546, 0). Beregner korteste vej med højeste forsinkelse på 273. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (274, 272). Kører./ csp_bb eo20. txt Optimal ( minimal ) vej koster : 480. Rodknudens ( øvre, nedre ) grænseværdier : (960, 0). Beregner korteste vej med højeste forsinkelse på 481. Rodknudens ( øvre, nedre ) grænseværdier : (480, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (480, 480). Kører./ csp_bb eo50. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (2470, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (2470, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (2470, 0). Kører./ csp_bb eo100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (5074, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (5074, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (5074, 0). Kører./ csp_bb eo200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (10118, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (10118, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (10118, 0). Kører./ csp_bb rcsp1. txt. Optimal ( minimal ) vej koster :

30 Rodknudens ( øvre, nedre ) grænseværdier : (329, 80). Beregner korteste vej med højeste forsinkelse på 73. Rodknudens ( øvre, nedre ) grænseværdier : (329, 80). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (329, 10). Kører./ csp_bb rcsp2. txt. Optimal ( minimal ) vej koster : 131. Rodknudens ( øvre, nedre ) grænseværdier : (329, 80). Beregner korteste vej med højeste forsinkelse på 65. Rodknudens ( øvre, nedre ) grænseværdier : (329, 80). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (329, 10). Kører./ csp_bb rcsp3. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (33, 1). Beregner korteste vej med højeste forsinkelse på 17. Total ( CPU ) køretid : 00:04. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp4. txt. Optimal ( minimal ) vej koster : 2. Rodknudens ( øvre, nedre ) grænseværdier : (33, 1). Beregner korteste vej med højeste forsinkelse på 15. Total ( CPU ) køretid : 00:36. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (2, 15). Kører./ csp_bb rcsp9. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, 230). Beregner korteste vej med højeste forsinkelse på 13. Rodknudens ( øvre, nedre ) grænseværdier : (808, 230). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (808, 12). Kører./ csp_bb rcsp10. txt. Optimal ( minimal ) vej koster : 420. Rodknudens ( øvre, nedre ) grænseværdier : (808, 230). Beregner korteste vej med højeste forsinkelse på 12. Rodknudens ( øvre, nedre ) grænseværdier : (808, 230). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (808, 12). Kører./ csp_bb rcsp11. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (38, 6). Beregner korteste vej med højeste forsinkelse på 27. : Knuder i træet : 33. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). 30

31 Kører./ csp_bb rcsp12. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (38, 6). Beregner korteste vej med højeste forsinkelse på 24. Total ( CPU ) køretid : 00:01. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 20). Kører./ csp_bb rcsp17. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, 455). Beregner korteste vej med højeste forsinkelse på 198. Knuder i træet : 143. Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp18. txt. Optimal ( minimal ) vej koster : 652. Rodknudens ( øvre, nedre ) grænseværdier : (1171, 455). Beregner korteste vej med højeste forsinkelse på 176. Total ( CPU ) køretid : 00:01. Knuder i træet : 221. Funden vejs egenskaber ( vægt, forsinkelse ) : (652, 143). Kører./ csp_bb rcsp19. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (25, 6). Beregner korteste vej med højeste forsinkelse på 22. : Knuder i træet : 15. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb rcsp20. txt. Optimal ( minimal ) vej koster : 6. Rodknudens ( øvre, nedre ) grænseværdier : (25, 6). Beregner korteste vej med højeste forsinkelse på 19. : Knuder i træet : 1. Funden vejs egenskaber ( vægt, forsinkelse ) : (6, 19). Kører./ csp_bb sc10. txt Optimal ( minimal ) vej koster : 303. Rodknudens ( øvre, nedre ) grænseværdier : (639, 0). Beregner korteste vej med højeste forsinkelse på 269. Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (303, 266). Kører./ csp_bb sc20. txt Optimal ( minimal ) vej koster : 535. Rodknudens ( øvre, nedre ) grænseværdier : (1150, 0). Beregner korteste vej med højeste forsinkelse på 475. Rodknudens ( øvre, nedre ) grænseværdier : (535, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (535, 475). Kører./ csp_bb sc50. txt Optimal ( minimal ) vej koster :

32 Rodknudens ( øvre, nedre ) grænseværdier : (2941, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (2941, 0). Knuder i træet : e +06. Funden vejs egenskaber ( vægt, forsinkelse ) : (2941, 0). Kører./ csp_bb sc100. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (6016, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (6016, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (6016, 0). Kører./ csp_bb sc200. txt Optimal ( minimal ) vej koster : Rodknudens ( øvre, nedre ) grænseværdier : (12009, 0). Beregner korteste vej med højeste forsinkelse på Rodknudens ( øvre, nedre ) grænseværdier : (12009, 0). Knuder i træet : Funden vejs egenskaber ( vægt, forsinkelse ) : (12009, 0). 32