7 Test vary edge  - shortest path problem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ae288796",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "exec(open(\"./funcs/tool_funcs.py\").read())\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bad63ce7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_need_update_list(remove_node, X_APSP_matrix):\n",
    "    N = len(X_APSP_matrix)\n",
    "    removal = remove_node\n",
    "    remaining_list = [i for i in np.arange(N) if i != removal]\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,removal] + X_APSP_matrix[removal,j]:\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\n",
    "\n",
    "def generate_new_distance_matrix(X_distance_matrix, remove_node):\n",
    "    X_distance_matrix_new = X_distance_matrix.copy()\n",
    " \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": 3,
   "id": "567ce66a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dijkstra_one_to_all(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",
    "                # import pdb;pdb.set_trace()\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": 4,
   "id": "ee14652e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def cal_new_APSP_matrix_warm(X_distance_matrix, X_APSP_matrix, remove_node):\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",
    "    need_update_list, how_many = cal_need_update_list(remove_node, X_APSP_matrix)\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",
    "    for i in remaining_list:\n",
    "        if len(need_update_list[i]) > 0:\n",
    "            temp = dijkstra_one_to_all(X_distance_matrix_new, i, need_update_list[i], remove_node)\n",
    "\n",
    "            for j in need_update_list[i]:\n",
    "                X_APSP_matrix_new[i,j] = temp[j]\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",
    "    return X_APSP_matrix_new \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f26e801c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bbf11671",
   "metadata": {},
   "outputs": [],
   "source": [
    "def shortest_path_n_to_r_new(distance_matrix, shortest_path_matrix, remaining_list, r, remove_node):\n",
    "  \n",
    "    max_jump_list = []\n",
    "    for t in remaining_list:\n",
    "        m_jump =  distance_matrix[remove_node,t] + shortest_path_matrix[t,r]\n",
    "        max_jump_list.append(m_jump)\n",
    "    return np.min(max_jump_list)\n",
    "\n",
    "def shortest_path_r_to_n_new(distance_matrix, shortest_path_matrix, remaining_list, r, remove_node):\n",
    "    max_jump_list = []\n",
    "    for t in remaining_list:\n",
    "        m_jump =  shortest_path_matrix[r,t] + distance_matrix[t, remove_node] \n",
    "        max_jump_list.append(m_jump)\n",
    "    return np.min(max_jump_list)\n",
    "\n",
    "     \n",
    "def cal_n_shortest_path_new(distance_matrix, shortest_path_matrix, remove_node, remaining_list):\n",
    "    for r in remaining_list:\n",
    "        shortest_path_matrix[remove_node, r] = shortest_path_n_to_r_new(distance_matrix, shortest_path_matrix, remaining_list, r, remove_node)\n",
    "        shortest_path_matrix[r, remove_node] = shortest_path_r_to_n_new(distance_matrix, shortest_path_matrix, remaining_list, r, remove_node)\n",
    "        \n",
    "    for i in remaining_list:        \n",
    "        for j in remaining_list:\n",
    "            if i < j:\n",
    "                shortest_path_matrix[i,j] =  update_shortest_path_ij_new(distance_matrix, shortest_path_matrix, remove_node, i, j)\n",
    "                shortest_path_matrix[j,i] =  update_shortest_path_ij_new(distance_matrix, shortest_path_matrix, remove_node, j, i)\n",
    "                \n",
    "def update_shortest_path_ij_new(distance_matrix, shortest_path_matrix, remove_node, i,j):\n",
    "    m1 = shortest_path_matrix[i,j]\n",
    "    m2 =  shortest_path_matrix[i,remove_node] + shortest_path_matrix[remove_node,j] \n",
    "    return np.min((m1,m2))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5fe00640",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_which_to_remove(X_APSP_matrix, edge_nodes):\n",
    "   \n",
    "    _, how_many0 = cal_need_update_list(edge_nodes[0], X_APSP_matrix)\n",
    "    _, how_many1 = cal_need_update_list(edge_nodes[1], X_APSP_matrix)\n",
    "    if how_many0 < how_many1:\n",
    "        remove_node = edge_nodes[0]\n",
    "    else:\n",
    "        remove_node = edge_nodes[1]\n",
    "    # print(how_many0, how_many1, edge_nodes, remove_node)\n",
    "    return remove_node\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f3908cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def cal_APSP_matrix_after_graph_update(X_distance_matrix, X_APSP_matrix, edge_nodes, X_distance_matrix_updated):\n",
    "    \n",
    "    N = len(X_distance_matrix)\n",
    "    \n",
    "    remove_node = cal_which_to_remove(X_APSP_matrix, edge_nodes)\n",
    "\n",
    "    X_APSP_matrix_updated = cal_new_APSP_matrix_warm(X_distance_matrix, X_APSP_matrix, remove_node)\n",
    " \n",
    "    remaining_list = [i for i in np.arange(N) if i != remove_node]\n",
    "    \n",
    "    cal_n_shortest_path_new(X_distance_matrix_updated, X_APSP_matrix_updated, remove_node, remaining_list)\n",
    "    \n",
    "    return X_APSP_matrix_updated\n",
    "\n",
    " \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b10809c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# N = 100\n",
    "\n",
    "# X_distance_matrix = create_distance_matrix(N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "618651c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_distance_matrix = np.loadtxt(\"./data/X_100_distance_matrix.csv\", delimiter=\",\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e1f8c1b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4c924faa",
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_nodes = [3, 9]\n",
    "\n",
    "edge_weight = 50    \n",
    "\n",
    "X_distance_matrix_new = X_distance_matrix.copy()\n",
    "X_distance_matrix_new[edge_nodes[0],edge_nodes[1]] = edge_weight \n",
    "\n",
    "X_APSP_matrix = floyd_warshall(X_distance_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e11caeb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cost for re-caculating the APSP matrix is: 0.434.\n"
     ]
    }
   ],
   "source": [
    " \n",
    "\n",
    "start = time.time()\n",
    "X_APSP_matrix_new_warm = cal_APSP_matrix_after_graph_update(X_distance_matrix, X_APSP_matrix, edge_nodes, X_distance_matrix_new)\n",
    "end = time.time()\n",
    "\n",
    "\n",
    "time_used1_warm = end - start\n",
    "time_used1_warm = np.round(time_used1_warm, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ba73f65a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time used: 0.224s\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(f\"Time used: {time_used1_warm}s\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a0e3e30",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "139a29ad",
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f4e896ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time used: 1.015s\n"
     ]
    }
   ],
   "source": [
    "print(f\"Time used: {time_used2_floyd}s\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8096b8f2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d2fc6ee4",
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8e99335a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ratio: 0.22\n"
     ]
    }
   ],
   "source": [
    "print(f\"Ratio: {np.round(time_used1_warm/time_used2_floyd, 2)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f43d265d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([31.,  0., 63., 23., 56., 57., 59., 41., 46., 56., 33., 26., 25.,\n",
       "       20., 27., 23., 49., 48., 33., 42., 35., 47., 48., 41., 36., 37.,\n",
       "       30., 48., 38., 28., 55., 22., 60., 24., 28., 55., 60., 24., 43.,\n",
       "       85., 25., 47., 16., 65., 48., 50., 10., 82., 34., 44., 59., 15.,\n",
       "        8., 46., 54., 39., 40., 45., 49., 32., 19., 48., 68., 27., 85.,\n",
       "       54., 76., 48., 53., 17., 15., 32., 30., 34., 52., 31., 17., 55.,\n",
       "       58., 70., 42., 64., 53., 40., 52., 20., 50., 63., 42., 40., 48.,\n",
       "       24., 65., 53., 39., 31., 29., 32., 26., 17.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_APSP_matrix_new_warm[1]\n"
   ]
  }
 ],
 "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
}