28 Test remove node - shortest path problem - mix Algorithm 5 and 10.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e919a87e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# This file tests mixing the techniques used in Algorithm 5 and 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "562c9604",
   "metadata": {},
   "outputs": [],
   "source": [
    "exec(open(\"./funcs/tool_funcs.py\").read())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78d3581b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e12bdac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dijkstra_show_path(adj_matrix, start, end):\n",
    " \n",
    "    n = len(adj_matrix)\n",
    "    distances = [float('inf')] * n\n",
    "    previous_nodes = [-1] * n\n",
    "    distances[start] = 0\n",
    "    priority_queue = [(0, start)]  # (distance, node)\n",
    "\n",
    "    while priority_queue:\n",
    "        current_distance, current_node = heapq.heappop(priority_queue)\n",
    "\n",
    "        # Stop if we reached the destination node\n",
    "        if current_node == end:\n",
    "            break\n",
    "\n",
    "        # If the distance is no longer optimal, skip\n",
    "        if current_distance > distances[current_node]:\n",
    "            continue\n",
    "\n",
    "        # Explore neighbors\n",
    "        for neighbor, weight in enumerate(adj_matrix[current_node]):\n",
    "            if weight > 0:  # Only consider edges with weight > 0\n",
    "                distance = current_distance + weight\n",
    "\n",
    "                # Update distance if it's better\n",
    "                if distance < distances[neighbor]:\n",
    "                    distances[neighbor] = distance\n",
    "                    previous_nodes[neighbor] = current_node\n",
    "                    heapq.heappush(priority_queue, (distance, neighbor))\n",
    "\n",
    "    # Reconstruct the path from end to start\n",
    "    path = []\n",
    "    current = end\n",
    "    while current != -1:\n",
    "        path.append(current)\n",
    "        current = previous_nodes[current]\n",
    "    path.reverse()\n",
    "\n",
    "    # If the start node isn't reachable, return an empty path\n",
    "    return path if path[0] == start else []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d7dd9c0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def dijkstra_cal_previous_nodes(adj_matrix, start):\n",
    " \n",
    "    n = len(adj_matrix)\n",
    "    distances = [float('inf')] * n\n",
    "    previous_nodes = [-1] * n\n",
    "    distances[start] = 0\n",
    "    priority_queue = [(0, start)]  \n",
    "\n",
    "    while priority_queue:\n",
    "        current_distance, current_node = heapq.heappop(priority_queue)\n",
    "\n",
    "        if current_distance > distances[current_node]:\n",
    "            continue\n",
    " \n",
    "        for neighbor, weight in enumerate(adj_matrix[current_node]):\n",
    "            if weight > 0:  \n",
    "                distance = current_distance + weight\n",
    " \n",
    "                if distance < distances[neighbor]:\n",
    "                    distances[neighbor] = distance\n",
    "                    previous_nodes[neighbor] = current_node\n",
    "                    heapq.heappush(priority_queue, (distance, neighbor))\n",
    " \n",
    "    return previous_nodes\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bc9c7a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dijkstra_show_path_from_previous_nodes(previous_nodes, start, end): \n",
    "    path = []\n",
    "    current = end\n",
    "    while current != -1:\n",
    "        path.append(current)\n",
    "        current = previous_nodes[current]\n",
    "    path.reverse()\n",
    "    return path if path[0] == start else []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c3c2a38",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a96d92af",
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate_path(path, candidate_node_list):\n",
    "    new_path = [candidate_node_list[i] for i in path]\n",
    "    return new_path\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad6bbacb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ff1876be",
   "metadata": {},
   "outputs": [],
   "source": [
    "def output_small_matrix(X_distance_matrix, candidate_node_list):\n",
    "    small_matrix = np.zeros((len(candidate_node_list), len(candidate_node_list)))\n",
    "    for i, ii in enumerate(candidate_node_list):\n",
    "        for j, jj in enumerate(candidate_node_list):\n",
    "            small_matrix[i,j] = X_distance_matrix[ii, jj]\n",
    "    return small_matrix\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9c210f08",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_candidate_node_list(i, j, X_APSP_matrix, X_distance_matrix):\n",
    "    \n",
    "    N = len(X_distance_matrix)\n",
    "    \n",
    "    remaining_list = [k for k in np.arange(N) if k != i and k != j]\n",
    "    candidate_node_list = []\n",
    "    candidate_node_list.append(i)\n",
    "    for t in remaining_list:\n",
    "        if X_APSP_matrix[i,j] < X_APSP_matrix[i,t] + X_APSP_matrix[t,j]:\n",
    "            pass\n",
    "        else:\n",
    "            candidate_node_list.append(t)\n",
    "    candidate_node_list.append(j)\n",
    " \n",
    "    return candidate_node_list\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a64c124e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_if_temp_path_already_in(all_paths_list, temp_path):\n",
    "    aa = set(temp_path)\n",
    "    for bb in all_paths_list:\n",
    "        bb = set(bb)\n",
    "        if aa == bb:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "75b32da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# All shortest paths calculated by Algorithm 8 and 9 may be incomplete.\n",
    "# However, this does not affect the correctness of Algorithm 10.\n",
    "\n",
    "def cal_all_paths_warm_start(i, j, X_APSP_matrix, X_distance_matrix):\n",
    "    candidate_node_list = cal_candidate_node_list(i, j, X_APSP_matrix, X_distance_matrix)\n",
    " \n",
    "    small_matrix = output_small_matrix(X_distance_matrix, candidate_node_list)\n",
    "    path = dijkstra_show_path(small_matrix, 0, len(candidate_node_list) - 1)\n",
    "\n",
    "    all_paths_list = []\n",
    "    all_paths_list.append(path)\n",
    "\n",
    "    K = len(candidate_node_list)\n",
    "    \n",
    "    #Using this temp_list can save some time. \n",
    "    temp_list = [q for q in range(K) if q not in path]\n",
    "    \n",
    "    # temp_list = [q for q in range(1, K - 1)]\n",
    "    \n",
    "    previous_nodes = dijkstra_cal_previous_nodes(small_matrix, 0)\n",
    "\n",
    "    for m in temp_list:\n",
    "        # temp_path1 = dijkstra_show_path(small_matrix, 0, m)\n",
    "        \n",
    "        # There is no need to call dijkstra_show_path for each node m. \n",
    "        temp_path1 = dijkstra_show_path_from_previous_nodes(previous_nodes, 0, m)\n",
    " \n",
    "        temp_path2 = dijkstra_show_path(small_matrix, m, K - 1)\n",
    "        temp_path =  temp_path1[:-1] + temp_path2\n",
    "        if not check_if_temp_path_already_in(all_paths_list, temp_path):\n",
    "            all_paths_list.append(temp_path)\n",
    "\n",
    "    all_paths_list = [translate_path(ppp, candidate_node_list) for ppp in all_paths_list]    \n",
    "\n",
    "    return all_paths_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3db14f17",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_key_node_list_all(X_distance_matrix, X_APSP_matrix):\n",
    "    \n",
    "    N = len(X_distance_matrix)\n",
    "    \n",
    "    key_node_list_all = []\n",
    "\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            if i == j:\n",
    "                key_node_list_all.append([])\n",
    "            else:\n",
    "                all_paths_list = cal_all_paths_warm_start(i, j, X_APSP_matrix, X_distance_matrix)\n",
    "                key_node_list = set(all_paths_list[0])\n",
    "                for m, path_m in enumerate(all_paths_list):\n",
    "                    if m > 0:\n",
    "                        aaa = set(path_m)\n",
    "                        key_node_list = key_node_list.intersection(aaa)\n",
    "                key_node_list = list(key_node_list)\n",
    "                key_node_list.remove(i)\n",
    "                key_node_list.remove(j)\n",
    "                key_node_list_all.append(key_node_list)\n",
    "    \n",
    "    return key_node_list_all     \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d5301c1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_need_update_list_mix_algo_5_and_10(remove_node, key_node_list_all, N):\n",
    " \n",
    "    remaining_list = [i for i in np.arange(N) if i != remove_node]\n",
    "    need_update_list = [[] for i in range(N)]\n",
    "    how_many_counter = np.zeros(N)\n",
    "    for i in remaining_list:\n",
    "        for j in remaining_list:\n",
    "            if i != j:\n",
    "                if X_APSP_matrix[i,j] == X_APSP_matrix[i,remove_node] + X_APSP_matrix[remove_node,j]:\n",
    "                    key_node_list = key_node_list_all[i*N + j]\n",
    "                    if remove_node in key_node_list:\n",
    "                        need_update_list[i].append(j)\n",
    "                        how_many_counter[i] += 1\n",
    "    \n",
    "    how_many = np.sum(how_many_counter > 0)\n",
    "    \n",
    "    return need_update_list, how_many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "403ffc49",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_new_APSP_matrix_warm_key_node_list(X_distance_matrix, X_APSP_matrix, remove_node, key_node_list_all):\n",
    "    N = len(X_distance_matrix)\n",
    "    X_APSP_matrix_new = X_APSP_matrix.copy()\n",
    "    remaining_list = [i for i in np.arange(N) if i != remove_node]\n",
    "    \n",
    "\n",
    "    need_update_list, how_many = cal_need_update_list_mix_algo_5_and_10(remove_node, key_node_list_all, N)\n",
    "    \n",
    "    Cost = np.round(how_many/(N - 1), 3)\n",
    "    \n",
    "    print(f\"The cost for re-caculating the APSP matrix is: {Cost}.\")\n",
    "\n",
    "    X_distance_matrix_new = generate_new_distance_matrix(X_distance_matrix, remove_node)\n",
    "    \n",
    "    total = 0\n",
    "    num_equal = 0\n",
    " \n",
    "    for i in remaining_list:  \n",
    "        if len(need_update_list[i]) > 0:\n",
    "            temp = dijkstra_one_to_all_early_stop(X_distance_matrix_new, i, need_update_list[i], remove_node)\n",
    "            for j in need_update_list[i]:\n",
    "                X_APSP_matrix_new[i,j] = temp[j]\n",
    "                total += 1\n",
    "                if X_APSP_matrix[i,j] == X_APSP_matrix_new[i,j]:\n",
    "                    num_equal += 1\n",
    " \n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            if i == remove_node or j == remove_node:\n",
    "                X_APSP_matrix_new[i,j] = np.inf\n",
    "\n",
    "    X_APSP_matrix_new[remove_node,remove_node] = 0\n",
    "    \n",
    "    print(f\"Total number of recalculation: \", total)\n",
    "    print(f\"Number of equal to previous value: \", num_equal)\n",
    "    \n",
    "    return X_APSP_matrix_new "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c3a0fb90",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_new_distance_matrix(X_distance_matrix, remove_node):\n",
    "    X_distance_matrix_new = X_distance_matrix.copy()\n",
    " \n",
    "    N = len(X_distance_matrix)\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            if i == remove_node or j == remove_node:\n",
    "                X_distance_matrix_new[i,j] = np.inf\n",
    "\n",
    "    X_distance_matrix_new[remove_node,remove_node] = 0  \n",
    "    \n",
    "    return X_distance_matrix_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "15cbd23e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dijkstra_one_to_all_early_stop(distance_matrix, src, need_up_i, remove_node):\n",
    "    \n",
    "    N = len(distance_matrix)\n",
    "    dist = [np.inf] * N\n",
    "    dist[src] = 0\n",
    "    visited = [False] * N\n",
    "\n",
    "    # Priority queue: (distance, node)\n",
    "    pq = [(0, src)]\n",
    "    \n",
    "    kk = len(need_up_i)\n",
    "    counter = 0\n",
    "    visited[remove_node] = True\n",
    "\n",
    "    while pq:\n",
    "        current_dist, u = heapq.heappop(pq)\n",
    "\n",
    "        if visited[u]:\n",
    "            continue\n",
    "        visited[u] = True\n",
    "        \n",
    "        if u in need_up_i:\n",
    "            counter += 1\n",
    "            if counter == kk:\n",
    "                return np.array(dist)\n",
    " \n",
    "\n",
    "        # Update distances for neighbors\n",
    "        for v in range(N):\n",
    "            if not visited[v] and distance_matrix[u][v] > 0:\n",
    "                new_dist = current_dist + distance_matrix[u][v]\n",
    "                if new_dist < dist[v]:\n",
    "                    dist[v] = new_dist\n",
    "                    heapq.heappush(pq, (new_dist, v))\n",
    "\n",
    "    return np.array(dist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de3207a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "025ebebe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# N = 1000\n",
    "\n",
    "# X_distance_matrix = create_distance_matrix(N)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8e87922b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "X_distance_matrix = np.loadtxt(\"./data/X_100_distance_matrix.csv\", delimiter=\",\")\n",
    "\n",
    "X_APSP_matrix = floyd_warshall(X_distance_matrix)\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1e42a3d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time used for calculating key_node_list_all: 1.142s\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "key_node_list_all = cal_key_node_list_all(X_distance_matrix, X_APSP_matrix)\n",
    "end = time.time()\n",
    "\n",
    "\n",
    "time_used_key_node_list_all = end - start\n",
    "time_used_key_node_list_all = np.round(time_used_key_node_list_all, 3)\n",
    "print(f\"Time used for calculating key_node_list_all: {time_used_key_node_list_all}s\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c698909b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "82e2dc0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "remove_node = 3 \n",
    "\n",
    "X_distance_matrix_new = generate_new_distance_matrix(X_distance_matrix, remove_node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53cc131d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "396ccb5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cost for re-caculating the APSP matrix is: 0.434.\n",
      "Total number of recalculation:  269\n",
      "Number of equal to previous value:  0\n",
      "time_used1_warm: 0.141s\n"
     ]
    }
   ],
   "source": [
    "\n",
    "start = time.time()\n",
    "X_APSP_matrix_new_warm = cal_new_APSP_matrix_warm_key_node_list(X_distance_matrix, X_APSP_matrix, remove_node, key_node_list_all)\n",
    "end = time.time()\n",
    "\n",
    "\n",
    "time_used1_warm = end - start\n",
    "time_used1_warm = np.round(time_used1_warm, 3)\n",
    "\n",
    "print(f\"time_used1_warm: {time_used1_warm}s\" )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c9d4127",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "53cd2188",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time_used2_floyd: 1.024s\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "X_APSP_matrix_new_floyd_warshall = floyd_warshall(X_distance_matrix_new)\n",
    "end = time.time()\n",
    "\n",
    "\n",
    "time_used2_floyd = end - start\n",
    "time_used2_floyd = np.round(time_used2_floyd, 3)\n",
    "print(f\"time_used2_floyd: {time_used2_floyd}s\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "97a5617a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.142\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Although it can be calculated in advance of knowing which node is to be removed, \n",
    "# the key_node_list_all in Algorithm 10 is very expensive to calculate, \n",
    "# the time complexity is at least  O(n^3) .\n",
    "\n",
    "print(time_used_key_node_list_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f0b7e12b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratio: 0.14\n"
     ]
    }
   ],
   "source": [
    " \n",
    "print(f\"Ratio: {np.round(time_used1_warm/time_used2_floyd, 2)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b67f94ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(np.allclose(X_APSP_matrix_new_warm, X_APSP_matrix_new_floyd_warshall))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "87251380",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0. 56. 56. inf 77. 45. 69. 49. 47. 49.]\n",
      "(100, 100)\n"
     ]
    }
   ],
   "source": [
    "print(X_APSP_matrix_new_warm[0,:10])\n",
    "\n",
    "print(X_APSP_matrix_new_warm.shape)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}