343 lines
9.9 KiB
OCaml
343 lines
9.9 KiB
OCaml
open Graph
|
|
open Algo
|
|
open Tools
|
|
open Gfile
|
|
|
|
type flight = {
|
|
id: int;
|
|
departure_airport: string;
|
|
arrival_airport: string;
|
|
departure_time: int;
|
|
arrival_time: int;
|
|
}
|
|
|
|
let read_flights_from_file path : flight list =
|
|
let ic = open_in path in
|
|
let flights = ref [] in
|
|
let id_counter = ref 0 in
|
|
|
|
try
|
|
while true do
|
|
let line = input_line ic in
|
|
let line = String.trim line in
|
|
if line <> "" then begin
|
|
try
|
|
(* AIRPORT -> AIRPORT | HH:MM -> HH:MM *)
|
|
Scanf.sscanf line "%s -> %s | %d:%d -> %d:%d"
|
|
(fun departure_airport arrival_airport dep_h dep_m arr_h arr_m ->
|
|
let dep_time = dep_h * 60 + dep_m in
|
|
let arr_time = arr_h * 60 + arr_m in
|
|
let f = { id = !id_counter;
|
|
departure_airport;
|
|
arrival_airport;
|
|
departure_time = dep_time;
|
|
arrival_time = arr_time } in
|
|
flights := f :: !flights;
|
|
id_counter := !id_counter + 1
|
|
)
|
|
with
|
|
| Scanf.Scan_failure msg
|
|
| Failure msg ->
|
|
failwith (Printf.sprintf "Failed to parse line: '%s', error: %s" line msg)
|
|
end
|
|
done;
|
|
[]
|
|
with End_of_file ->
|
|
close_in ic;
|
|
List.rev !flights
|
|
|
|
(* two flights are compatible if they are 30 mins away from each other *)
|
|
let compatible f1 f2 =
|
|
f1.arrival_airport = f2.departure_airport &&
|
|
(f1.arrival_time + 30 mod (24 * 60)) <= f2.departure_time
|
|
|
|
let s = 0
|
|
let t = 1
|
|
let si i = 2 + 2*i
|
|
let di i = 2 + 2*i + 1
|
|
|
|
let is_si i = i mod 2 == 0;;
|
|
let is_di i = i mod 2 == 1;;
|
|
|
|
type bounded_flow = {
|
|
mutable flow: int;
|
|
lower: int;
|
|
capacity: int;
|
|
}
|
|
|
|
(* Build the bounded flow graph *)
|
|
let build_bounded_graph (flights: flight list) (k: int) : bounded_flow graph =
|
|
|
|
let g = empty_graph in
|
|
let g = new_node g s in
|
|
let g = new_node g t in
|
|
|
|
(* Add flight nodes *)
|
|
let g =
|
|
List.fold_left (fun g f ->
|
|
let g = new_node g (si f.id) in
|
|
let g = new_node g (di f.id) in
|
|
g
|
|
) g flights
|
|
in
|
|
|
|
(* Helper to add bounded edge *)
|
|
let add_arc g u v lower upper =
|
|
let lbl = {flow=0; lower=lower; capacity=upper} in
|
|
new_arc g {src=u; tgt=v; lbl}
|
|
in
|
|
|
|
(* s -> si [0,1] *)
|
|
let g = List.fold_left (fun g f -> add_arc g s (si f.id) 0 1) g flights in
|
|
(* si -> di [1,1] *)
|
|
let g = List.fold_left (fun g f -> add_arc g (si f.id) (di f.id) 1 1) g flights in
|
|
(* di -> t [0,1] *)
|
|
let g = List.fold_left (fun g f -> add_arc g (di f.id) t 0 1) g flights in
|
|
(* di -> sj [0,1] if compatible *)
|
|
let g =
|
|
List.fold_left (fun g f1 ->
|
|
List.fold_left (fun g f2 ->
|
|
if compatible f1 f2 then add_arc g (di f1.id) (si f2.id) 0 1
|
|
else g
|
|
) g flights
|
|
) g flights
|
|
in
|
|
(* s -> t [0, k] *)
|
|
let g = add_arc g s t 0 k in
|
|
g
|
|
|
|
|
|
(* compute and returns demands from lower bounds *)
|
|
let compute_demands (g: bounded_flow graph) (k: int): int array =
|
|
let n = n_fold g (fun acc id -> max acc id) 0 + 1 in
|
|
let demand = Array.make n 0 in
|
|
demand.(s) <- (-k);
|
|
demand.(t) <- (k);
|
|
e_iter g (fun arc ->
|
|
demand.(arc.src) <- demand.(arc.src) + arc.lbl.lower;
|
|
demand.(arc.tgt) <- demand.(arc.tgt) - arc.lbl.lower
|
|
);
|
|
demand
|
|
|
|
let add_super_nodes g demand: bounded_flow graph * id * id * int =
|
|
let n = Array.length demand in
|
|
let ss = n in
|
|
let tt = n + 1 in
|
|
let g = new_node g ss in
|
|
let g = new_node g tt in
|
|
|
|
let (g, total_demand) =
|
|
Array.fold_left (fun (g, total) v ->
|
|
let d = demand.(v) in
|
|
if d < 0 then
|
|
(new_arc g {src=ss; tgt=v; lbl={flow=0; lower=0; capacity=(-d)}}, total)
|
|
else if d > 0 then
|
|
(new_arc g {src=v; tgt=tt; lbl={flow=0; lower=0; capacity=(d)}}, total + d)
|
|
else
|
|
(g, total)
|
|
) (g, 0) (Array.init n (fun i -> i))
|
|
in
|
|
|
|
(g, ss, tt, total_demand)
|
|
|
|
(* recover original flows by adding lower bounds back *)
|
|
let recover_flows (g: bounded_flow graph) (flowg: flow graph) : unit =
|
|
e_iter flowg (fun arc ->
|
|
match(find_arc g arc.src arc.tgt) with
|
|
| None -> ();
|
|
| Some barc -> barc.lbl.flow <- arc.lbl.flow + barc.lbl.lower
|
|
)
|
|
|
|
type schedule_arc = {
|
|
from_airport: string;
|
|
to_airport: string;
|
|
flow: int;
|
|
}
|
|
|
|
let graph_to_schedule (g: bounded_flow graph) flights : schedule_arc list =
|
|
e_fold g (fun acc arc ->
|
|
if arc.lbl.flow > 0 then
|
|
let f_from = List.find_opt (fun f -> si f.id = arc.src || di f.id = arc.src) flights in
|
|
let f_to = List.find_opt (fun f -> si f.id = arc.tgt || di f.id = arc.tgt) flights in
|
|
match f_from, f_to with
|
|
| Some ff, Some ft ->
|
|
{from_airport=ff.arrival_airport; to_airport=ft.departure_airport; flow=arc.lbl.flow} :: acc
|
|
| _ -> acc
|
|
else acc
|
|
) []
|
|
|
|
|
|
let airline_schedule flights k : bounded_flow graph option =
|
|
|
|
let g = build_bounded_graph flights k in
|
|
|
|
let demand = compute_demands g k in
|
|
|
|
(* add SS and TT *)
|
|
let (g, ss, tt, total_demand) = add_super_nodes g demand in
|
|
|
|
let flow_g = e_fold g (fun org a -> new_arc org {src=a.src; tgt=a.tgt; lbl={flow=a.lbl.flow; capacity=a.lbl.capacity}}) (clone_nodes g) in
|
|
|
|
let flow_g = apply_ford_fulkerson flow_g ss tt in
|
|
|
|
(* check if demand is satisfied (sum of all flows going out of SS) *)
|
|
let total_flow_out_ss =
|
|
let arcs = out_arcs flow_g ss in
|
|
List.fold_left (fun acc (arc: flow arc) -> acc + arc.lbl.flow) 0 arcs
|
|
in
|
|
|
|
recover_flows g flow_g;
|
|
|
|
Printf.printf "total flow out of SS %d, total demand %d\n" total_flow_out_ss total_demand;
|
|
|
|
if total_flow_out_ss <> total_demand then None
|
|
else begin
|
|
Some g
|
|
end;;
|
|
|
|
let export_schedule_graph path (g: bounded_flow graph) flights =
|
|
let ff = open_out path in
|
|
|
|
(* Start DOT graph *)
|
|
Printf.fprintf ff "digraph airline_schedule {\n";
|
|
Printf.fprintf ff " fontname=\"Helvetica,Arial,sans-serif\";\n";
|
|
Printf.fprintf ff " node [fontname=\"Helvetica,Arial,sans-serif\"];\n";
|
|
Printf.fprintf ff " edge [fontname=\"Helvetica,Arial,sans-serif\"];\n";
|
|
Printf.fprintf ff " rankdir=LR;\n";
|
|
Printf.fprintf ff " node [shape=circle];\n";
|
|
|
|
(* get airport name from node id *)
|
|
let node_name id =
|
|
match List.find_opt (fun f -> si f.id = id || di f.id = id) flights with
|
|
| Some f -> f.departure_airport
|
|
| None -> if id = s then "source" else if id = t then "sink" else "unknown"
|
|
in
|
|
|
|
let n = n_fold g (fun a _ -> a + 1) 0 in
|
|
let ss = n in
|
|
let tt = n + 1 in
|
|
|
|
(* Print each arc with flow as label *)
|
|
let print_arc (arc: bounded_flow arc) =
|
|
if arc.lbl.flow > 0 &&
|
|
arc.src <> s &&
|
|
arc.tgt <> s &&
|
|
arc.src <> t &&
|
|
arc.tgt <> t &&
|
|
arc.src <> ss &&
|
|
arc.tgt <> tt then
|
|
let src_name = node_name arc.src in
|
|
let tgt_name = node_name arc.tgt in
|
|
Printf.fprintf ff " \"%s\" -> \"%s\" [label=\"%d\"];\n" src_name tgt_name arc.lbl.flow
|
|
in
|
|
|
|
e_iter g print_arc;
|
|
|
|
Printf.fprintf ff "}\n";
|
|
close_out ff;;
|
|
|
|
let export_schedule path (g: bounded_flow graph) flights =
|
|
let ff = open_out path in
|
|
|
|
(* Map node id -> flight, start with di because of di -> si case *)
|
|
let airport_of_did id =
|
|
List.find_opt (fun f -> di f.id = id) flights
|
|
in
|
|
|
|
let airport_of_sid id =
|
|
List.find_opt (fun f -> si f.id = id) flights
|
|
in
|
|
|
|
let n = n_fold g (fun a _ -> a + 1) 0 in
|
|
let ss = n - 2 in
|
|
let tt = n - 1 in
|
|
|
|
(* Keep track of which arcs were already used in a path *)
|
|
let used = Hashtbl.create 100 in
|
|
|
|
(* Find next arc with positive flow and not used *)
|
|
let next_arc_from v =
|
|
List.find_opt (fun (arc: bounded_flow arc) ->
|
|
arc.lbl.flow > 0 && not (Hashtbl.mem used (arc.src, arc.tgt)) &&
|
|
not (List.mem arc.src [ss; tt]) &&
|
|
not (List.mem arc.tgt [ss; tt; t])
|
|
) (out_arcs g v)
|
|
in
|
|
|
|
(* Trace one airplane path starting from s *)
|
|
let rec trace_airplane path_nodes current =
|
|
match next_arc_from current with
|
|
| None -> List.rev path_nodes
|
|
| Some arc ->
|
|
Hashtbl.add used (arc.src, arc.tgt) ();
|
|
trace_airplane (arc :: path_nodes) arc.tgt
|
|
in
|
|
|
|
let airplane_counter = ref 1 in
|
|
|
|
(* Generate all airplane paths *)
|
|
let rec trace_all v =
|
|
match next_arc_from v with
|
|
| None -> ()
|
|
| Some _ ->
|
|
let path = trace_airplane [] v in
|
|
(* Print the full route *)
|
|
let rec print_path = function
|
|
| [] -> ()
|
|
| (arc: bounded_flow arc) :: rest ->
|
|
let airplane = !airplane_counter in
|
|
|
|
if arc.src = s then
|
|
(* Case 1: starts *)
|
|
let airport =
|
|
match airport_of_sid arc.tgt with
|
|
| Some f -> f.departure_airport
|
|
| None -> "?"
|
|
in
|
|
Printf.fprintf ff
|
|
"Airplane %d starts at airport %s\n"
|
|
airplane airport
|
|
|
|
else if is_di arc.src && is_si arc.tgt then
|
|
(* Case 2: waits *)
|
|
let airport =
|
|
match airport_of_did arc.src with
|
|
| Some f -> f.arrival_airport
|
|
| None -> "?"
|
|
in
|
|
Printf.fprintf ff
|
|
"Airplane %d waits at airport %s\n"
|
|
airplane airport
|
|
|
|
else begin
|
|
let from_airport =
|
|
match airport_of_sid arc.src with
|
|
| Some f -> f.departure_airport
|
|
| None -> "?"
|
|
and to_airport =
|
|
match airport_of_did arc.tgt with
|
|
| Some f -> f.arrival_airport
|
|
| None -> "?"
|
|
in
|
|
Printf.fprintf ff
|
|
"Airplane %d: %s -> %s\n"
|
|
airplane from_airport to_airport;
|
|
if rest = [] then begin
|
|
Printf.fprintf ff
|
|
"Airplane %d schedule ends at airport %s\n"
|
|
airplane to_airport;
|
|
end;
|
|
end;
|
|
|
|
print_path rest
|
|
|
|
in
|
|
print_path path;
|
|
Printf.fprintf ff "\n";
|
|
airplane_counter := !airplane_counter + 1;
|
|
trace_all v
|
|
in
|
|
|
|
trace_all s;
|
|
close_out ff
|
|
|