team_orieentering_base_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gurobipy as gp\n",
    "from gurobipy import GRB\n",
    "import numpy as np\n",
    "import os\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_top_instance(file_path):\n",
    "    with open(file_path, 'r') as file:\n",
    "        # Read the first three lines\n",
    "        n_line = file.readline().strip()\n",
    "        m_line = file.readline().strip()\n",
    "        tmax_line = file.readline().strip()\n",
    "\n",
    "        # Parse n N\n",
    "        _, N = n_line.split()\n",
    "        N = int(N)\n",
    "\n",
    "        # Parse m P\n",
    "        _, P = m_line.split()\n",
    "        P = int(P)\n",
    "\n",
    "        # Parse tmax Tmax\n",
    "        _, Tmax = tmax_line.split()\n",
    "        Tmax = float(Tmax)\n",
    "\n",
    "        # Read the remaining lines for each node\n",
    "        nodes = []\n",
    "        for i in range(N):\n",
    "            line = file.readline().strip()\n",
    "            if line == '':\n",
    "                continue  # Skip empty lines\n",
    "            x_str, y_str, s_str = line.split()\n",
    "            x = float(x_str)\n",
    "            y = float(y_str)\n",
    "            s = float(s_str)\n",
    "            nodes.append({'id': i, 'x': x, 'y': y, 'score': s})\n",
    "        \n",
    "        return N, P, Tmax, nodes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_distance_matrix(nodes):\n",
    "    N = len(nodes)\n",
    "    distance_matrix = np.zeros((N, N))\n",
    "    for i in range(N):\n",
    "        xi, yi = nodes[i]['x'], nodes[i]['y']\n",
    "        for j in range(N):\n",
    "            xj, yj = nodes[j]['x'], nodes[j]['y']\n",
    "            distance = np.hypot(xi - xj, yi - yj)\n",
    "            distance_matrix[i][j] = distance\n",
    "    return distance_matrix\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_top_gurobi(N, P, Tmax, nodes, distance_matrix):\n",
    "    try:\n",
    "        \n",
    "\n",
    "        # Start timing\n",
    "        start_time = time.time()\n",
    "    \n",
    "        # Create a new model\n",
    "        model = gp.Model('TOP_base')\n",
    "        model.Params.TimeLimit = 600\n",
    "        model.Params.MIPGap = 0.01 \n",
    "        model.Params.OutputFlag = 0\n",
    "\n",
    "        # Sets\n",
    "        V = range(N)  # Set of nodes\n",
    "        K = range(P)  # Set of vehicles\n",
    "\n",
    "        # Parameters\n",
    "        c = distance_matrix\n",
    "        p = [node['score'] for node in nodes]\n",
    "\n",
    "        # Decision variables\n",
    "        x = model.addVars(V, V, K, vtype=GRB.BINARY, name='x')\n",
    "        y = model.addVars(V, K, vtype=GRB.BINARY, name='y')\n",
    "\n",
    "        # Objective function\n",
    "        model.setObjective(\n",
    "            gp.quicksum(p[j] * y[j, k] for j in V for k in K),\n",
    "            GRB.MAXIMIZE\n",
    "        )\n",
    "\n",
    "        # Constraints\n",
    "        for k in K:\n",
    "            # Time budget constraint\n",
    "            model.addConstr(\n",
    "                gp.quicksum(c[i][j] * x[i, j, k] for i in V for j in V if i != j) <= Tmax,\n",
    "                name=f'TimeBudget_{k}'\n",
    "            )\n",
    "\n",
    "            # Flow conservation\n",
    "            for j in V:\n",
    "                if j != 0 and j != N - 1:\n",
    "                    model.addConstr(\n",
    "                        gp.quicksum(x[i, j, k] for i in V if i != j) == y[j, k],\n",
    "                        name=f'FlowIn_{j}_{k}'\n",
    "                    )\n",
    "                    model.addConstr(\n",
    "                        gp.quicksum(x[j, i, k] for i in V if i != j) == y[j, k],\n",
    "                        name=f'FlowOut_{j}_{k}'\n",
    "                    )\n",
    "\n",
    "            # Start at start node\n",
    "            model.addConstr(\n",
    "                gp.quicksum(x[0, j, k] for j in V if j != 0) == 1,\n",
    "                name=f'StartAtStartNode_{k}'\n",
    "            )\n",
    "\n",
    "            # End at end node\n",
    "            model.addConstr(\n",
    "                gp.quicksum(x[j, N - 1, k] for j in V if j != N - 1) == 1,\n",
    "                name=f'EndAtEndNode_{k}'\n",
    "            )\n",
    "\n",
    "            # No flow into start node and no flow out of end node\n",
    "            model.addConstr(\n",
    "                gp.quicksum(x[j, 0, k] for j in V if j != 0) == 0,\n",
    "                name=f'NoFlowIntoStartNode_{k}'\n",
    "            )\n",
    "            model.addConstr(\n",
    "                gp.quicksum(x[N - 1, j, k] for j in V if j != N - 1) == 0,\n",
    "                name=f'NoFlowOutOfEndNode_{k}'\n",
    "            )\n",
    "\n",
    "        # Each node is visited at most once\n",
    "        for j in V:\n",
    "            if j != 0 and j != N - 1:\n",
    "                model.addConstr(\n",
    "                    gp.quicksum(y[j, k] for k in K) <= 1,\n",
    "                    name=f'VisitOnce_{j}'\n",
    "                )\n",
    "\n",
    "        # Find the maximum distance\n",
    "        max_distance = np.max(distance_matrix)\n",
    "\n",
    "        # Set the big M value\n",
    "        M = Tmax + max_distance # Or consider using M = Tmax + max_distance if appropriate\n",
    "\n",
    "        # Subtour elimination constraints (MTZ)\n",
    "        u = model.addVars(V, K, vtype=GRB.CONTINUOUS, lb=0, ub=Tmax, name='u')\n",
    "\n",
    "        for k in K:\n",
    "            for i in V:\n",
    "                for j in V:\n",
    "                    if i != j :\n",
    "                        model.addConstr(\n",
    "                            u[i, k] + c[i][j] - M * (1 - x[i, j, k]) <= u[j, k],\n",
    "                            name=f'Subtour_{i}_{j}_{k}'\n",
    "                        )\n",
    "\n",
    "        # Optimize the model\n",
    "        model.optimize()\n",
    "        end_time = time.time()\n",
    "        run_time = end_time - start_time\n",
    "\n",
    "        # Initialize the routes dictionary and collected prize\n",
    "        routes = {}\n",
    "        total_collected_prize = 0\n",
    "\n",
    "\n",
    "        # Initialize the routes dictionary\n",
    "        routes = {}\n",
    "\n",
    "        # Extract the solution\n",
    "        if model.Status == GRB.OPTIMAL or model.Status == GRB.TIME_LIMIT:\n",
    "            for k in K:\n",
    "                # Get the arcs used by vehicle k\n",
    "                arcs = [(i, j) for i in V for j in V if x[i, j, k].X > 0.5]\n",
    "                if not arcs:\n",
    "                    continue\n",
    "                # Store the arcs in the routes dictionary\n",
    "                routes[k] = arcs\n",
    "\n",
    "                # Reconstruct the route to calculate the collected prize\n",
    "                arc_dict = {i: j for (i, j) in arcs}\n",
    "                route = [0]\n",
    "                current_node = 0\n",
    "                while current_node != N - 1:\n",
    "                    if current_node in arc_dict:\n",
    "                        next_node = arc_dict[current_node]\n",
    "                        route.append(next_node)\n",
    "                        current_node = next_node\n",
    "                    else:\n",
    "                        break\n",
    "                # Calculate collected prize for this vehicle\n",
    "                collected_prize = sum(p[j] for j in route if j != 0 and j != N - 1)\n",
    "                total_collected_prize += collected_prize\n",
    "        elif model.Status == GRB.INFEASIBLE:\n",
    "            print(\"Model is infeasible.\")\n",
    "            return None, None, None, None\n",
    "        else:\n",
    "            print(f\"Optimization was stopped with status {model.Status}\")\n",
    "            return None, None, None, None\n",
    "\n",
    "        # Get the optimality gap\n",
    "        if model.Status == GRB.OPTIMAL:\n",
    "            gap = 0.0\n",
    "        else:\n",
    "            gap = model.MIPGap\n",
    "\n",
    "        return routes, run_time, gap, total_collected_prize\n",
    "\n",
    "    except gp.GurobiError as e:\n",
    "        print(f\"Gurobi Error: {e}\")\n",
    "        return None, None, None, None\n",
    "    except AttributeError as e:\n",
    "        print(f\"Attribute error: {e}\")\n",
    "        return None, None, None, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_all_instances(directory_path):\n",
    "    import csv\n",
    "    import os\n",
    "\n",
    "    # Prepare a list to store the results\n",
    "    results = []\n",
    "\n",
    "    csv_file = 'results.csv'\n",
    "    with open(csv_file, mode='w', newline='') as file:\n",
    "        writer = csv.writer(file)\n",
    "        writer.writerow(['Instance', 'RunTime', 'Gap', 'TotalCollectedPrize', 'AveragePrizePerVehicle'])\n",
    "\n",
    "    for filename in os.listdir(directory_path):\n",
    "        if filename.endswith('.txt'):  # Adjust the extension if needed\n",
    "            file_path = os.path.join(directory_path, filename)\n",
    "            print(f\"\\nProcessing instance: {filename}\")\n",
    "            N, P, Tmax, nodes = read_top_instance(file_path)\n",
    "            distance_matrix = compute_distance_matrix(nodes)\n",
    "            routes, run_time, gap, total_collected_prize = solve_top_gurobi(N, P, Tmax, nodes, distance_matrix)\n",
    "\n",
    "            if routes is not None:\n",
    "                # Calculate average prize per vehicle\n",
    "                num_vehicles_used = len(routes)\n",
    "                if num_vehicles_used > 0:\n",
    "                    average_prize = total_collected_prize / num_vehicles_used\n",
    "                else:\n",
    "                    average_prize = 0\n",
    "\n",
    "                # Append the results\n",
    "                results.append({\n",
    "                    'Instance': filename,\n",
    "                    'RunTime': run_time,\n",
    "                    'Gap': gap,\n",
    "                    'TotalCollectedPrize': total_collected_prize,\n",
    "                    'AveragePrizePerVehicle': average_prize\n",
    "                })\n",
    "\n",
    "                # Write the results to the CSV file\n",
    "                with open(csv_file, mode='a', newline='') as file:\n",
    "                    writer = csv.writer(file)\n",
    "                    writer.writerow([filename, run_time, gap, total_collected_prize, average_prize])\n",
    "            else:\n",
    "                print(f\"No solution found for instance {filename}.\")\n",
    "\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "({0: [(0, 96), (7, 34), (23, 7), (34, 76), (76, 99), (96, 23)], 1: [(0, 14), (14, 52), (24, 99), (52, 55), (55, 78), (78, 24)]}, 13.382877588272095, 0.0, 206.0)\n"
     ]
    }
   ],
   "source": [
    "#test with first instance\n",
    "if __name__ == \"__main__\":\n",
    "    # Path to a single instance file\n",
    "    instance_file = 'Set_100_234/p4.2.a.txt'  \n",
    "\n",
    "    # Read the instance data\n",
    "    N, P, Tmax, nodes = read_top_instance(instance_file)\n",
    "\n",
    "    # Compute the distance matrix\n",
    "    distance_matrix = compute_distance_matrix(nodes)\n",
    "\n",
    "    # Solve the TOP using Gurobi\n",
    "    results  = solve_top_gurobi(N, P, Tmax, nodes, distance_matrix)\n",
    "    print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processing instance: p4.2.a.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Processing instance: p4.2.b.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.c.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.d.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.e.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.f.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.g.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.h.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.i.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.j.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.k.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.l.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.m.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.n.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.o.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.p.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.q.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.r.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.s.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.2.t.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.a.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "Model is infeasible.\n",
      "No solution found for instance p4.3.a.txt.\n",
      "\n",
      "Processing instance: p4.3.b.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.c.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.d.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.e.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.f.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.g.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.h.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.i.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.j.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.k.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.l.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.m.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.n.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.o.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.p.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.q.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.r.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.s.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.3.t.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.a.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "Model is infeasible.\n",
      "No solution found for instance p4.4.a.txt.\n",
      "\n",
      "Processing instance: p4.4.b.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "Model is infeasible.\n",
      "No solution found for instance p4.4.b.txt.\n",
      "\n",
      "Processing instance: p4.4.c.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "Model is infeasible.\n",
      "No solution found for instance p4.4.c.txt.\n",
      "\n",
      "Processing instance: p4.4.d.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.e.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.f.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.g.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.h.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.i.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.j.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.k.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.l.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.m.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.n.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.o.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.p.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.q.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.r.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.s.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Processing instance: p4.4.t.txt\n",
      "Set parameter TimeLimit to value 600\n",
      "Set parameter MIPGap to value 0.01\n",
      "\n",
      "Summary of Results:\n",
      "Instance: p4.2.a.txt, Run Time: 13.30s, Gap: 0.00%, Total Prize: 206.0, Avg Prize/Vehicle: 103.0\n",
      "Instance: p4.2.b.txt, Run Time: 25.63s, Gap: 0.00%, Total Prize: 341.0, Avg Prize/Vehicle: 170.5\n",
      "Instance: p4.2.c.txt, Run Time: 62.22s, Gap: 0.00%, Total Prize: 452.0, Avg Prize/Vehicle: 226.0\n",
      "Instance: p4.2.d.txt, Run Time: 603.63s, Gap: 3.95%, Total Prize: 531.0, Avg Prize/Vehicle: 265.5\n",
      "Instance: p4.2.e.txt, Run Time: 602.82s, Gap: 5.38%, Total Prize: 613.0, Avg Prize/Vehicle: 306.5\n",
      "Instance: p4.2.f.txt, Run Time: 605.99s, Gap: 9.13%, Total Prize: 679.0, Avg Prize/Vehicle: 339.5\n",
      "Instance: p4.2.g.txt, Run Time: 602.09s, Gap: 8.46%, Total Prize: 745.0, Avg Prize/Vehicle: 372.5\n",
      "Instance: p4.2.h.txt, Run Time: 602.04s, Gap: 10.76%, Total Prize: 790.0, Avg Prize/Vehicle: 395.0\n",
      "Instance: p4.2.i.txt, Run Time: 602.00s, Gap: 4.66%, Total Prize: 902.0, Avg Prize/Vehicle: 451.0\n",
      "Instance: p4.2.j.txt, Run Time: 602.08s, Gap: 15.71%, Total Prize: 885.0, Avg Prize/Vehicle: 442.5\n",
      "Instance: p4.2.k.txt, Run Time: 602.03s, Gap: 10.30%, Total Prize: 990.0, Avg Prize/Vehicle: 495.0\n",
      "Instance: p4.2.l.txt, Run Time: 602.20s, Gap: 10.87%, Total Prize: 1030.0, Avg Prize/Vehicle: 515.0\n",
      "Instance: p4.2.m.txt, Run Time: 602.25s, Gap: 9.01%, Total Prize: 1088.0, Avg Prize/Vehicle: 544.0\n",
      "Instance: p4.2.n.txt, Run Time: 602.13s, Gap: 7.21%, Total Prize: 1138.0, Avg Prize/Vehicle: 569.0\n",
      "Instance: p4.2.o.txt, Run Time: 602.21s, Gap: 8.14%, Total Prize: 1155.0, Avg Prize/Vehicle: 577.5\n",
      "Instance: p4.2.p.txt, Run Time: 602.16s, Gap: 4.70%, Total Prize: 1214.0, Avg Prize/Vehicle: 607.0\n",
      "Instance: p4.2.q.txt, Run Time: 602.16s, Gap: 2.71%, Total Prize: 1256.0, Avg Prize/Vehicle: 628.0\n",
      "Instance: p4.2.r.txt, Run Time: 602.29s, Gap: 5.32%, Total Prize: 1240.0, Avg Prize/Vehicle: 620.0\n",
      "Instance: p4.2.s.txt, Run Time: 602.29s, Gap: 2.27%, Total Prize: 1277.0, Avg Prize/Vehicle: 638.5\n",
      "Instance: p4.2.t.txt, Run Time: 602.15s, Gap: 4.56%, Total Prize: 1249.0, Avg Prize/Vehicle: 624.5\n",
      "Instance: p4.3.b.txt, Run Time: 7.05s, Gap: 0.00%, Total Prize: 38.0, Avg Prize/Vehicle: 12.666666666666666\n",
      "Instance: p4.3.c.txt, Run Time: 49.27s, Gap: 0.00%, Total Prize: 193.0, Avg Prize/Vehicle: 64.33333333333333\n",
      "Instance: p4.3.d.txt, Run Time: 338.18s, Gap: 0.00%, Total Prize: 335.0, Avg Prize/Vehicle: 111.66666666666667\n",
      "Instance: p4.3.e.txt, Run Time: 603.23s, Gap: 1.71%, Total Prize: 468.0, Avg Prize/Vehicle: 156.0\n",
      "Instance: p4.3.f.txt, Run Time: 603.19s, Gap: 2.07%, Total Prize: 579.0, Avg Prize/Vehicle: 193.0\n",
      "Instance: p4.3.g.txt, Run Time: 603.53s, Gap: 6.74%, Total Prize: 653.0, Avg Prize/Vehicle: 217.66666666666666\n",
      "Instance: p4.3.h.txt, Run Time: 603.27s, Gap: 12.02%, Total Prize: 724.0, Avg Prize/Vehicle: 241.33333333333334\n",
      "Instance: p4.3.i.txt, Run Time: 603.58s, Gap: 13.12%, Total Prize: 800.0, Avg Prize/Vehicle: 266.6666666666667\n",
      "Instance: p4.3.j.txt, Run Time: 603.22s, Gap: 11.81%, Total Prize: 855.0, Avg Prize/Vehicle: 285.0\n",
      "Instance: p4.3.k.txt, Run Time: 603.62s, Gap: 14.25%, Total Prize: 912.0, Avg Prize/Vehicle: 304.0\n",
      "Instance: p4.3.l.txt, Run Time: 603.27s, Gap: 15.01%, Total Prize: 953.0, Avg Prize/Vehicle: 317.6666666666667\n",
      "Instance: p4.3.m.txt, Run Time: 603.23s, Gap: 11.92%, Total Prize: 1040.0, Avg Prize/Vehicle: 346.6666666666667\n",
      "Instance: p4.3.n.txt, Run Time: 604.13s, Gap: 11.68%, Total Prize: 1079.0, Avg Prize/Vehicle: 359.6666666666667\n",
      "Instance: p4.3.o.txt, Run Time: 603.26s, Gap: 9.97%, Total Prize: 1123.0, Avg Prize/Vehicle: 374.3333333333333\n",
      "Instance: p4.3.p.txt, Run Time: 603.18s, Gap: 3.95%, Total Prize: 1215.0, Avg Prize/Vehicle: 405.0\n",
      "Instance: p4.3.q.txt, Run Time: 603.33s, Gap: 5.77%, Total Prize: 1213.0, Avg Prize/Vehicle: 404.3333333333333\n",
      "Instance: p4.3.r.txt, Run Time: 603.99s, Gap: 5.35%, Total Prize: 1233.0, Avg Prize/Vehicle: 411.0\n",
      "Instance: p4.3.s.txt, Run Time: 603.35s, Gap: 6.27%, Total Prize: 1229.0, Avg Prize/Vehicle: 409.6666666666667\n",
      "Instance: p4.3.t.txt, Run Time: 603.24s, Gap: 7.31%, Total Prize: 1217.0, Avg Prize/Vehicle: 405.6666666666667\n",
      "Instance: p4.4.d.txt, Run Time: 8.28s, Gap: 0.00%, Total Prize: 38.0, Avg Prize/Vehicle: 9.5\n",
      "Instance: p4.4.e.txt, Run Time: 71.61s, Gap: 0.00%, Total Prize: 183.0, Avg Prize/Vehicle: 45.75\n",
      "Instance: p4.4.f.txt, Run Time: 604.38s, Gap: 15.12%, Total Prize: 324.0, Avg Prize/Vehicle: 81.0\n",
      "Instance: p4.4.g.txt, Run Time: 604.57s, Gap: 16.23%, Total Prize: 456.0, Avg Prize/Vehicle: 114.0\n",
      "Instance: p4.4.h.txt, Run Time: 604.69s, Gap: 14.36%, Total Prize: 571.0, Avg Prize/Vehicle: 142.75\n",
      "Instance: p4.4.i.txt, Run Time: 604.62s, Gap: 19.30%, Total Prize: 632.0, Avg Prize/Vehicle: 158.0\n",
      "Instance: p4.4.j.txt, Run Time: 604.31s, Gap: 34.94%, Total Prize: 707.0, Avg Prize/Vehicle: 176.75\n",
      "Instance: p4.4.k.txt, Run Time: 604.74s, Gap: 22.06%, Total Prize: 775.0, Avg Prize/Vehicle: 193.75\n",
      "Instance: p4.4.l.txt, Run Time: 605.50s, Gap: 17.89%, Total Prize: 855.0, Avg Prize/Vehicle: 213.75\n",
      "Instance: p4.4.m.txt, Run Time: 607.07s, Gap: 19.22%, Total Prize: 900.0, Avg Prize/Vehicle: 225.0\n",
      "Instance: p4.4.n.txt, Run Time: 604.22s, Gap: 20.91%, Total Prize: 942.0, Avg Prize/Vehicle: 235.5\n",
      "Instance: p4.4.o.txt, Run Time: 604.75s, Gap: 31.08%, Total Prize: 962.0, Avg Prize/Vehicle: 240.5\n",
      "Instance: p4.4.p.txt, Run Time: 604.77s, Gap: 23.95%, Total Prize: 1002.0, Avg Prize/Vehicle: 250.5\n",
      "Instance: p4.4.q.txt, Run Time: 606.10s, Gap: 15.81%, Total Prize: 1094.0, Avg Prize/Vehicle: 273.5\n",
      "Instance: p4.4.r.txt, Run Time: 604.27s, Gap: 21.28%, Total Prize: 1062.0, Avg Prize/Vehicle: 265.5\n",
      "Instance: p4.4.s.txt, Run Time: 604.31s, Gap: 14.06%, Total Prize: 1145.0, Avg Prize/Vehicle: 286.25\n",
      "Instance: p4.4.t.txt, Run Time: 604.25s, Gap: 8.47%, Total Prize: 1204.0, Avg Prize/Vehicle: 301.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Set the path to your instance directory\n",
    "    instance_directory = 'Set_100_234'  \n",
    "\n",
    "    # Process all instances in the directory and collect results\n",
    "    results = process_all_instances(instance_directory)\n",
    "\n",
    "    print(\"\\nSummary of Results:\")\n",
    "    for result in results:\n",
    "        print(f\"Instance: {result['Instance']}, Run Time: {result['RunTime']:.2f}s, \"\n",
    "              f\"Gap: {result['Gap']*100:.2f}%, Total Prize: {result['TotalCollectedPrize']}, \"\n",
    "              f\"Avg Prize/Vehicle: {result['AveragePrizePerVehicle']}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}