🕷️ Crawler Inspector

URL Lookup

Direct Parameter Lookup

Raw Queries and Responses

1. Shard Calculation

Query:

Response:

Calculated Shard: 174 (from laksa193)

2. Crawled Status Check

Query:

curl -X POST \
  'http://laksa174.int.ahrefs:8124/' \
  -H 'Content-Type: text/plain' \
  -H 'X-ClickHouse-Database: crawler3' \
  -H 'Authorization: Basic YXBpOg==' \
  -d 'SELECT getAhrefsURLFromUnparsed(src_unparsed) AS found_url, ifNull(toUnixTimestamp(download_stamp), 0) AS crawl_time, ifNull(toUnixTimestamp(props_url_first_seen), 0) AS first_indexed_time, download_http_code AS http_code, src_unparsed AS src_unparsed, src_root_hash AS src_root_hash, history_drop_reason AS history_drop_reason, meta_title AS meta_title, meta_descriptions AS meta_descriptions, attrs_boilerpipe_text AS attrs_boilerpipe_text, attrs_markdown AS attrs_markdown, attrs_readable_markdown AS attrs_readable_markdown, meta_canonical AS meta_canonical FROM crawler3.page_info_local FINAL PREWHERE (src_root_hash, src_unparsed) IN ((getAhrefsRootHashFromUnparsed(getAhrefsUnparsedNoserviceFromURL(\'https://www.algotree.org/algorithms/single_source_shortest_path/bellman_ford_shortest_path/\')), getAhrefsUnparsedNoserviceFromURL(\'https://www.algotree.org/algorithms/single_source_shortest_path/bellman_ford_shortest_path/\'))) FORMAT JSONEachRow'

Response:

{"found_url":"https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/bellman_ford_shortest_path\/","crawl_time":1775746790,"first_indexed_time":1590000901,"http_code":200,"src_unparsed":"org,algotree!www,\/algorithms\/single_source_shortest_path\/bellman_ford_shortest_path\/ s443","src_root_hash":"15388939227391360774","history_drop_reason":null,"meta_title":"Bellman-Ford Shortest Path Algorithm :: AlgoTree","meta_descriptions":[""],"attrs_boilerpipe_text":"The gist of Bellman-Ford single source shortest path algorithm is a below :\nBellman-Ford algorithm finds the shortest path ( in terms of distance \/ cost ) from a single source in a\ndirected, weighted graph\ncontaining positive and negative edge weights.\nBellman-Ford algorithm performs edge relaxation of all the edges for every node.\nBellman-Ford Edge Relaxation\nIf\n( distance-from-source-to [ node_v ] > distance-from-source-to [ node_u ] + weight-of-path-from-node-u-to-v )\nthen\n     distance-from-source-to [ node_v ] = distance-from-source-to [ node_u ] + weight-of-path-from-node-u-to-v )\nWith negative edge weights in a graph Bellman-Ford algorithm is preferred over\nDijkstra’s\nalgorithm as Dijkstra’s algorithm cannot handle negative edge weights in a graph.\nBelow data structures are used for storing the graph before running Bellman-Ford algorithm\nEdgeList\n: List of all the edges in the graph.\nEdgeWeight\n: Map of edges and their corresponding weights.\nAlgorithm : Bellman-Ford Single Source Shortest Path ( EdgeList, EdgeWeight )\n1.    Initialize the distance from the source node\nS\nto all other nodes as infinite (999999999) and to itself as 0.\n      Distance [ AllNodes ] = 999999999, Distance [\nS\n] = 0.\n2.   \nFor\nevery node in the graph \n3.      \nFor\nevery edge E in the\nEdgeList\n4.           Node_u = E.first, Node_v = E.second\n5.           Weight_u_v =\nEdgeWeight\n( Node_u, Node_v )\n6.          \nIf\n( Distance [ v ] > Distance [ u ] + Weight_u_v )\n7.                 Distance [ v ] = Distance [ u ] + Weight_u_v\nExample of single source shortest path from source node 0 using Bellman-Ford algorithm\nNote:\nWeight of the path corresponds to the distance \/ cost between the nodes.\nBellman-Ford iteration 1\nDist [ 0 ] = 0.\nDistance from source node 0 to itself is 0.\nDist [ 1 ] = Dist [ 2 ] = Dist [ 3 ] = Dist [ 4 ] = Dist [ 5 ] = 999999999.\nInitialize the distance from the source node\n0\nto all other nodes to a max value (ex:999999999).\nNode CountIteration\nEdge (U-V)\nWeight (Cost\/Distance)  of Edge (U-V)\nDistance from source  to node ‘U’\nDistance from source  to node ‘V’\nUpdate\n1\n( 0 - 1 )\n-1\nDist [ 0 ] = 0\nDist [ 1 ] = 999999999\nIf : Dist [ 1 ] > Dist [ 0 ] + ( -1 ) Yes\nUpdate : Dist [ 1 ] = 0 + -1 = -1\n1\n( 0 - 5 )\n2\nDist [ 0 ] = 0\nDist [ 5 ] = 999999999\nIf : Dist [ 5 ] > Dist [ 0 ] + ( 2 ) Yes\nUpdate : Dist [ 5 ] = 0 + 2 = 2\n1\n( 1 - 2 )\n2\nDist [ 1 ] = -1\nDist [ 2 ] = 999999999\nIf : Dist [ 2 ] > Dist [ 1 ] + ( 2 ) Yes\nUpdate : Dist [ 2 ] = -1 + 2 = 1\n1\n( 1 - 5 )\n-2\nDist [ 1 ] = -1\nDist [ 5 ] = 2\nIf : Dist [ 5 ] > Dist [ 1 ] + ( -2 ) Yes\nUpdate : Dist [ 5 ] = -1 + -2 = -3\n1\n( 2 - 3 )\n5\nDist [ 2 ] = 1\nDist [ 3 ] = 999999999\nIf : Dist [ 3 ] > Dist [ 2 ] + ( 5 )Yes\nUpdate : Dist [ 3 ] = 1 + 5 = 6\n1\n( 2 - 4 )\n1\nDist [ 2 ] = 1\nDist [ 4 ] = 999999999\nIf : Dist [ 4 ] > Dist [ 2 ] + ( 1 )Yes\nUpdate : Dist [ 4 ] = 1 + 1 = 2\n1\n( 4 - 3 )\n-4\nDist [ 4 ] = 2\nDist [ 3 ] = 6\nIf : Dist [ 3 ] > Dist [ 4 ] + ( -4 )Yes\nUpdate : Dist [ 3 ] = 6 + (-4) = 2\n1\n( 4 - 5 )\n3\nDist [ 4 ] = 2\nDist [ 5 ] = -3\nIf : Dist [ 5 ] > Dist [ 4 ] + ( 3 )No\nNo change : Dist [ 5 ] = -3\n1\n( 5 - 1 )\n2\nDist [ 5 ] = -3\nDist [ 1 ] = -1\nIf : Dist [ 1 ] > Dist [ 5 ] + ( 2 )No\nNo change : Dist [ 1 ] = -1\n1\n( 5 - 2 )\n3\nDist [ 5 ] = -3\nDist [ 2 ] = 1\nIf : Dist [ 2 ] > Dist [ 5 ]  + ( 3 )Yes\nUpdate Dist [ 2 ] = -3 + 3 = 0\n…\n\nthe algorithm continues with iterations 2, 3, 4, 5 and 6 (number of nodes). During each iteration the shortest path from source node to other nodes is updated.\nGraph type\n: Designed for directed graph containing positive and negative edge weights.\nTime complexity of Bellman-Ford’s algorithm : O ( E . V )\n.\nV\nis the number of vertices and\nE\nis the number of edges in a graph.\nBellman-Ford’s shortest implementation\nclass\nEdge\n:\ndef\n__init__(self, src, dst, weight) :\nself\n.\nsrc\n=\nsrc\nself\n.\ndst\n=\ndst\nself\n.\nweight\n=\nweight\nclass\nGraph\n:\ndef\n__init__(self, edge_list, node_cnt) :\nself\n.\nedge_list\n=\nedge_list\nself\n.\nnode_cnt\n=\nnode_cnt\ndef\nBellmanFord\n(self, src) :\n# Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0.\ndistance\n=\n[\n999999999999\n]\n*\nself\n.\nnode_cnt\ndistance[src]\n=\n0\nfor\nnode\nin\nrange(self\n.\nnode_cnt) :\nfor\nedge\nin\nself\n.\nedge_list :\nif\n(distance[edge\n.\ndst]\n>\ndistance[edge\n.\nsrc]\n+\nedge\n.\nweight) :\ndistance[edge\n.\ndst]\n=\ndistance[edge\n.\nsrc]\n+\nedge\n.\nweight\nfor\nedge\nin\nself\n.\nedge_list :\nif\n(distance[edge\n.\ndst]\n>\ndistance[edge\n.\nsrc]\n+\nedge\n.\nweight) :\nprint(\n\"Negative weight cycle exist in the graph\"\n)\nfor\nnode\nin\nrange(self\n.\nnode_cnt) :\nprint(\n\"Source Node(\"\n+\nstr(src)\n+\n\") -> Destination Node(\"\n+\nstr(node)\n+\n\") : Length => \"\n+\nstr(distance[node]))\ndef\nmain\n() :\ne01\n=\nEdge(\n0\n,\n1\n,\n-\n1\n)\ne05\n=\nEdge(\n0\n,\n5\n,\n2\n)\ne12\n=\nEdge(\n1\n,\n2\n,\n2\n)\ne15\n=\nEdge(\n1\n,\n5\n,\n-\n2\n)\ne23\n=\nEdge(\n2\n,\n3\n,\n5\n)\ne24\n=\nEdge(\n2\n,\n4\n,\n1\n)\ne43\n=\nEdge(\n4\n,\n3\n,\n-\n4\n)\ne45\n=\nEdge(\n4\n,\n5\n,\n3\n)\ne51\n=\nEdge(\n5\n,\n1\n,\n2\n)\ne52\n=\nEdge(\n5\n,\n2\n,\n3\n)\nedge_list\n=\n[e01, e05, e12, e15, e23, e24, e43, e45, e51, e52]\nnode_cnt\n=\n6\nsource_node\n=\n0\ng\n=\nGraph(edge_list, node_cnt)\ng\n.\nBellmanFord(source_node)\nif\n__name__\n==\n\"__main__\"\n:\nmain()\nOutput\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\n#include<iostream>\n#include<vector>\n#include<list>\nusing\nnamespace\nstd;\nclass\nEdge\n{\npublic\n:\nEdge(\nint\narg_src,\nint\narg_dst,\nint\narg_weight)\n:\nsrc(arg_src), dst(arg_dst), weight(arg_weight)\n{}\nint\nsrc;\nint\ndst;\nint\nweight;\n};\nclass\nGraph\n{\nprivate\n:\nint\nnode_count;\nlist\n<\nEdge\n>\nedge_list;\npublic\n:\nGraph (\nint\narg_node_count, list\n<\nEdge\n>\narg_edge_list)\n:\nnode_count(arg_node_count), edge_list(arg_edge_list)\n{}\nvoid\nBellmanFord\n(\nint\nsrc) {\n\/\/ Initialize the distance \/ cost from the source node to all other nodes to some max value.\nvector\n<\nint\n>\ndistance(node_count,\n999999999\n);\n\/\/ Distance\/cost from the source node to itself is 0.\ndistance[src]\n=\n0\n;\nfor\n(\nint\ni\n=\n0\n; i\n<\nnode_count; i\n++\n) {\nfor\n(\nauto\n&\nit : edge_list) {\nif\n(distance[it.dst]\n>\ndistance[it.src]\n+\nit.weight) {\ndistance[it.dst]\n=\ndistance[it.src]\n+\nit.weight;\n}\n}\n}\nfor\n(\nauto\n&\nit : edge_list) {\nif\n(distance[it.dst]\n>\ndistance[it.src]\n+\nit.weight) {\ncout\n<<\n\"Negative weight cycle exist in the graph !!!\"\n<<\nendl;\n}\n}\nfor\n(\nint\ni\n=\n0\n; i\n<\nnode_count; i\n++\n)\ncout\n<<\n\"Source Node(\"\n<<\nsrc\n<<\n\") -> Destination Node(\"\n<<\ni\n<<\n\") : Length => \"\n<<\ndistance[i]\n<<\nendl;\n}\n};\nint\nmain\n(){\nEdge e01(\n0\n,\n1\n,\n-\n1\n);\nEdge e05(\n0\n,\n5\n,\n2\n);\nEdge e12(\n1\n,\n2\n,\n2\n);\nEdge e15(\n1\n,\n5\n,\n-\n2\n);\nEdge e23(\n2\n,\n3\n,\n5\n);\nEdge e24(\n2\n,\n4\n,\n1\n);\nEdge e43(\n4\n,\n3\n,\n-\n4\n);\nEdge e45(\n4\n,\n5\n,\n3\n);\nEdge e51(\n5\n,\n1\n,\n2\n);\nEdge e52(\n5\n,\n2\n,\n3\n);\nint\nnode_count\n=\n6\n;\nint\nsource_node\n=\n0\n;\nlist\n<\nEdge\n>\nedge_list\n=\n{ e01, e05, e12, e15, e23, e24, e43, e45, e51, e52 };\nGraph g(node_count, edge_list);\ng.BellmanFord(source_node);\nreturn\n0\n;\n}\nOutput\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\nimport\njava.util.ArrayList;\nimport\njava.util.List;\nimport\njava.util.Collections;\nclass\nEdge\n{\nEdge(\nint\narg_src,\nint\narg_dst,\nint\narg_weight) {\nthis\n.\nsrc\n=\narg_src;\nthis\n.\ndst\n=\narg_dst;\nthis\n.\nweight\n=\narg_weight;\n}\nint\nsrc;\nint\ndst;\nint\nweight;\n}\nclass\nGraph\n{\nint\nnode_count;\nList\n<\nEdge\n>\nedge_list;\nGraph (\nint\narg_node_count, List\n<\nEdge\n>\narg_edge_list) {\nthis\n.\nnode_count\n=\narg_node_count;\nthis\n.\nedge_list\n=\narg_edge_list;\n}\nvoid\nBellmanFord\n(\nint\nsrc) {\n\/\/ Initialize the distance\/cost from the source node to all other nodes to some max value.\nLong INF\n=\n(\nlong\n) 999999999;\nList\n<\nLong\n>\ndistance\n=\nnew\nArrayList\n<\nLong\n>\n(Collections.\nnCopies\n(node_count, INF));\n\/\/ Distance\/cost from the source node to itself is 0.\ndistance.\nset\n(src, (\nlong\n) 0);\nfor\n(\nint\ni\n=\n0; i\n<\nnode_count; i\n++\n) {\nfor\n(Edge it : edge_list) {\nif\n(distance.\nget\n(it.\ndst\n)\n>\ndistance.\nget\n(it.\nsrc\n)\n+\nit.\nweight\n) {\ndistance.\nset\n(it.\ndst\n, distance.\nget\n(it.\nsrc\n)\n+\nit.\nweight\n);\n}\n}\n}\nfor\n(Edge it : edge_list) {\nif\n(distance.\nget\n(it.\ndst\n)\n>\ndistance.\nget\n(it.\nsrc\n)\n+\nit.\nweight\n) {\nSystem.\nout\n.\nprintln\n(\n\"Negative weight cycle exist in the graph !!!\"\n);\n}\n}\nfor\n(\nint\ni\n=\n0; i\n<\nnode_count; i\n++\n)\nSystem.\nout\n.\nprintln\n(\n\"Source Node(\"\n+\nsrc\n+\n\") -> Destination Node(\"\n+\ni\n+\n\") : Length => \"\n+\ndistance.\nget\n(i));\n}\npublic\nstatic\nvoid\nmain\n(String\n[]\nargs) {\nEdge e01\n=\nnew\nEdge(0, 1,\n-\n1);\nEdge e05\n=\nnew\nEdge(0, 5, 2);\nEdge e12\n=\nnew\nEdge(1, 2, 2);\nEdge e15\n=\nnew\nEdge(1, 5,\n-\n2);\nEdge e23\n=\nnew\nEdge(2, 3, 5);\nEdge e24\n=\nnew\nEdge(2, 4, 1);\nEdge e43\n=\nnew\nEdge(4, 3,\n-\n4);\nEdge e45\n=\nnew\nEdge(4, 5, 3);\nEdge e51\n=\nnew\nEdge(5, 1, 2);\nEdge e52\n=\nnew\nEdge(5, 2, 3);\nint\nnode_count\n=\n6;\nint\nsource_node\n=\n0;\nList\n<\nEdge\n>\nedge_list\n=\nnew\nArrayList\n<>\n();\nCollections.\naddAll\n(edge_list, e01, e05, e12, e15, e23, e24, e43, e45, e51, e52);\nGraph g\n=\nnew\nGraph(node_count, edge_list);\ng.\nBellmanFord\n(source_node);\n}\n}\nOutput\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\n© 2019-2026 Algotree.org\n| All rights reserved.\nThis content is provided for educational purposes. Feel free to learn, practice, and share knowledge.\nFor questions or contributions, visit\nalgotree.org\n\"First, solve the problem. Then, write the code. - John Johnson\"","attrs_markdown":"**AlgoTree**\n\n- [Home](https:\/\/www.algotree.org\/)\n\n- [Algorithms](https:\/\/www.algotree.org\/algorithms\/)\n  - [Sorting Algorithms](https:\/\/www.algotree.org\/algorithms\/sorting\/)\n    - [Merge Sort](https:\/\/www.algotree.org\/algorithms\/sorting\/mergesort\/)\n    - [QuickSort](https:\/\/www.algotree.org\/algorithms\/sorting\/quicksort\/)\n  - [Binary Search](https:\/\/www.algotree.org\/algorithms\/binary_search\/)\n    - [Searching a number in a 2D Sorted Matrix](https:\/\/www.algotree.org\/algorithms\/binary_search\/search_an_element_in_2d_sorted_matrix\/)\n    - [Binary Search : Counting Duplicates 🤡 🤡](https:\/\/www.algotree.org\/algorithms\/binary_search\/duplicates\/)\n    - [Binary Search : Finding Square Root √](https:\/\/www.algotree.org\/algorithms\/binary_search\/squareroot\/)\n    - [Smallest Number In A Rotated Sorted Array](https:\/\/www.algotree.org\/algorithms\/binary_search\/smallest_number_in_a_rotated_sorted_array\/)\n    - [Search Number In A Rotated Sorted Array ↻](https:\/\/www.algotree.org\/algorithms\/binary_search\/search_number_in_a_rotated_sorted_array\/)\n    - [Binary Search : Allocate books 📚](https:\/\/www.algotree.org\/algorithms\/binary_search\/allot_books\/)\n    - [Binary Search : Ship packages 🚢](https:\/\/www.algotree.org\/algorithms\/binary_search\/ship_packages\/)\n  - [Range Minimum Queries ( RMQ ) : Sparse Table](https:\/\/www.algotree.org\/algorithms\/sparse_table\/)\n  - [Binary Indexed Tree ( Fenwick Tree ) 🗂](https:\/\/www.algotree.org\/algorithms\/binary_indexed_trees\/)\n  - [Adjacency Lists](https:\/\/www.algotree.org\/algorithms\/adjacency_list\/)\n    - [\\[ C++ \\] : Storing Graph As An Adjacency List](https:\/\/www.algotree.org\/algorithms\/adjacency_list\/graph_as_adjacency_list_c++\/)\n    - [\\[ Java \\] : Storing Graph As An Adjacency List](https:\/\/www.algotree.org\/algorithms\/adjacency_list\/graph_as_adjacency_list_java\/)\n    - [\\[ Python \\] : Storing Graph As An Adjacency List](https:\/\/www.algotree.org\/algorithms\/adjacency_list\/graph_as_adjacency_list_python\/)\n  - [Tree & Graph Traversals](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/)\n    - [Pre-Order, In-Order & Post-Order Traversals](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/pre_in_post_order\/)\n    - [In-Order & Pre-Order : Construct Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/construct_tree_from_inorder_preorder\/)\n    - [In-Order & Post-Order : Construct Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/construct_tree_from_inorder_postorder\/)\n    - [Level Order Tree Traversal](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/level_order\/)\n    - [Right View Of A Binary Tree 🌲 ←](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/right_view_of_a_binary_tree\/)\n    - [Level Order : Sum Of The Deepest Leaves](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/deepest_leaves_sum\/)\n    - [Top View Of A Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/top_view_of_binary_tree\/)\n    - [Balance Binary Search Tree ⚖](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/balancing_binary_search_tree\/)\n    - [Level Order : Minimum Depth Of A Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/minimum_depth_of_a_binary_tree\/)\n    - [Breadth First Search ( BFS )](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/breadth_first_search\/)\n      - [BFS : Finding Max Area Of An Island](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/breadth_first_search\/max_area_of_island\/)\n      - [BFS : Finding The Number Of Islands 🏝 🏝](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/breadth_first_search\/finding_number_of_islands\/)\n    - [Depth First Search ( DFS )](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/depth_first_search\/)\n      - [DFS : Finding Longest Path In A Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/depth_first_search\/longest_path_in_a_tree\/)\n      - [DFS : All Paths In A Directed Acyclic Graph](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/depth_first_search\/all_paths_in_a_graph\/)\n      - [DFS : Detecting Cycle In A Directed Graph ➰](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/depth_first_search\/cycle_detection_in_directed_graphs\/)\n      - [DFS : Detecting Cycle In An Undirected Graph](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/depth_first_search\/cycle_detection_in_undirected_graphs\/)\n    - [Topological Sort](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/topological_sort\/)\n    - [\\[ C++ \\] : Lexical Topological Sort](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/lexical_topological_sort_c++\/)\n    - [\\[ Python \\] : Lexical Topological Sort](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/lexical_topological_sort_python\/)\n    - [Finding A Binary Subtree In A Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/finding_binary_subtree\/)\n    - [Finding Diameter of a Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/finding_diameter_of_a_binary_tree\/)\n    - [Deleting Leaf Nodes In A Binary Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/deleting_leaf_nodes_in_a_binary_tree\/)\n    - [Merging Binary Trees](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/merging_binary_trees\/)\n    - [Binary Search Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/binary_search_tree\/)\n      - [Searching A Binary Search Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/binary_search_tree\/search_a_binary_search_tree\/)\n      - [Validating A Binary Search Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/binary_search_tree\/validating_a_binary_search_tree\/)\n      - [Inserting Into A Binary Search Tree](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/binary_search_tree\/inserting_into_a_binary_search_tree\/)\n    - [Height-Balanced Tree Check Using Recursion](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/recursively_checking_height_balanced_tree\/)\n    - [Height-Balanced Tree Check Using Traversal](https:\/\/www.algotree.org\/algorithms\/tree_graph_traversal\/tree_traversal_check_height_balanced\/)\n  - [Heap](https:\/\/www.algotree.org\/algorithms\/heap\/)\n    - [\\[ C++ \\] : Max & Min Heap ( Priority Queue \/ Set )](https:\/\/www.algotree.org\/algorithms\/heap\/maxheap_minheap_c++\/)\n    - [\\[ Python \\] : Max & Min Heap ( HeapQ )](https:\/\/www.algotree.org\/algorithms\/heap\/maxheap_minheap_python\/)\n    - [K Most Frequent Elements In An Array](https:\/\/www.algotree.org\/algorithms\/heap\/k_most_frequent_array_elements\/)\n    - [K'th largest and smallest element in an array](https:\/\/www.algotree.org\/algorithms\/heap\/kth_largest_and_smallest_element_in_array\/)\n    - [Merge K Sorted Linked Lists](https:\/\/www.algotree.org\/algorithms\/heap\/merge_k_sorted_linked_lists\/)\n  - [Stack](https:\/\/www.algotree.org\/algorithms\/stack_based\/)\n    - [Expression Conversion : Infix To Postfix](https:\/\/www.algotree.org\/algorithms\/stack_based\/infix_to_postfix\/)\n    - [Evaluating An Infix Expression](https:\/\/www.algotree.org\/algorithms\/stack_based\/evaluate_infix\/)\n    - [Largest Rectangle In A Histogram 📊](https:\/\/www.algotree.org\/algorithms\/stack_based\/largest_rectangle_in_histogram\/)\n    - [Max Size 1 Filled Rectangle In A Binary Matrix](https:\/\/www.algotree.org\/algorithms\/stack_based\/maximum_size_rectangle_in_a_binary_matrix\/)\n    - [Stock Span Problem 📈](https:\/\/www.algotree.org\/algorithms\/stack_based\/stock_span_problem\/)\n    - [Longest Valid Parentheses](https:\/\/www.algotree.org\/algorithms\/stack_based\/longest_valid_parentheses\/)\n  - [Hash Table & Set](https:\/\/www.algotree.org\/algorithms\/hash_table_and_set\/)\n    - [Finding Anagrams](https:\/\/www.algotree.org\/algorithms\/hash_table_and_set\/finding_anagrams\/)\n    - [Grouping Anagrams](https:\/\/www.algotree.org\/algorithms\/hash_table_and_set\/grouping_anagrams\/)\n    - [Longest Substring w\/o Repeating Characters](https:\/\/www.algotree.org\/algorithms\/hash_table_and_set\/substring_without_repeating_characters\/)\n  - [Linked List 🔗🔗🔗🔗](https:\/\/www.algotree.org\/algorithms\/linkedlists\/)\n    - [Singly Linked List : Insert & Append](https:\/\/www.algotree.org\/algorithms\/linkedlists\/single_linked_list_insert_and_append\/)\n    - [Singly Linked List : Reverse](https:\/\/www.algotree.org\/algorithms\/linkedlists\/single_linked_list_reverse\/)\n    - [Singly Linked List : Detect Cycle](https:\/\/www.algotree.org\/algorithms\/linkedlists\/singly_linked_list_detect_cycle\/)\n    - [Singly Linked List : Remove Duplicates](https:\/\/www.algotree.org\/algorithms\/linkedlists\/remove_duplicates_from_sorted_linked_list\/)\n    - [Doubly Linked List : Insert, Append & Delete](https:\/\/www.algotree.org\/algorithms\/linkedlists\/doubly_linked_list\/)\n  - [Backtracking](https:\/\/www.algotree.org\/algorithms\/backtracking\/)\n    - [N Queens problem ♛ ♛ ♛ ♛ ♛ ♛ ♛ ♛](https:\/\/www.algotree.org\/algorithms\/backtracking\/nqueens\/)\n    - [Backtracking + DFS : A Game Of Boggle](https:\/\/www.algotree.org\/algorithms\/backtracking\/boggle\/)\n    - [Letter Phone 📱](https:\/\/www.algotree.org\/algorithms\/backtracking\/letter_phone\/)\n    - [Generating Integer Partitions](https:\/\/www.algotree.org\/algorithms\/backtracking\/integer_partitions\/)\n    - [Partition N Elements Into K Non-Empty Subsets](https:\/\/www.algotree.org\/algorithms\/backtracking\/partition_n_elements_into_k_nonempty_subsets\/)\n    - [Palindrome Partitioning](https:\/\/www.algotree.org\/algorithms\/backtracking\/palindrome_partitioning\/)\n    - [Break a string into a given set of words](https:\/\/www.algotree.org\/algorithms\/backtracking\/word_break\/)\n  - [Greedy](https:\/\/www.algotree.org\/algorithms\/greedy\/)\n    - [Light Bulbs 💡 💡 💡 💡 💡](https:\/\/www.algotree.org\/algorithms\/greedy\/light_bulbs\/)\n  - [Disjoint-Set : Union By Rank, Path Compression](https:\/\/www.algotree.org\/algorithms\/disjoint_set\/)\n  - [Lowest Common Ancestor ( LCA )](https:\/\/www.algotree.org\/algorithms\/lowest_common_ancestor\/)\n    - [Finding The LCA Using Recursion](https:\/\/www.algotree.org\/algorithms\/lowest_common_ancestor\/lca_recursive\/)\n    - [Finding The LCA Using Upward Traversals](https:\/\/www.algotree.org\/algorithms\/lowest_common_ancestor\/lca_upwardtraversal\/)\n    - [Finding The LCA By Moving Level Up And Closer](https:\/\/www.algotree.org\/algorithms\/lowest_common_ancestor\/lca_hopandmovecloser\/)\n  - [Minimum Spanning Tree Algorithms](https:\/\/www.algotree.org\/algorithms\/minimum_spanning_tree\/)\n    - [\\[ Python \\] : Prim's Minimum Spanning Tree](https:\/\/www.algotree.org\/algorithms\/minimum_spanning_tree\/prims_python\/)\n    - [\\[ Java \\] : Prim's Minimum Spanning Tree](https:\/\/www.algotree.org\/algorithms\/minimum_spanning_tree\/prims_java\/)\n    - [\\[ C++ \\] : Prim's Minimum Spanning Tree](https:\/\/www.algotree.org\/algorithms\/minimum_spanning_tree\/prims_c++\/)\n    - [Kruskal's Minimum Spanning Tree](https:\/\/www.algotree.org\/algorithms\/minimum_spanning_tree\/kruskals\/)\n  - [Single Source Shortest Path Algorithms](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/)\n    - [\\[ Python \\] : Dijkstra's Shortest Path](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/dijkstras_shortest_path_python\/)\n    - [\\[ C++ \\] : Dijkstra's Shortest Path](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/dijkstras_shortest_path_c++\/)\n    - [\\[ Java \\] : Dijkstra's Shortest Path](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/dijkstras_shortest_path_java\/)\n    - [Bellman-Ford's Shortest Path Algorithm](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/bellman_ford_shortest_path\/)\n    - [Bellman Ford's Algorithm For DAG](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/bellman_ford_on_dag\/)\n  - [All Pairs Shortest Path : Floyd-Warshall](https:\/\/www.algotree.org\/algorithms\/floyd-warshall\/)\n  - [Numeric 🔢](https:\/\/www.algotree.org\/algorithms\/numeric\/)\n    - [Fibonacci Sequence 🧬](https:\/\/www.algotree.org\/algorithms\/numeric\/fibonacci_sequence\/)\n    - [Euler's Totient Function](https:\/\/www.algotree.org\/algorithms\/numeric\/euler_totient\/)\n    - [Prime Sieve : Generating Prime Numbers](https:\/\/www.algotree.org\/algorithms\/numeric\/prime_sieve\/)\n    - [Prime Factors](https:\/\/www.algotree.org\/algorithms\/numeric\/prime_factors\/)\n    - [Euclid's : Finding The Greatest Common Divisor](https:\/\/www.algotree.org\/algorithms\/numeric\/euclid_gcd\/)\n    - [Factorials Of Large Numbers \\!](https:\/\/www.algotree.org\/algorithms\/numeric\/large_factorials\/)\n    - [Fast Exponentiation](https:\/\/www.algotree.org\/algorithms\/numeric\/fast_exponentiation\/)\n    - [Modular Multiplication & Exponentiation](https:\/\/www.algotree.org\/algorithms\/numeric\/modular_multiplication_exponentiation\/)\n    - [Prime Or Non Prime ( Miller-Rabin )](https:\/\/www.algotree.org\/algorithms\/numeric\/check_if_prime_miller_rabin\/)\n    - [Pythagorean Triples 📐](https:\/\/www.algotree.org\/algorithms\/numeric\/pythagorean_triples\/)\n    - [Pythagorean Triples In An Array 📐](https:\/\/www.algotree.org\/algorithms\/numeric\/pythagorean_triples_in_an_array\/)\n    - [Binomial Coefficients](https:\/\/www.algotree.org\/algorithms\/numeric\/binomial_coefficients\/)\n    - [Subsets \/ Combinations : Bitwise](https:\/\/www.algotree.org\/algorithms\/numeric\/subsets_bitwise\/)\n    - [Subsets Using Permutations](https:\/\/www.algotree.org\/algorithms\/numeric\/subsets_next_permutation\/)\n    - [Integer To Hexadecimal Conversion](https:\/\/www.algotree.org\/algorithms\/numeric\/integer_to_hex\/)\n    - [Matrix Multiplication](https:\/\/www.algotree.org\/algorithms\/numeric\/matrix_multiplication\/)\n  - [Sudoku](https:\/\/www.algotree.org\/algorithms\/sudoku\/)\n    - [Validate A Given Sudoku](https:\/\/www.algotree.org\/algorithms\/sudoku\/validate_sudoku\/)\n  - [Computational Geometry](https:\/\/www.algotree.org\/algorithms\/computational_geometry\/)\n    - [Line Segment Intersection](https:\/\/www.algotree.org\/algorithms\/computational_geometry\/line_segment_intersection\/)\n  - [Bitwise Operations](https:\/\/www.algotree.org\/algorithms\/bitwise\/)\n    - [Number Of Set Bits In An Integer](https:\/\/www.algotree.org\/algorithms\/bitwise\/count_set_bits\/)\n    - [Toggle Last Set Bit](https:\/\/www.algotree.org\/algorithms\/bitwise\/toggle_last_set_bit\/)\n    - [Swapping Integers Using Bitwise XOR](https:\/\/www.algotree.org\/algorithms\/bitwise\/swap_integers\/)\n    - [Binary To Decimal Conversion](https:\/\/www.algotree.org\/algorithms\/bitwise\/binary_to_decimal\/)\n  - [Recursive Algorithms 🌀 🌀 🌀](https:\/\/www.algotree.org\/algorithms\/recursive\/)\n    - [Recursive : Finding the N'th Fibonacci number](https:\/\/www.algotree.org\/algorithms\/recursive\/generate_nth_fibonacci_number\/)\n    - [Recursive : Generating Permutations](https:\/\/www.algotree.org\/algorithms\/recursive\/permutations_recursion\/)\n    - [Recursive : Generating Subsets \/ Combinations](https:\/\/www.algotree.org\/algorithms\/recursive\/subsets_recursion\/)\n    - [Recursive : Dollar sack 💰💰💰](https:\/\/www.algotree.org\/algorithms\/recursive\/dollar_sack\/)\n    - [Recursive : Generating Subsequences](https:\/\/www.algotree.org\/algorithms\/recursive\/generate_all_subsequences\/)\n    - [Recursive : Generating All Balanced Parenthesis](https:\/\/www.algotree.org\/algorithms\/recursive\/generating_all_balanced_parenthesis\/)\n    - [Recursive : Word Search](https:\/\/www.algotree.org\/algorithms\/recursive\/word_search\/)\n    - [Recursive : Tower Of Hanoi 🗼](https:\/\/www.algotree.org\/algorithms\/recursive\/tower_of_hanoi\/)\n    - [Recursive : Finding Max Depth Of A Binary Tree](https:\/\/www.algotree.org\/algorithms\/recursive\/maximum_depth_of_a_binary_tree\/)\n  - [Cache](https:\/\/www.algotree.org\/algorithms\/cache\/)\n    - [LFU ( Least Frequently Used ) Cache](https:\/\/www.algotree.org\/algorithms\/cache\/lfu_cache\/)\n    - [LRU ( Least Recently Used ) Cache](https:\/\/www.algotree.org\/algorithms\/cache\/lru_cache\/)\n  - [Dynamic Programming](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/)\n    - [Longest Common Subsequence 🧬](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/longest_common_subsequence\/)\n    - [Longest Increasing Subsequence 🧬](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/longest_increasing_subsequence\/)\n    - [Distinct Subsequences 🧬](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/distinct_subsequences\/)\n    - [Matrix Chain Multiplication ⛓ ❌ ⛓ ❌ ⛓](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/matrix_chain_multiplication\/)\n    - [Finding Longest Palindromic Substring](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/longest_palindromic_substring\/)\n    - [Minimum Cuts To Make A Palindrome ✂ ✂](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/minimum_cuts_to_make_string_palindrome\/)\n    - [Word Break](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/word_break\/)\n    - [String Interleave](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/string_interleave\/)\n    - [0-1 Knapsack Problem 💰](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/0_1_knapsack\/)\n    - [Coins Change Problem 🪙](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/coins_change\/)\n    - [Minimum Coins For Making Change 💵 🪙](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/minimum_coins_for_change\/)\n    - [Integer Partitioning Problem](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/integer_partitioning\/)\n    - [Subset Sum Problem ⊆](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/subset_sum_problem\/)\n    - [Maximum Product Subarray Problem](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximum_product_subarray\/)\n    - [Maximum Sum Subarray Problem](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximum_sum_subarray\/)\n    - [Finding Size Of Biggest 1 Filled Square](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximal_square\/)\n    - [Maximum Sum SubRectangle](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximum_sum_subrectangle\/)\n      - [Using Aggregate Rectangles](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximum_sum_subrectangle\/aggregate_rectangles\/)\n      - [Applying Kadane's Algorithm On Row Sums](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/maximum_sum_subrectangle\/kadane_row_summations\/)\n    - [Unique Paths In A Grid ▦](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/unique_paths_in_a_grid\/)\n    - [Egg Drop Problem 🥚](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/egg_drop\/)\n    - [Assignment Problem Using BitMask](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/assignments_using_bitmask\/)\n    - [Edit Distance](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/edit_distance\/)\n    - [Climbing Stairs Problem 🪜](https:\/\/www.algotree.org\/algorithms\/dynamic_programming\/climbing_stairs\/)\n  - [KMP Pattern Match Algorithm](https:\/\/www.algotree.org\/algorithms\/pattern_matching\/)\n  - [Minimum Steps To Make Two Strings Anagrams](https:\/\/www.algotree.org\/algorithms\/minimum_step_to_make_anagrams\/)\n  - [Trie \\[ Python \\] \\[ Java \\]](https:\/\/www.algotree.org\/algorithms\/trie_python_java\/)\n  - [Trie \\[ C++ \\]](https:\/\/www.algotree.org\/algorithms\/trie\/)\n    - [Counting Distinct Substrings](https:\/\/www.algotree.org\/algorithms\/trie\/all_substrings\/)\n    - [Solving Boggle Using Trie & Depth First Search](https:\/\/www.algotree.org\/algorithms\/trie\/trie_dfs_boggle\/)\n  - [Rubik's Cube](https:\/\/www.algotree.org\/algorithms\/rubik_cube\/)\n    - [Solving a 2 x 2 Rubik's Cube 💠](https:\/\/www.algotree.org\/algorithms\/rubik_cube\/solving_2x2_rubik_cube\/)\n    - [Solving a 3 x 3 Rubik's Cube](https:\/\/www.algotree.org\/algorithms\/rubik_cube\/solving_3x3_rubik_cube\/)\n  - [A Pinch Of Code](https:\/\/www.algotree.org\/algorithms\/snippets\/)\n    - [Java : List - Create & Initialize](https:\/\/www.algotree.org\/algorithms\/snippets\/java_list_create_initialize\/)\n    - [Java : List Of Arrays](https:\/\/www.algotree.org\/algorithms\/snippets\/java_list_of_arrays\/)\n    - [Python : Create A Dictionary From A List](https:\/\/www.algotree.org\/algorithms\/snippets\/python_create_dictionary_from_list\/)\n    - [Python : Sort Dictionary By Value & Key](https:\/\/www.algotree.org\/algorithms\/snippets\/python_sort_dictionary\/)\n    - [Python : Delete Key & Value from Dictionary](https:\/\/www.algotree.org\/algorithms\/snippets\/python_delete_key_from_dictionary\/)\n    - [Python : Merge Dictionaries](https:\/\/www.algotree.org\/algorithms\/snippets\/python_merge_dictionaries\/)\n    - [Python : Two dimensional list.](https:\/\/www.algotree.org\/algorithms\/snippets\/python_two_dimensional_list\/)\n    - [Python : Convert List Of Strings To List Of Int](https:\/\/www.algotree.org\/algorithms\/snippets\/python_list_of_strings_to_list_of_int\/)\n    - [Python : Getting Current Date & Time](https:\/\/www.algotree.org\/algorithms\/snippets\/python_current_date_time\/)\n    - [Python : Decorators](https:\/\/www.algotree.org\/algorithms\/snippets\/python_decorators\/)\n    - [Python : Reading JSON file](https:\/\/www.algotree.org\/algorithms\/snippets\/python_reading_json\/)\n    - [Python : Agrument Parser](https:\/\/www.algotree.org\/algorithms\/snippets\/python_argument_parser\/)\n    - [Python : First & Last N Characters Of A String](https:\/\/www.algotree.org\/algorithms\/snippets\/python_first_and_last_n_characters_of_string\/)\n    - [Go : Check If File Exists](https:\/\/www.algotree.org\/algorithms\/snippets\/golang_check_if_file_exists\/)\n    - [Go : Read File Line By Line](https:\/\/www.algotree.org\/algorithms\/snippets\/golang_read_file_line_by_line\/)\n    - [Go : Extract Pattern Using Regular Expression](https:\/\/www.algotree.org\/algorithms\/snippets\/golang_extract_pattern_using_regexp\/)\n    - [Go : Check If A Key Exists In A Map ( Dict )](https:\/\/www.algotree.org\/algorithms\/snippets\/go_check_if_key_exists_in_a_map\/)\n    - [Go : Remove \/ Hide fields from a struct](https:\/\/www.algotree.org\/algorithms\/snippets\/golang_remove_struct_fields\/)\n    - [C++ : Compilation Process](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_compilation_process\/)\n    - [C++ : String conversion upper \/ lower case](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_uppercase_lowercase\/)\n    - [C++ : Convert String Of Integers Into A Vector](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_convert_string_to_array_of_int\/)\n    - [C++ : Static Keyword](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_static_keyword\/)\n    - [C++ : Copy Constructor](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_copy_constructor\/)\n    - [C++ : Lvaule and Rvalue](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_lvalue_rvalue\/)\n    - [C++ : Move Constructor](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_move_constructor\/)\n    - [C++ : Overload Assignment (=) Operator](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_overload_assignment_operator\/)\n    - [C++ : Move Assignment Operator](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_move_assignment_operator\/)\n    - [C++ : Overload Subscript ( \\[ \\] ) Operator](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_overload_subscript_operator\/)\n    - [C++ : Member Initializer List](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_member_initializer_list\/)\n    - [C++ : Singleton Design Pattern](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_singleton\/)\n    - [C++ : Templates](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_templates\/)\n    - [C++ : static\\_cast & dynamic\\_cast](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_static_dynamic_cast\/)\n    - [C++ : const\\_cast & reinterpret\\_cast](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_const_cast_reinterpret_cast\/)\n    - [C++ : Throwing Exceptions From A Destructor](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_throwning_exceptions_from_destructor\/)\n    - [C++ : Lambda Expression & Callback Functions](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_lambda_functions_and_callbacks\/)\n    - [C++ : Smart Pointers ( unique, shared, weak )](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_smart_pointers\/)\n    - [C++ : Initializing A Vector](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_initialize_vector\/)\n    - [C++ : Threads ( Producer & Consumer )](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_threads_producer_consumer\/)\n    - [C++ : Threads & Condition Variable 🧵](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_threads_conditional_wait\/)\n    - [C++ & Boost : Program Options](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_boost_program_options_positional_options\/)\n    - [C++ & Boost : Parsing XML](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_boost_parsing_xml\/)\n    - [C++ & Boost : Generating UUID](https:\/\/www.algotree.org\/algorithms\/snippets\/c++_boost_uuid\/)\n    - [JavaScript : Remove An Item From An Array](https:\/\/www.algotree.org\/algorithms\/snippets\/javascript_remove_specific_item_from_array\/)\n    - [JavaScript : Accept Only A Numeric Input](https:\/\/www.algotree.org\/algorithms\/snippets\/javascript_accept_float_input\/)\n    - [JavaScript : Extract Numbers From String](https:\/\/www.algotree.org\/algorithms\/snippets\/javascript_extract_numbers_from_string\/)\n- [About](https:\/\/www.algotree.org\/about\/)\n\n[Algotree](https:\/\/www.algotree.org\/)\n\n\\>\n\n[Algorithms](https:\/\/www.algotree.org\/algorithms\/)\n\n\\>\n\n[Single Source Shortest Path](https:\/\/www.algotree.org\/algorithms\/single_source_shortest_path\/)\n\n\\> Bellman-Ford Shortest Path Algorithm\n\n[Shortest Path](https:\/\/www.algotree.org\/tags\/shortest-path) [Python](https:\/\/www.algotree.org\/tags\/python) [C++](https:\/\/www.algotree.org\/tags\/c++) [Java](https:\/\/www.algotree.org\/tags\/java)\n\n# Bellman-Ford Shortest Path Algorithm\nThe gist of Bellman-Ford single source shortest path algorithm is a below :\n\n- Bellman-Ford algorithm finds the shortest path ( in terms of distance \/ cost ) from a single source in a **directed, weighted graph** containing positive and negative edge weights.\n- Bellman-Ford algorithm performs edge relaxation of all the edges for every node. **Bellman-Ford Edge Relaxation** **If** ( distance-from-source-to \\[ node\\_v \\] \\> distance-from-source-to \\[ node\\_u \\] + weight-of-path-from-node-u-to-v ) **then** distance-from-source-to \\[ node\\_v \\] = distance-from-source-to \\[ node\\_u \\] + weight-of-path-from-node-u-to-v )\n- With negative edge weights in a graph Bellman-Ford algorithm is preferred over [**Dijkstra’s**](https:\/\/algotree.org\/algorithms\/single_source_shortest_path\/dijkstras_shortest_path\/) algorithm as Dijkstra’s algorithm cannot handle negative edge weights in a graph.\n***\nBelow data structures are used for storing the graph before running Bellman-Ford algorithm\n\n- **EdgeList** : List of all the edges in the graph.\n- **EdgeWeight** : Map of edges and their corresponding weights.\n***\n***\n**Algorithm : Bellman-Ford Single Source Shortest Path ( EdgeList, EdgeWeight )**\n\n1\\. Initialize the distance from the source node **S** to all other nodes as infinite (999999999) and to itself as 0. Distance \\[ AllNodes \\] = 999999999, Distance \\[ **S** \\] = 0. 2. **For** every node in the graph 3. **For** every edge E in the **EdgeList** 4. Node\\_u = E.first, Node\\_v = E.second 5. Weight\\_u\\_v = **EdgeWeight** ( Node\\_u, Node\\_v ) 6. **If** ( Distance \\[ v \\] \\> Distance \\[ u \\] + Weight\\_u\\_v ) 7. Distance \\[ v \\] = Distance \\[ u \\] + Weight\\_u\\_v\n***\n**Example of single source shortest path from source node 0 using Bellman-Ford algorithm**\n\n**Note:** Weight of the path corresponds to the distance \/ cost between the nodes.\n\n**Bellman-Ford iteration 1** **Dist \\[ 0 \\] = 0.** Distance from source node 0 to itself is 0. **Dist \\[ 1 \\] = Dist \\[ 2 \\] = Dist \\[ 3 \\] = Dist \\[ 4 \\] = Dist \\[ 5 \\] = 999999999.** Initialize the distance from the source node **0** to all other nodes to a max value (ex:999999999).\n\n| Node CountIteration | Edge (U-V) | Weight (Cost\/Distance) of Edge (U-V) | Distance from source to node ‘U’ | Distance from source to node ‘V’ | Update |\n|---|---|---|---|---|---|\n| 1 | ( 0 - 1 ) | \\-1 | Dist \\[ 0 \\] = 0 | Dist \\[ 1 \\] = 999999999 | If : Dist \\[ 1 \\] \\> Dist \\[ 0 \\] + ( -1 ) Yes **Update : Dist \\[ 1 \\] = 0 + -1 = -1** |\n| 1 | ( 0 - 5 ) | 2 | Dist \\[ 0 \\] = 0 | Dist \\[ 5 \\] = 999999999 | If : Dist \\[ 5 \\] \\> Dist \\[ 0 \\] + ( 2 ) Yes **Update : Dist \\[ 5 \\] = 0 + 2 = 2** |\n| 1 | ( 1 - 2 ) | 2 | Dist \\[ 1 \\] = -1 | Dist \\[ 2 \\] = 999999999 | If : Dist \\[ 2 \\] \\> Dist \\[ 1 \\] + ( 2 ) Yes **Update : Dist \\[ 2 \\] = -1 + 2 = 1** |\n| 1 | ( 1 - 5 ) | \\-2 | Dist \\[ 1 \\] = -1 | Dist \\[ 5 \\] = 2 | If : Dist \\[ 5 \\] \\> Dist \\[ 1 \\] + ( -2 ) Yes **Update : Dist \\[ 5 \\] = -1 + -2 = -3** |\n| 1 | ( 2 - 3 ) | 5 | Dist \\[ 2 \\] = 1 | Dist \\[ 3 \\] = 999999999 | If : Dist \\[ 3 \\] \\> Dist \\[ 2 \\] + ( 5 )Yes **Update : Dist \\[ 3 \\] = 1 + 5 = 6** |\n| 1 | ( 2 - 4 ) | 1 | Dist \\[ 2 \\] = 1 | Dist \\[ 4 \\] = 999999999 | If : Dist \\[ 4 \\] \\> Dist \\[ 2 \\] + ( 1 )Yes **Update : Dist \\[ 4 \\] = 1 + 1 = 2** |\n| 1 | ( 4 - 3 ) | \\-4 | Dist \\[ 4 \\] = 2 | Dist \\[ 3 \\] = 6 | If : Dist \\[ 3 \\] \\> Dist \\[ 4 \\] + ( -4 )Yes **Update : Dist \\[ 3 \\] = 6 + (-4) = 2** |\n| 1 | ( 4 - 5 ) | 3 | Dist \\[ 4 \\] = 2 | Dist \\[ 5 \\] = -3 | If : Dist \\[ 5 \\] \\> Dist \\[ 4 \\] + ( 3 )No **No change : Dist \\[ 5 \\] = -3** |\n| 1 | ( 5 - 1 ) | 2 | Dist \\[ 5 \\] = -3 | Dist \\[ 1 \\] = -1 | If : Dist \\[ 1 \\] \\> Dist \\[ 5 \\] + ( 2 )No **No change : Dist \\[ 1 \\] = -1** |\n| 1 | ( 5 - 2 ) | 3 | Dist \\[ 5 \\] = -3 | Dist \\[ 2 \\] = 1 | If : Dist \\[ 2 \\] \\> Dist \\[ 5 \\] + ( 3 )Yes **Update Dist \\[ 2 \\] = -3 + 3 = 0** |\n\n… the algorithm continues with iterations 2, 3, 4, 5 and 6 (number of nodes). During each iteration the shortest path from source node to other nodes is updated.\n\n![Bellman\\_Ford\\_Shortest\\_Path](https:\/\/www.algotree.org\/images\/Bellman_Ford_Shortest_Path.svg)\n\n**Graph type** : Designed for directed graph containing positive and negative edge weights. **Time complexity of Bellman-Ford’s algorithm : O ( E . V )**. **V** is the number of vertices and **E** is the number of edges in a graph.\n***\n***\n**Bellman-Ford’s shortest implementation**\n\nPython\n\nC++\n\nJava\n\n```\nclass Edge :\n\n    def __init__(self, src, dst, weight) :\n         self.src = src \n         self.dst = dst \n         self.weight = weight\n\nclass Graph :\n\n    def __init__(self, edge_list, node_cnt) :\n         self.edge_list = edge_list\n         self.node_cnt  = node_cnt\n\n    def BellmanFord (self, src) :\n\n        # Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0.\n        distance = [999999999999] * self.node_cnt\n        distance[src] = 0 \n\n        for node in range(self.node_cnt) :\n            for edge in self.edge_list :\n\n                if (distance[edge.dst] > distance[edge.src] + edge.weight) :\n                    distance[edge.dst] = distance[edge.src] + edge.weight\n\n        for edge in self.edge_list :\n\n            if (distance[edge.dst] > distance[edge.src] + edge.weight) :\n                print(\"Negative weight cycle exist in the graph\")\n\n        for node in range(self.node_cnt) : \n            print(\"Source Node(\"+str(src)+\") -> Destination Node(\"+str(node)+\") : Length => \"+str(distance[node]))\n\ndef main() :\n\n    e01 = Edge(0, 1, -1) \n    e05 = Edge(0, 5, 2)\n    e12 = Edge(1, 2, 2)\n    e15 = Edge(1, 5, -2) \n    e23 = Edge(2, 3, 5)\n    e24 = Edge(2, 4, 1)\n    e43 = Edge(4, 3, -4) \n    e45 = Edge(4, 5, 3)\n    e51 = Edge(5, 1, 2)\n    e52 = Edge(5, 2, 3)\n\n    edge_list = [e01, e05, e12, e15, e23, e24, e43, e45, e51, e52]\n    node_cnt = 6 \n    source_node = 0 \n \n    g = Graph(edge_list, node_cnt)\n    g.BellmanFord(source_node)\n\nif __name__ == \"__main__\":\n    main()\n```\nOutput\n```\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\n```\n\n```\n#include<iostream>\n#include<vector>\n#include<list>\n\nusing namespace std;\n\nclass Edge {\n\n    public :\n\n    Edge(int arg_src, int arg_dst, int arg_weight) : src(arg_src), dst(arg_dst), weight(arg_weight)\n    {}\n    int src;\n    int dst;\n    int weight;\n};\n\nclass Graph {\n\n    private :\n\n    int node_count;\n    list<Edge> edge_list;\n\n    public:\n\n    Graph (int arg_node_count, list<Edge> arg_edge_list) : node_count(arg_node_count), edge_list(arg_edge_list)\n    {}\n\n    void BellmanFord (int src) {\n\n        \/\/ Initialize the distance \/ cost from the source node to all other nodes to some max value.\n        vector<int> distance(node_count, 999999999);\n\n        \/\/ Distance\/cost from the source node to itself is 0.\n        distance[src] = 0;\n\n        for (int i=0; i<node_count; i++) {\n            for (auto& it : edge_list) {\n                if (distance[it.dst] > distance[it.src] + it.weight) {\n                    distance[it.dst] = distance[it.src] + it.weight;\n                }\n            }\n        }\n\n        for (auto& it : edge_list) {\n            if (distance[it.dst] > distance[it.src] + it.weight) {\n               cout << \"Negative weight cycle exist in the graph !!!\" << endl;\n            }\n        }\n\n        for (int i=0; i<node_count; i++)\n            cout << \"Source Node(\" << src << \") -> Destination Node(\" << i << \") : Length => \" << distance[i] << endl;\n    }\n};\n\nint main(){\n\n    Edge e01(0, 1, -1);\n    Edge e05(0, 5, 2);\n    Edge e12(1, 2, 2);\n    Edge e15(1, 5, -2);\n    Edge e23(2, 3, 5);\n    Edge e24(2, 4, 1);\n    Edge e43(4, 3, -4);\n    Edge e45(4, 5, 3);\n    Edge e51(5, 1, 2);\n    Edge e52(5, 2, 3);\n\n    int node_count = 6;\n    int source_node = 0;\n    list<Edge> edge_list = { e01, e05, e12, e15, e23, e24, e43, e45, e51, e52 };\n\n    Graph g(node_count, edge_list);\n    g.BellmanFord(source_node);\n\n    return 0;\n}\n```\nOutput\n```\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\n```\n\n```\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.Collections;\n\nclass Edge {\n\n    Edge(int arg_src, int arg_dst, int arg_weight) {\n         this.src = arg_src;\n         this.dst = arg_dst;\n         this.weight = arg_weight;\n    }\n    int src;\n    int dst;\n    int weight;\n}\n\nclass Graph {\n\n    int node_count;\n    List<Edge> edge_list;\n\n    Graph (int arg_node_count, List<Edge> arg_edge_list) {\n        this.node_count = arg_node_count;\n        this.edge_list  = arg_edge_list;\n    }\n\n    void BellmanFord (int src) {\n\n        \/\/ Initialize the distance\/cost from the source node to all other nodes to some max value.\n        Long INF = (long) 999999999;\n        List<Long> distance = new ArrayList<Long>(Collections.nCopies(node_count, INF));\n\n        \/\/ Distance\/cost from the source node to itself is 0.\n        distance.set(src, (long) 0);\n\n        for (int i=0; i<node_count; i++) {\n            for (Edge it : edge_list) {\n                if (distance.get(it.dst) > distance.get(it.src) + it.weight) {\n                    distance.set(it.dst, distance.get(it.src) + it.weight);\n                }\n            }\n        }\n\n        for (Edge it : edge_list) {\n            if (distance.get(it.dst) > distance.get(it.src) + it.weight) {\n               System.out.println(\"Negative weight cycle exist in the graph !!!\");\n            }\n        }\n\n        for (int i=0; i<node_count; i++)\n            System.out.println(\"Source Node(\" + src + \") -> Destination Node(\" + i + \") : Length => \" + distance.get(i));\n    }\n\n    public static void main (String[] args) {\n\n        Edge e01 = new Edge(0, 1, -1);\n        Edge e05 = new Edge(0, 5, 2);\n        Edge e12 = new Edge(1, 2, 2);\n        Edge e15 = new Edge(1, 5, -2);\n        Edge e23 = new Edge(2, 3, 5);\n        Edge e24 = new Edge(2, 4, 1);\n        Edge e43 = new Edge(4, 3, -4);\n        Edge e45 = new Edge(4, 5, 3);\n        Edge e51 = new Edge(5, 1, 2);\n        Edge e52 = new Edge(5, 2, 3);\n\n        int node_count = 6;\n        int source_node = 0;\n        List<Edge> edge_list = new ArrayList<>();\n        Collections.addAll(edge_list, e01, e05, e12, e15, e23, e24, e43, e45, e51, e52);\n\n        Graph g = new Graph(node_count, edge_list);\n        g.BellmanFord(source_node);\n    }\n}\n```\nOutput\n```\nSource Node(0) -> Destination Node(0) : Length => 0\nSource Node(0) -> Destination Node(1) : Length => -1\nSource Node(0) -> Destination Node(2) : Length => 0\nSource Node(0) -> Destination Node(3) : Length => -3\nSource Node(0) -> Destination Node(4) : Length => 1\nSource Node(0) -> Destination Node(5) : Length => -3\n```\n***\n***\n**© 2019-2026 Algotree.org** \\| All rights reserved.\n\nThis content is provided for educational purposes. Feel free to learn, practice, and share knowledge.  \n For questions or contributions, visit [algotree.org](https:\/\/algotree.org\/)\n\n\"First, solve the problem. Then, write the code. - John Johnson\"","attrs_readable_markdown":null,"meta_canonical":null}

3. Robots.txt Check

Query:

Response:

4. Spam/Ban Check

Query:

Response:

5. Seen Status Check

ℹ️ Skipped - page is already crawled

📄

INDEXABLE

✅

CRAWLED

7 days ago

🤖

ROBOTS ALLOWED

Page Info Filters

Filter	Status	Condition	Details
HTTP status	PASS	`download_http_code = 200`	HTTP 200
Age cutoff	PASS	`download_stamp > now() - 6 MONTH`	0.3 months ago
History drop	PASS	`isNull(history_drop_reason)`	No drop reason
Spam/ban	PASS	`fh_dont_index != 1 AND ml_spam_score = 0`	ml_spam_score=0
Canonical	PASS	`meta_canonical IS NULL OR = '' OR = src_unparsed`	Not set

Page Details

Property	Value
URL	https://www.algotree.org/algorithms/single_source_shortest_path/bellman_ford_shortest_path/
Last Crawled	2026-04-09 14:59:50 (7 days ago)
First Indexed	2020-05-20 18:55:01 (5 years ago)
HTTP Status Code	200
Meta Title	Bellman-Ford Shortest Path Algorithm :: AlgoTree
Meta Description	null
Meta Canonical	null
Boilerpipe Text	The gist of Bellman-Ford single source shortest path algorithm is a below : Bellman-Ford algorithm finds the shortest path ( in terms of distance / cost ) from a single source in a directed, weighted graph containing positive and negative edge weights. Bellman-Ford algorithm performs edge relaxation of all the edges for every node. Bellman-Ford Edge Relaxation If ( distance-from-source-to [ node_v ] > distance-from-source-to [ node_u ] + weight-of-path-from-node-u-to-v ) then distance-from-source-to [ node_v ] = distance-from-source-to [ node_u ] + weight-of-path-from-node-u-to-v ) With negative edge weights in a graph Bellman-Ford algorithm is preferred over Dijkstra’s algorithm as Dijkstra’s algorithm cannot handle negative edge weights in a graph. Below data structures are used for storing the graph before running Bellman-Ford algorithm EdgeList : List of all the edges in the graph. EdgeWeight : Map of edges and their corresponding weights. Algorithm : Bellman-Ford Single Source Shortest Path ( EdgeList, EdgeWeight ) 1. Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0. Distance [ AllNodes ] = 999999999, Distance [ S ] = 0. 2. For every node in the graph 3. For every edge E in the EdgeList 4. Node_u = E.first, Node_v = E.second 5. Weight_u_v = EdgeWeight ( Node_u, Node_v ) 6. If ( Distance [ v ] > Distance [ u ] + Weight_u_v ) 7. Distance [ v ] = Distance [ u ] + Weight_u_v Example of single source shortest path from source node 0 using Bellman-Ford algorithm Note: Weight of the path corresponds to the distance / cost between the nodes. Bellman-Ford iteration 1 Dist [ 0 ] = 0. Distance from source node 0 to itself is 0. Dist [ 1 ] = Dist [ 2 ] = Dist [ 3 ] = Dist [ 4 ] = Dist [ 5 ] = 999999999. Initialize the distance from the source node 0 to all other nodes to a max value (ex:999999999). Node CountIteration Edge (U-V) Weight (Cost/Distance) of Edge (U-V) Distance from source to node ‘U’ Distance from source to node ‘V’ Update 1 ( 0 - 1 ) -1 Dist [ 0 ] = 0 Dist [ 1 ] = 999999999 If : Dist [ 1 ] > Dist [ 0 ] + ( -1 ) Yes Update : Dist [ 1 ] = 0 + -1 = -1 1 ( 0 - 5 ) 2 Dist [ 0 ] = 0 Dist [ 5 ] = 999999999 If : Dist [ 5 ] > Dist [ 0 ] + ( 2 ) Yes Update : Dist [ 5 ] = 0 + 2 = 2 1 ( 1 - 2 ) 2 Dist [ 1 ] = -1 Dist [ 2 ] = 999999999 If : Dist [ 2 ] > Dist [ 1 ] + ( 2 ) Yes Update : Dist [ 2 ] = -1 + 2 = 1 1 ( 1 - 5 ) -2 Dist [ 1 ] = -1 Dist [ 5 ] = 2 If : Dist [ 5 ] > Dist [ 1 ] + ( -2 ) Yes Update : Dist [ 5 ] = -1 + -2 = -3 1 ( 2 - 3 ) 5 Dist [ 2 ] = 1 Dist [ 3 ] = 999999999 If : Dist [ 3 ] > Dist [ 2 ] + ( 5 )Yes Update : Dist [ 3 ] = 1 + 5 = 6 1 ( 2 - 4 ) 1 Dist [ 2 ] = 1 Dist [ 4 ] = 999999999 If : Dist [ 4 ] > Dist [ 2 ] + ( 1 )Yes Update : Dist [ 4 ] = 1 + 1 = 2 1 ( 4 - 3 ) -4 Dist [ 4 ] = 2 Dist [ 3 ] = 6 If : Dist [ 3 ] > Dist [ 4 ] + ( -4 )Yes Update : Dist [ 3 ] = 6 + (-4) = 2 1 ( 4 - 5 ) 3 Dist [ 4 ] = 2 Dist [ 5 ] = -3 If : Dist [ 5 ] > Dist [ 4 ] + ( 3 )No No change : Dist [ 5 ] = -3 1 ( 5 - 1 ) 2 Dist [ 5 ] = -3 Dist [ 1 ] = -1 If : Dist [ 1 ] > Dist [ 5 ] + ( 2 )No No change : Dist [ 1 ] = -1 1 ( 5 - 2 ) 3 Dist [ 5 ] = -3 Dist [ 2 ] = 1 If : Dist [ 2 ] > Dist [ 5 ] + ( 3 )Yes Update Dist [ 2 ] = -3 + 3 = 0 … the algorithm continues with iterations 2, 3, 4, 5 and 6 (number of nodes). During each iteration the shortest path from source node to other nodes is updated. Graph type : Designed for directed graph containing positive and negative edge weights. Time complexity of Bellman-Ford’s algorithm : O ( E . V ) . V is the number of vertices and E is the number of edges in a graph. Bellman-Ford’s shortest implementation class Edge : def __init__(self, src, dst, weight) : self . src = src self . dst = dst self . weight = weight class Graph : def __init__(self, edge_list, node_cnt) : self . edge_list = edge_list self . node_cnt = node_cnt def BellmanFord (self, src) : # Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0. distance = [ 999999999999 ] * self . node_cnt distance[src] = 0 for node in range(self . node_cnt) : for edge in self . edge_list : if (distance[edge . dst] > distance[edge . src] + edge . weight) : distance[edge . dst] = distance[edge . src] + edge . weight for edge in self . edge_list : if (distance[edge . dst] > distance[edge . src] + edge . weight) : print( "Negative weight cycle exist in the graph" ) for node in range(self . node_cnt) : print( "Source Node(" + str(src) + ") -> Destination Node(" + str(node) + ") : Length => " + str(distance[node])) def main () : e01 = Edge( 0 , 1 , - 1 ) e05 = Edge( 0 , 5 , 2 ) e12 = Edge( 1 , 2 , 2 ) e15 = Edge( 1 , 5 , - 2 ) e23 = Edge( 2 , 3 , 5 ) e24 = Edge( 2 , 4 , 1 ) e43 = Edge( 4 , 3 , - 4 ) e45 = Edge( 4 , 5 , 3 ) e51 = Edge( 5 , 1 , 2 ) e52 = Edge( 5 , 2 , 3 ) edge_list = [e01, e05, e12, e15, e23, e24, e43, e45, e51, e52] node_cnt = 6 source_node = 0 g = Graph(edge_list, node_cnt) g . BellmanFord(source_node) if __name__ == "__main__" : main() Output Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 #include<iostream> #include<vector> #include<list> using namespace std; class Edge { public : Edge( int arg_src, int arg_dst, int arg_weight) : src(arg_src), dst(arg_dst), weight(arg_weight) {} int src; int dst; int weight; }; class Graph { private : int node_count; list < Edge > edge_list; public : Graph ( int arg_node_count, list < Edge > arg_edge_list) : node_count(arg_node_count), edge_list(arg_edge_list) {} void BellmanFord ( int src) { // Initialize the distance / cost from the source node to all other nodes to some max value. vector < int > distance(node_count, 999999999 ); // Distance/cost from the source node to itself is 0. distance[src] = 0 ; for ( int i = 0 ; i < node_count; i ++ ) { for ( auto & it : edge_list) { if (distance[it.dst] > distance[it.src] + it.weight) { distance[it.dst] = distance[it.src] + it.weight; } } } for ( auto & it : edge_list) { if (distance[it.dst] > distance[it.src] + it.weight) { cout << "Negative weight cycle exist in the graph !!!" << endl; } } for ( int i = 0 ; i < node_count; i ++ ) cout << "Source Node(" << src << ") -> Destination Node(" << i << ") : Length => " << distance[i] << endl; } }; int main (){ Edge e01( 0 , 1 , - 1 ); Edge e05( 0 , 5 , 2 ); Edge e12( 1 , 2 , 2 ); Edge e15( 1 , 5 , - 2 ); Edge e23( 2 , 3 , 5 ); Edge e24( 2 , 4 , 1 ); Edge e43( 4 , 3 , - 4 ); Edge e45( 4 , 5 , 3 ); Edge e51( 5 , 1 , 2 ); Edge e52( 5 , 2 , 3 ); int node_count = 6 ; int source_node = 0 ; list < Edge > edge_list = { e01, e05, e12, e15, e23, e24, e43, e45, e51, e52 }; Graph g(node_count, edge_list); g.BellmanFord(source_node); return 0 ; } Output Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 import java.util.ArrayList; import java.util.List; import java.util.Collections; class Edge { Edge( int arg_src, int arg_dst, int arg_weight) { this . src = arg_src; this . dst = arg_dst; this . weight = arg_weight; } int src; int dst; int weight; } class Graph { int node_count; List < Edge > edge_list; Graph ( int arg_node_count, List < Edge > arg_edge_list) { this . node_count = arg_node_count; this . edge_list = arg_edge_list; } void BellmanFord ( int src) { // Initialize the distance/cost from the source node to all other nodes to some max value. Long INF = ( long ) 999999999; List < Long > distance = new ArrayList < Long > (Collections. nCopies (node_count, INF)); // Distance/cost from the source node to itself is 0. distance. set (src, ( long ) 0); for ( int i = 0; i < node_count; i ++ ) { for (Edge it : edge_list) { if (distance. get (it. dst ) > distance. get (it. src ) + it. weight ) { distance. set (it. dst , distance. get (it. src ) + it. weight ); } } } for (Edge it : edge_list) { if (distance. get (it. dst ) > distance. get (it. src ) + it. weight ) { System. out . println ( "Negative weight cycle exist in the graph !!!" ); } } for ( int i = 0; i < node_count; i ++ ) System. out . println ( "Source Node(" + src + ") -> Destination Node(" + i + ") : Length => " + distance. get (i)); } public static void main (String [] args) { Edge e01 = new Edge(0, 1, - 1); Edge e05 = new Edge(0, 5, 2); Edge e12 = new Edge(1, 2, 2); Edge e15 = new Edge(1, 5, - 2); Edge e23 = new Edge(2, 3, 5); Edge e24 = new Edge(2, 4, 1); Edge e43 = new Edge(4, 3, - 4); Edge e45 = new Edge(4, 5, 3); Edge e51 = new Edge(5, 1, 2); Edge e52 = new Edge(5, 2, 3); int node_count = 6; int source_node = 0; List < Edge > edge_list = new ArrayList <> (); Collections. addAll (edge_list, e01, e05, e12, e15, e23, e24, e43, e45, e51, e52); Graph g = new Graph(node_count, edge_list); g. BellmanFord (source_node); } } Output Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 © 2019-2026 Algotree.org \| All rights reserved. This content is provided for educational purposes. Feel free to learn, practice, and share knowledge. For questions or contributions, visit algotree.org "First, solve the problem. Then, write the code. - John Johnson"
Markdown	AlgoTree - [Home](https://www.algotree.org/) - [Algorithms](https://www.algotree.org/algorithms/) - [Sorting Algorithms](https://www.algotree.org/algorithms/sorting/) - [Merge Sort](https://www.algotree.org/algorithms/sorting/mergesort/) - [QuickSort](https://www.algotree.org/algorithms/sorting/quicksort/) - [Binary Search](https://www.algotree.org/algorithms/binary_search/) - [Searching a number in a 2D Sorted Matrix](https://www.algotree.org/algorithms/binary_search/search_an_element_in_2d_sorted_matrix/) - [Binary Search : Counting Duplicates 🤡 🤡](https://www.algotree.org/algorithms/binary_search/duplicates/) - [Binary Search : Finding Square Root √](https://www.algotree.org/algorithms/binary_search/squareroot/) - [Smallest Number In A Rotated Sorted Array](https://www.algotree.org/algorithms/binary_search/smallest_number_in_a_rotated_sorted_array/) - [Search Number In A Rotated Sorted Array ↻](https://www.algotree.org/algorithms/binary_search/search_number_in_a_rotated_sorted_array/) - [Binary Search : Allocate books 📚](https://www.algotree.org/algorithms/binary_search/allot_books/) - [Binary Search : Ship packages 🚢](https://www.algotree.org/algorithms/binary_search/ship_packages/) - [Range Minimum Queries ( RMQ ) : Sparse Table](https://www.algotree.org/algorithms/sparse_table/) - [Binary Indexed Tree ( Fenwick Tree ) 🗂](https://www.algotree.org/algorithms/binary_indexed_trees/) - [Adjacency Lists](https://www.algotree.org/algorithms/adjacency_list/) - [\[ C++ \] : Storing Graph As An Adjacency List](https://www.algotree.org/algorithms/adjacency_list/graph_as_adjacency_list_c++/) - [\[ Java \] : Storing Graph As An Adjacency List](https://www.algotree.org/algorithms/adjacency_list/graph_as_adjacency_list_java/) - [\[ Python \] : Storing Graph As An Adjacency List](https://www.algotree.org/algorithms/adjacency_list/graph_as_adjacency_list_python/) - [Tree & Graph Traversals](https://www.algotree.org/algorithms/tree_graph_traversal/) - [Pre-Order, In-Order & Post-Order Traversals](https://www.algotree.org/algorithms/tree_graph_traversal/pre_in_post_order/) - [In-Order & Pre-Order : Construct Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/construct_tree_from_inorder_preorder/) - [In-Order & Post-Order : Construct Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/construct_tree_from_inorder_postorder/) - [Level Order Tree Traversal](https://www.algotree.org/algorithms/tree_graph_traversal/level_order/) - [Right View Of A Binary Tree 🌲 ←](https://www.algotree.org/algorithms/tree_graph_traversal/right_view_of_a_binary_tree/) - [Level Order : Sum Of The Deepest Leaves](https://www.algotree.org/algorithms/tree_graph_traversal/deepest_leaves_sum/) - [Top View Of A Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/top_view_of_binary_tree/) - [Balance Binary Search Tree ⚖](https://www.algotree.org/algorithms/tree_graph_traversal/balancing_binary_search_tree/) - [Level Order : Minimum Depth Of A Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/minimum_depth_of_a_binary_tree/) - [Breadth First Search ( BFS )](https://www.algotree.org/algorithms/tree_graph_traversal/breadth_first_search/) - [BFS : Finding Max Area Of An Island](https://www.algotree.org/algorithms/tree_graph_traversal/breadth_first_search/max_area_of_island/) - [BFS : Finding The Number Of Islands 🏝 🏝](https://www.algotree.org/algorithms/tree_graph_traversal/breadth_first_search/finding_number_of_islands/) - [Depth First Search ( DFS )](https://www.algotree.org/algorithms/tree_graph_traversal/depth_first_search/) - [DFS : Finding Longest Path In A Tree](https://www.algotree.org/algorithms/tree_graph_traversal/depth_first_search/longest_path_in_a_tree/) - [DFS : All Paths In A Directed Acyclic Graph](https://www.algotree.org/algorithms/tree_graph_traversal/depth_first_search/all_paths_in_a_graph/) - [DFS : Detecting Cycle In A Directed Graph ➰](https://www.algotree.org/algorithms/tree_graph_traversal/depth_first_search/cycle_detection_in_directed_graphs/) - [DFS : Detecting Cycle In An Undirected Graph](https://www.algotree.org/algorithms/tree_graph_traversal/depth_first_search/cycle_detection_in_undirected_graphs/) - [Topological Sort](https://www.algotree.org/algorithms/tree_graph_traversal/topological_sort/) - [\[ C++ \] : Lexical Topological Sort](https://www.algotree.org/algorithms/tree_graph_traversal/lexical_topological_sort_c++/) - [\[ Python \] : Lexical Topological Sort](https://www.algotree.org/algorithms/tree_graph_traversal/lexical_topological_sort_python/) - [Finding A Binary Subtree In A Tree](https://www.algotree.org/algorithms/tree_graph_traversal/finding_binary_subtree/) - [Finding Diameter of a Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/finding_diameter_of_a_binary_tree/) - [Deleting Leaf Nodes In A Binary Tree](https://www.algotree.org/algorithms/tree_graph_traversal/deleting_leaf_nodes_in_a_binary_tree/) - [Merging Binary Trees](https://www.algotree.org/algorithms/tree_graph_traversal/merging_binary_trees/) - [Binary Search Tree](https://www.algotree.org/algorithms/tree_graph_traversal/binary_search_tree/) - [Searching A Binary Search Tree](https://www.algotree.org/algorithms/tree_graph_traversal/binary_search_tree/search_a_binary_search_tree/) - [Validating A Binary Search Tree](https://www.algotree.org/algorithms/tree_graph_traversal/binary_search_tree/validating_a_binary_search_tree/) - [Inserting Into A Binary Search Tree](https://www.algotree.org/algorithms/tree_graph_traversal/binary_search_tree/inserting_into_a_binary_search_tree/) - [Height-Balanced Tree Check Using Recursion](https://www.algotree.org/algorithms/tree_graph_traversal/recursively_checking_height_balanced_tree/) - [Height-Balanced Tree Check Using Traversal](https://www.algotree.org/algorithms/tree_graph_traversal/tree_traversal_check_height_balanced/) - [Heap](https://www.algotree.org/algorithms/heap/) - [\[ C++ \] : Max & Min Heap ( Priority Queue / Set )](https://www.algotree.org/algorithms/heap/maxheap_minheap_c++/) - [\[ Python \] : Max & Min Heap ( HeapQ )](https://www.algotree.org/algorithms/heap/maxheap_minheap_python/) - [K Most Frequent Elements In An Array](https://www.algotree.org/algorithms/heap/k_most_frequent_array_elements/) - [K'th largest and smallest element in an array](https://www.algotree.org/algorithms/heap/kth_largest_and_smallest_element_in_array/) - [Merge K Sorted Linked Lists](https://www.algotree.org/algorithms/heap/merge_k_sorted_linked_lists/) - [Stack](https://www.algotree.org/algorithms/stack_based/) - [Expression Conversion : Infix To Postfix](https://www.algotree.org/algorithms/stack_based/infix_to_postfix/) - [Evaluating An Infix Expression](https://www.algotree.org/algorithms/stack_based/evaluate_infix/) - [Largest Rectangle In A Histogram 📊](https://www.algotree.org/algorithms/stack_based/largest_rectangle_in_histogram/) - [Max Size 1 Filled Rectangle In A Binary Matrix](https://www.algotree.org/algorithms/stack_based/maximum_size_rectangle_in_a_binary_matrix/) - [Stock Span Problem 📈](https://www.algotree.org/algorithms/stack_based/stock_span_problem/) - [Longest Valid Parentheses](https://www.algotree.org/algorithms/stack_based/longest_valid_parentheses/) - [Hash Table & Set](https://www.algotree.org/algorithms/hash_table_and_set/) - [Finding Anagrams](https://www.algotree.org/algorithms/hash_table_and_set/finding_anagrams/) - [Grouping Anagrams](https://www.algotree.org/algorithms/hash_table_and_set/grouping_anagrams/) - [Longest Substring w/o Repeating Characters](https://www.algotree.org/algorithms/hash_table_and_set/substring_without_repeating_characters/) - [Linked List 🔗🔗🔗🔗](https://www.algotree.org/algorithms/linkedlists/) - [Singly Linked List : Insert & Append](https://www.algotree.org/algorithms/linkedlists/single_linked_list_insert_and_append/) - [Singly Linked List : Reverse](https://www.algotree.org/algorithms/linkedlists/single_linked_list_reverse/) - [Singly Linked List : Detect Cycle](https://www.algotree.org/algorithms/linkedlists/singly_linked_list_detect_cycle/) - [Singly Linked List : Remove Duplicates](https://www.algotree.org/algorithms/linkedlists/remove_duplicates_from_sorted_linked_list/) - [Doubly Linked List : Insert, Append & Delete](https://www.algotree.org/algorithms/linkedlists/doubly_linked_list/) - [Backtracking](https://www.algotree.org/algorithms/backtracking/) - [N Queens problem ♛ ♛ ♛ ♛ ♛ ♛ ♛ ♛](https://www.algotree.org/algorithms/backtracking/nqueens/) - [Backtracking + DFS : A Game Of Boggle](https://www.algotree.org/algorithms/backtracking/boggle/) - [Letter Phone 📱](https://www.algotree.org/algorithms/backtracking/letter_phone/) - [Generating Integer Partitions](https://www.algotree.org/algorithms/backtracking/integer_partitions/) - [Partition N Elements Into K Non-Empty Subsets](https://www.algotree.org/algorithms/backtracking/partition_n_elements_into_k_nonempty_subsets/) - [Palindrome Partitioning](https://www.algotree.org/algorithms/backtracking/palindrome_partitioning/) - [Break a string into a given set of words](https://www.algotree.org/algorithms/backtracking/word_break/) - [Greedy](https://www.algotree.org/algorithms/greedy/) - [Light Bulbs 💡 💡 💡 💡 💡](https://www.algotree.org/algorithms/greedy/light_bulbs/) - [Disjoint-Set : Union By Rank, Path Compression](https://www.algotree.org/algorithms/disjoint_set/) - [Lowest Common Ancestor ( LCA )](https://www.algotree.org/algorithms/lowest_common_ancestor/) - [Finding The LCA Using Recursion](https://www.algotree.org/algorithms/lowest_common_ancestor/lca_recursive/) - [Finding The LCA Using Upward Traversals](https://www.algotree.org/algorithms/lowest_common_ancestor/lca_upwardtraversal/) - [Finding The LCA By Moving Level Up And Closer](https://www.algotree.org/algorithms/lowest_common_ancestor/lca_hopandmovecloser/) - [Minimum Spanning Tree Algorithms](https://www.algotree.org/algorithms/minimum_spanning_tree/) - [\[ Python \] : Prim's Minimum Spanning Tree](https://www.algotree.org/algorithms/minimum_spanning_tree/prims_python/) - [\[ Java \] : Prim's Minimum Spanning Tree](https://www.algotree.org/algorithms/minimum_spanning_tree/prims_java/) - [\[ C++ \] : Prim's Minimum Spanning Tree](https://www.algotree.org/algorithms/minimum_spanning_tree/prims_c++/) - [Kruskal's Minimum Spanning Tree](https://www.algotree.org/algorithms/minimum_spanning_tree/kruskals/) - [Single Source Shortest Path Algorithms](https://www.algotree.org/algorithms/single_source_shortest_path/) - [\[ Python \] : Dijkstra's Shortest Path](https://www.algotree.org/algorithms/single_source_shortest_path/dijkstras_shortest_path_python/) - [\[ C++ \] : Dijkstra's Shortest Path](https://www.algotree.org/algorithms/single_source_shortest_path/dijkstras_shortest_path_c++/) - [\[ Java \] : Dijkstra's Shortest Path](https://www.algotree.org/algorithms/single_source_shortest_path/dijkstras_shortest_path_java/) - [Bellman-Ford's Shortest Path Algorithm](https://www.algotree.org/algorithms/single_source_shortest_path/bellman_ford_shortest_path/) - [Bellman Ford's Algorithm For DAG](https://www.algotree.org/algorithms/single_source_shortest_path/bellman_ford_on_dag/) - [All Pairs Shortest Path : Floyd-Warshall](https://www.algotree.org/algorithms/floyd-warshall/) - [Numeric 🔢](https://www.algotree.org/algorithms/numeric/) - [Fibonacci Sequence 🧬](https://www.algotree.org/algorithms/numeric/fibonacci_sequence/) - [Euler's Totient Function](https://www.algotree.org/algorithms/numeric/euler_totient/) - [Prime Sieve : Generating Prime Numbers](https://www.algotree.org/algorithms/numeric/prime_sieve/) - [Prime Factors](https://www.algotree.org/algorithms/numeric/prime_factors/) - [Euclid's : Finding The Greatest Common Divisor](https://www.algotree.org/algorithms/numeric/euclid_gcd/) - [Factorials Of Large Numbers \!](https://www.algotree.org/algorithms/numeric/large_factorials/) - [Fast Exponentiation](https://www.algotree.org/algorithms/numeric/fast_exponentiation/) - [Modular Multiplication & Exponentiation](https://www.algotree.org/algorithms/numeric/modular_multiplication_exponentiation/) - [Prime Or Non Prime ( Miller-Rabin )](https://www.algotree.org/algorithms/numeric/check_if_prime_miller_rabin/) - [Pythagorean Triples 📐](https://www.algotree.org/algorithms/numeric/pythagorean_triples/) - [Pythagorean Triples In An Array 📐](https://www.algotree.org/algorithms/numeric/pythagorean_triples_in_an_array/) - [Binomial Coefficients](https://www.algotree.org/algorithms/numeric/binomial_coefficients/) - [Subsets / Combinations : Bitwise](https://www.algotree.org/algorithms/numeric/subsets_bitwise/) - [Subsets Using Permutations](https://www.algotree.org/algorithms/numeric/subsets_next_permutation/) - [Integer To Hexadecimal Conversion](https://www.algotree.org/algorithms/numeric/integer_to_hex/) - [Matrix Multiplication](https://www.algotree.org/algorithms/numeric/matrix_multiplication/) - [Sudoku](https://www.algotree.org/algorithms/sudoku/) - [Validate A Given Sudoku](https://www.algotree.org/algorithms/sudoku/validate_sudoku/) - [Computational Geometry](https://www.algotree.org/algorithms/computational_geometry/) - [Line Segment Intersection](https://www.algotree.org/algorithms/computational_geometry/line_segment_intersection/) - [Bitwise Operations](https://www.algotree.org/algorithms/bitwise/) - [Number Of Set Bits In An Integer](https://www.algotree.org/algorithms/bitwise/count_set_bits/) - [Toggle Last Set Bit](https://www.algotree.org/algorithms/bitwise/toggle_last_set_bit/) - [Swapping Integers Using Bitwise XOR](https://www.algotree.org/algorithms/bitwise/swap_integers/) - [Binary To Decimal Conversion](https://www.algotree.org/algorithms/bitwise/binary_to_decimal/) - [Recursive Algorithms 🌀 🌀 🌀](https://www.algotree.org/algorithms/recursive/) - [Recursive : Finding the N'th Fibonacci number](https://www.algotree.org/algorithms/recursive/generate_nth_fibonacci_number/) - [Recursive : Generating Permutations](https://www.algotree.org/algorithms/recursive/permutations_recursion/) - [Recursive : Generating Subsets / Combinations](https://www.algotree.org/algorithms/recursive/subsets_recursion/) - [Recursive : Dollar sack 💰💰💰](https://www.algotree.org/algorithms/recursive/dollar_sack/) - [Recursive : Generating Subsequences](https://www.algotree.org/algorithms/recursive/generate_all_subsequences/) - [Recursive : Generating All Balanced Parenthesis](https://www.algotree.org/algorithms/recursive/generating_all_balanced_parenthesis/) - [Recursive : Word Search](https://www.algotree.org/algorithms/recursive/word_search/) - [Recursive : Tower Of Hanoi 🗼](https://www.algotree.org/algorithms/recursive/tower_of_hanoi/) - [Recursive : Finding Max Depth Of A Binary Tree](https://www.algotree.org/algorithms/recursive/maximum_depth_of_a_binary_tree/) - [Cache](https://www.algotree.org/algorithms/cache/) - [LFU ( Least Frequently Used ) Cache](https://www.algotree.org/algorithms/cache/lfu_cache/) - [LRU ( Least Recently Used ) Cache](https://www.algotree.org/algorithms/cache/lru_cache/) - [Dynamic Programming](https://www.algotree.org/algorithms/dynamic_programming/) - [Longest Common Subsequence 🧬](https://www.algotree.org/algorithms/dynamic_programming/longest_common_subsequence/) - [Longest Increasing Subsequence 🧬](https://www.algotree.org/algorithms/dynamic_programming/longest_increasing_subsequence/) - [Distinct Subsequences 🧬](https://www.algotree.org/algorithms/dynamic_programming/distinct_subsequences/) - [Matrix Chain Multiplication ⛓ ❌ ⛓ ❌ ⛓](https://www.algotree.org/algorithms/dynamic_programming/matrix_chain_multiplication/) - [Finding Longest Palindromic Substring](https://www.algotree.org/algorithms/dynamic_programming/longest_palindromic_substring/) - [Minimum Cuts To Make A Palindrome ✂ ✂](https://www.algotree.org/algorithms/dynamic_programming/minimum_cuts_to_make_string_palindrome/) - [Word Break](https://www.algotree.org/algorithms/dynamic_programming/word_break/) - [String Interleave](https://www.algotree.org/algorithms/dynamic_programming/string_interleave/) - [0-1 Knapsack Problem 💰](https://www.algotree.org/algorithms/dynamic_programming/0_1_knapsack/) - [Coins Change Problem 🪙](https://www.algotree.org/algorithms/dynamic_programming/coins_change/) - [Minimum Coins For Making Change 💵 🪙](https://www.algotree.org/algorithms/dynamic_programming/minimum_coins_for_change/) - [Integer Partitioning Problem](https://www.algotree.org/algorithms/dynamic_programming/integer_partitioning/) - [Subset Sum Problem ⊆](https://www.algotree.org/algorithms/dynamic_programming/subset_sum_problem/) - [Maximum Product Subarray Problem](https://www.algotree.org/algorithms/dynamic_programming/maximum_product_subarray/) - [Maximum Sum Subarray Problem](https://www.algotree.org/algorithms/dynamic_programming/maximum_sum_subarray/) - [Finding Size Of Biggest 1 Filled Square](https://www.algotree.org/algorithms/dynamic_programming/maximal_square/) - [Maximum Sum SubRectangle](https://www.algotree.org/algorithms/dynamic_programming/maximum_sum_subrectangle/) - [Using Aggregate Rectangles](https://www.algotree.org/algorithms/dynamic_programming/maximum_sum_subrectangle/aggregate_rectangles/) - [Applying Kadane's Algorithm On Row Sums](https://www.algotree.org/algorithms/dynamic_programming/maximum_sum_subrectangle/kadane_row_summations/) - [Unique Paths In A Grid ▦](https://www.algotree.org/algorithms/dynamic_programming/unique_paths_in_a_grid/) - [Egg Drop Problem 🥚](https://www.algotree.org/algorithms/dynamic_programming/egg_drop/) - [Assignment Problem Using BitMask](https://www.algotree.org/algorithms/dynamic_programming/assignments_using_bitmask/) - [Edit Distance](https://www.algotree.org/algorithms/dynamic_programming/edit_distance/) - [Climbing Stairs Problem 🪜](https://www.algotree.org/algorithms/dynamic_programming/climbing_stairs/) - [KMP Pattern Match Algorithm](https://www.algotree.org/algorithms/pattern_matching/) - [Minimum Steps To Make Two Strings Anagrams](https://www.algotree.org/algorithms/minimum_step_to_make_anagrams/) - [Trie \[ Python \] \[ Java \]](https://www.algotree.org/algorithms/trie_python_java/) - [Trie \[ C++ \]](https://www.algotree.org/algorithms/trie/) - [Counting Distinct Substrings](https://www.algotree.org/algorithms/trie/all_substrings/) - [Solving Boggle Using Trie & Depth First Search](https://www.algotree.org/algorithms/trie/trie_dfs_boggle/) - [Rubik's Cube](https://www.algotree.org/algorithms/rubik_cube/) - [Solving a 2 x 2 Rubik's Cube 💠](https://www.algotree.org/algorithms/rubik_cube/solving_2x2_rubik_cube/) - [Solving a 3 x 3 Rubik's Cube](https://www.algotree.org/algorithms/rubik_cube/solving_3x3_rubik_cube/) - [A Pinch Of Code](https://www.algotree.org/algorithms/snippets/) - [Java : List - Create & Initialize](https://www.algotree.org/algorithms/snippets/java_list_create_initialize/) - [Java : List Of Arrays](https://www.algotree.org/algorithms/snippets/java_list_of_arrays/) - [Python : Create A Dictionary From A List](https://www.algotree.org/algorithms/snippets/python_create_dictionary_from_list/) - [Python : Sort Dictionary By Value & Key](https://www.algotree.org/algorithms/snippets/python_sort_dictionary/) - [Python : Delete Key & Value from Dictionary](https://www.algotree.org/algorithms/snippets/python_delete_key_from_dictionary/) - [Python : Merge Dictionaries](https://www.algotree.org/algorithms/snippets/python_merge_dictionaries/) - [Python : Two dimensional list.](https://www.algotree.org/algorithms/snippets/python_two_dimensional_list/) - [Python : Convert List Of Strings To List Of Int](https://www.algotree.org/algorithms/snippets/python_list_of_strings_to_list_of_int/) - [Python : Getting Current Date & Time](https://www.algotree.org/algorithms/snippets/python_current_date_time/) - [Python : Decorators](https://www.algotree.org/algorithms/snippets/python_decorators/) - [Python : Reading JSON file](https://www.algotree.org/algorithms/snippets/python_reading_json/) - [Python : Agrument Parser](https://www.algotree.org/algorithms/snippets/python_argument_parser/) - [Python : First & Last N Characters Of A String](https://www.algotree.org/algorithms/snippets/python_first_and_last_n_characters_of_string/) - [Go : Check If File Exists](https://www.algotree.org/algorithms/snippets/golang_check_if_file_exists/) - [Go : Read File Line By Line](https://www.algotree.org/algorithms/snippets/golang_read_file_line_by_line/) - [Go : Extract Pattern Using Regular Expression](https://www.algotree.org/algorithms/snippets/golang_extract_pattern_using_regexp/) - [Go : Check If A Key Exists In A Map ( Dict )](https://www.algotree.org/algorithms/snippets/go_check_if_key_exists_in_a_map/) - [Go : Remove / Hide fields from a struct](https://www.algotree.org/algorithms/snippets/golang_remove_struct_fields/) - [C++ : Compilation Process](https://www.algotree.org/algorithms/snippets/c++_compilation_process/) - [C++ : String conversion upper / lower case](https://www.algotree.org/algorithms/snippets/c++_uppercase_lowercase/) - [C++ : Convert String Of Integers Into A Vector](https://www.algotree.org/algorithms/snippets/c++_convert_string_to_array_of_int/) - [C++ : Static Keyword](https://www.algotree.org/algorithms/snippets/c++_static_keyword/) - [C++ : Copy Constructor](https://www.algotree.org/algorithms/snippets/c++_copy_constructor/) - [C++ : Lvaule and Rvalue](https://www.algotree.org/algorithms/snippets/c++_lvalue_rvalue/) - [C++ : Move Constructor](https://www.algotree.org/algorithms/snippets/c++_move_constructor/) - [C++ : Overload Assignment (=) Operator](https://www.algotree.org/algorithms/snippets/c++_overload_assignment_operator/) - [C++ : Move Assignment Operator](https://www.algotree.org/algorithms/snippets/c++_move_assignment_operator/) - [C++ : Overload Subscript ( \[ \] ) Operator](https://www.algotree.org/algorithms/snippets/c++_overload_subscript_operator/) - [C++ : Member Initializer List](https://www.algotree.org/algorithms/snippets/c++_member_initializer_list/) - [C++ : Singleton Design Pattern](https://www.algotree.org/algorithms/snippets/c++_singleton/) - [C++ : Templates](https://www.algotree.org/algorithms/snippets/c++_templates/) - [C++ : static\_cast & dynamic\_cast](https://www.algotree.org/algorithms/snippets/c++_static_dynamic_cast/) - [C++ : const\_cast & reinterpret\_cast](https://www.algotree.org/algorithms/snippets/c++_const_cast_reinterpret_cast/) - [C++ : Throwing Exceptions From A Destructor](https://www.algotree.org/algorithms/snippets/c++_throwning_exceptions_from_destructor/) - [C++ : Lambda Expression & Callback Functions](https://www.algotree.org/algorithms/snippets/c++_lambda_functions_and_callbacks/) - [C++ : Smart Pointers ( unique, shared, weak )](https://www.algotree.org/algorithms/snippets/c++_smart_pointers/) - [C++ : Initializing A Vector](https://www.algotree.org/algorithms/snippets/c++_initialize_vector/) - [C++ : Threads ( Producer & Consumer )](https://www.algotree.org/algorithms/snippets/c++_threads_producer_consumer/) - [C++ : Threads & Condition Variable 🧵](https://www.algotree.org/algorithms/snippets/c++_threads_conditional_wait/) - [C++ & Boost : Program Options](https://www.algotree.org/algorithms/snippets/c++_boost_program_options_positional_options/) - [C++ & Boost : Parsing XML](https://www.algotree.org/algorithms/snippets/c++_boost_parsing_xml/) - [C++ & Boost : Generating UUID](https://www.algotree.org/algorithms/snippets/c++_boost_uuid/) - [JavaScript : Remove An Item From An Array](https://www.algotree.org/algorithms/snippets/javascript_remove_specific_item_from_array/) - [JavaScript : Accept Only A Numeric Input](https://www.algotree.org/algorithms/snippets/javascript_accept_float_input/) - [JavaScript : Extract Numbers From String](https://www.algotree.org/algorithms/snippets/javascript_extract_numbers_from_string/) - [About](https://www.algotree.org/about/) [Algotree](https://www.algotree.org/) \> [Algorithms](https://www.algotree.org/algorithms/) \> [Single Source Shortest Path](https://www.algotree.org/algorithms/single_source_shortest_path/) \> Bellman-Ford Shortest Path Algorithm [Shortest Path](https://www.algotree.org/tags/shortest-path) [Python](https://www.algotree.org/tags/python) [C++](https://www.algotree.org/tags/c++) [Java](https://www.algotree.org/tags/java) # Bellman-Ford Shortest Path Algorithm The gist of Bellman-Ford single source shortest path algorithm is a below : - Bellman-Ford algorithm finds the shortest path ( in terms of distance / cost ) from a single source in a directed, weighted graph containing positive and negative edge weights. - Bellman-Ford algorithm performs edge relaxation of all the edges for every node. Bellman-Ford Edge Relaxation If ( distance-from-source-to \[ node\_v \] \> distance-from-source-to \[ node\_u \] + weight-of-path-from-node-u-to-v ) then distance-from-source-to \[ node\_v \] = distance-from-source-to \[ node\_u \] + weight-of-path-from-node-u-to-v ) - With negative edge weights in a graph Bellman-Ford algorithm is preferred over [Dijkstra’s](https://algotree.org/algorithms/single_source_shortest_path/dijkstras_shortest_path/) algorithm as Dijkstra’s algorithm cannot handle negative edge weights in a graph. * Below data structures are used for storing the graph before running Bellman-Ford algorithm - EdgeList : List of all the edges in the graph. - EdgeWeight : Map of edges and their corresponding weights. * * Algorithm : Bellman-Ford Single Source Shortest Path ( EdgeList, EdgeWeight ) 1\. Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0. Distance \[ AllNodes \] = 999999999, Distance \[ S \] = 0. 2. For every node in the graph 3. For every edge E in the EdgeList 4. Node\_u = E.first, Node\_v = E.second 5. Weight\_u\_v = EdgeWeight ( Node\_u, Node\_v ) 6. If ( Distance \[ v \] \> Distance \[ u \] + Weight\_u\_v ) 7. Distance \[ v \] = Distance \[ u \] + Weight\_u\_v * Example of single source shortest path from source node 0 using Bellman-Ford algorithm Note: Weight of the path corresponds to the distance / cost between the nodes. Bellman-Ford iteration 1 Dist \[ 0 \] = 0. Distance from source node 0 to itself is 0. Dist \[ 1 \] = Dist \[ 2 \] = Dist \[ 3 \] = Dist \[ 4 \] = Dist \[ 5 \] = 999999999. Initialize the distance from the source node 0 to all other nodes to a max value (ex:999999999). \| Node CountIteration \| Edge (U-V) \| Weight (Cost/Distance) of Edge (U-V) \| Distance from source to node ‘U’ \| Distance from source to node ‘V’ \| Update \| \|---\|---\|---\|---\|---\|---\| \| 1 \| ( 0 - 1 ) \| \-1 \| Dist \[ 0 \] = 0 \| Dist \[ 1 \] = 999999999 \| If : Dist \[ 1 \] \> Dist \[ 0 \] + ( -1 ) Yes Update : Dist \[ 1 \] = 0 + -1 = -1 \| \| 1 \| ( 0 - 5 ) \| 2 \| Dist \[ 0 \] = 0 \| Dist \[ 5 \] = 999999999 \| If : Dist \[ 5 \] \> Dist \[ 0 \] + ( 2 ) Yes Update : Dist \[ 5 \] = 0 + 2 = 2 \| \| 1 \| ( 1 - 2 ) \| 2 \| Dist \[ 1 \] = -1 \| Dist \[ 2 \] = 999999999 \| If : Dist \[ 2 \] \> Dist \[ 1 \] + ( 2 ) Yes Update : Dist \[ 2 \] = -1 + 2 = 1 \| \| 1 \| ( 1 - 5 ) \| \-2 \| Dist \[ 1 \] = -1 \| Dist \[ 5 \] = 2 \| If : Dist \[ 5 \] \> Dist \[ 1 \] + ( -2 ) Yes Update : Dist \[ 5 \] = -1 + -2 = -3 \| \| 1 \| ( 2 - 3 ) \| 5 \| Dist \[ 2 \] = 1 \| Dist \[ 3 \] = 999999999 \| If : Dist \[ 3 \] \> Dist \[ 2 \] + ( 5 )Yes Update : Dist \[ 3 \] = 1 + 5 = 6 \| \| 1 \| ( 2 - 4 ) \| 1 \| Dist \[ 2 \] = 1 \| Dist \[ 4 \] = 999999999 \| If : Dist \[ 4 \] \> Dist \[ 2 \] + ( 1 )Yes Update : Dist \[ 4 \] = 1 + 1 = 2 \| \| 1 \| ( 4 - 3 ) \| \-4 \| Dist \[ 4 \] = 2 \| Dist \[ 3 \] = 6 \| If : Dist \[ 3 \] \> Dist \[ 4 \] + ( -4 )Yes Update : Dist \[ 3 \] = 6 + (-4) = 2 \| \| 1 \| ( 4 - 5 ) \| 3 \| Dist \[ 4 \] = 2 \| Dist \[ 5 \] = -3 \| If : Dist \[ 5 \] \> Dist \[ 4 \] + ( 3 )No No change : Dist \[ 5 \] = -3 \| \| 1 \| ( 5 - 1 ) \| 2 \| Dist \[ 5 \] = -3 \| Dist \[ 1 \] = -1 \| If : Dist \[ 1 \] \> Dist \[ 5 \] + ( 2 )No No change : Dist \[ 1 \] = -1 \| \| 1 \| ( 5 - 2 ) \| 3 \| Dist \[ 5 \] = -3 \| Dist \[ 2 \] = 1 \| If : Dist \[ 2 \] \> Dist \[ 5 \] + ( 3 )Yes Update Dist \[ 2 \] = -3 + 3 = 0 \| … the algorithm continues with iterations 2, 3, 4, 5 and 6 (number of nodes). During each iteration the shortest path from source node to other nodes is updated. ![Bellman\_Ford\_Shortest\_Path](https://www.algotree.org/images/Bellman_Ford_Shortest_Path.svg) Graph type : Designed for directed graph containing positive and negative edge weights. Time complexity of Bellman-Ford’s algorithm : O ( E . V ). V is the number of vertices and E is the number of edges in a graph. * * Bellman-Ford’s shortest implementation Python C++ Java ``` class Edge : def __init__(self, src, dst, weight) : self.src = src self.dst = dst self.weight = weight class Graph : def __init__(self, edge_list, node_cnt) : self.edge_list = edge_list self.node_cnt = node_cnt def BellmanFord (self, src) : # Initialize the distance from the source node S to all other nodes as infinite (999999999) and to itself as 0. distance = [999999999999] * self.node_cnt distance[src] = 0 for node in range(self.node_cnt) : for edge in self.edge_list : if (distance[edge.dst] > distance[edge.src] + edge.weight) : distance[edge.dst] = distance[edge.src] + edge.weight for edge in self.edge_list : if (distance[edge.dst] > distance[edge.src] + edge.weight) : print("Negative weight cycle exist in the graph") for node in range(self.node_cnt) : print("Source Node("+str(src)+") -> Destination Node("+str(node)+") : Length => "+str(distance[node])) def main() : e01 = Edge(0, 1, -1) e05 = Edge(0, 5, 2) e12 = Edge(1, 2, 2) e15 = Edge(1, 5, -2) e23 = Edge(2, 3, 5) e24 = Edge(2, 4, 1) e43 = Edge(4, 3, -4) e45 = Edge(4, 5, 3) e51 = Edge(5, 1, 2) e52 = Edge(5, 2, 3) edge_list = [e01, e05, e12, e15, e23, e24, e43, e45, e51, e52] node_cnt = 6 source_node = 0 g = Graph(edge_list, node_cnt) g.BellmanFord(source_node) if __name__ == "__main__": main() ``` Output ``` Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 ``` ``` #include<iostream> #include<vector> #include<list> using namespace std; class Edge { public : Edge(int arg_src, int arg_dst, int arg_weight) : src(arg_src), dst(arg_dst), weight(arg_weight) {} int src; int dst; int weight; }; class Graph { private : int node_count; list<Edge> edge_list; public: Graph (int arg_node_count, list<Edge> arg_edge_list) : node_count(arg_node_count), edge_list(arg_edge_list) {} void BellmanFord (int src) { // Initialize the distance / cost from the source node to all other nodes to some max value. vector<int> distance(node_count, 999999999); // Distance/cost from the source node to itself is 0. distance[src] = 0; for (int i=0; i<node_count; i++) { for (auto& it : edge_list) { if (distance[it.dst] > distance[it.src] + it.weight) { distance[it.dst] = distance[it.src] + it.weight; } } } for (auto& it : edge_list) { if (distance[it.dst] > distance[it.src] + it.weight) { cout << "Negative weight cycle exist in the graph !!!" << endl; } } for (int i=0; i<node_count; i++) cout << "Source Node(" << src << ") -> Destination Node(" << i << ") : Length => " << distance[i] << endl; } }; int main(){ Edge e01(0, 1, -1); Edge e05(0, 5, 2); Edge e12(1, 2, 2); Edge e15(1, 5, -2); Edge e23(2, 3, 5); Edge e24(2, 4, 1); Edge e43(4, 3, -4); Edge e45(4, 5, 3); Edge e51(5, 1, 2); Edge e52(5, 2, 3); int node_count = 6; int source_node = 0; list<Edge> edge_list = { e01, e05, e12, e15, e23, e24, e43, e45, e51, e52 }; Graph g(node_count, edge_list); g.BellmanFord(source_node); return 0; } ``` Output ``` Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 ``` ``` import java.util.ArrayList; import java.util.List; import java.util.Collections; class Edge { Edge(int arg_src, int arg_dst, int arg_weight) { this.src = arg_src; this.dst = arg_dst; this.weight = arg_weight; } int src; int dst; int weight; } class Graph { int node_count; List<Edge> edge_list; Graph (int arg_node_count, List<Edge> arg_edge_list) { this.node_count = arg_node_count; this.edge_list = arg_edge_list; } void BellmanFord (int src) { // Initialize the distance/cost from the source node to all other nodes to some max value. Long INF = (long) 999999999; List<Long> distance = new ArrayList<Long>(Collections.nCopies(node_count, INF)); // Distance/cost from the source node to itself is 0. distance.set(src, (long) 0); for (int i=0; i<node_count; i++) { for (Edge it : edge_list) { if (distance.get(it.dst) > distance.get(it.src) + it.weight) { distance.set(it.dst, distance.get(it.src) + it.weight); } } } for (Edge it : edge_list) { if (distance.get(it.dst) > distance.get(it.src) + it.weight) { System.out.println("Negative weight cycle exist in the graph !!!"); } } for (int i=0; i<node_count; i++) System.out.println("Source Node(" + src + ") -> Destination Node(" + i + ") : Length => " + distance.get(i)); } public static void main (String[] args) { Edge e01 = new Edge(0, 1, -1); Edge e05 = new Edge(0, 5, 2); Edge e12 = new Edge(1, 2, 2); Edge e15 = new Edge(1, 5, -2); Edge e23 = new Edge(2, 3, 5); Edge e24 = new Edge(2, 4, 1); Edge e43 = new Edge(4, 3, -4); Edge e45 = new Edge(4, 5, 3); Edge e51 = new Edge(5, 1, 2); Edge e52 = new Edge(5, 2, 3); int node_count = 6; int source_node = 0; List<Edge> edge_list = new ArrayList<>(); Collections.addAll(edge_list, e01, e05, e12, e15, e23, e24, e43, e45, e51, e52); Graph g = new Graph(node_count, edge_list); g.BellmanFord(source_node); } } ``` Output ``` Source Node(0) -> Destination Node(0) : Length => 0 Source Node(0) -> Destination Node(1) : Length => -1 Source Node(0) -> Destination Node(2) : Length => 0 Source Node(0) -> Destination Node(3) : Length => -3 Source Node(0) -> Destination Node(4) : Length => 1 Source Node(0) -> Destination Node(5) : Length => -3 ``` * * © 2019-2026 Algotree.org \\| All rights reserved. This content is provided for educational purposes. Feel free to learn, practice, and share knowledge. For questions or contributions, visit [algotree.org](https://algotree.org/) "First, solve the problem. Then, write the code. - John Johnson"
Readable Markdown	null
Shard	174 (laksa)
Root Hash	15388939227391360774
Unparsed URL	org,algotree!www,/algorithms/single_source_shortest_path/bellman_ford_shortest_path/ s443