If you want to solve problems in the most understandable way, please look for Coding5DotCom.

• Array is consecutive in memory.
• Cannot delete an item. Actually, it is overwrite. Delete a item of array will call the latter items move 1 to left. So it is O(n) time complexity.
• C++ 2D array is also consecutive. But Java is not.

You want to store students' information into a hash table. You want to query information by a student's name.

• index = theHashFunction(student_name) the_information = the_hash_table[index].

boolean mark solution.

• Recursion steps:
  1. Determine the parameters
  2. Determine the recursion logic
  3. Determine the return value
  4. Determine the exit logic

• 647. Palindromic Substrings
• 516. Longest Palindromic Subsequence For solving the above two issues, we can use two-dimensional array. Remember the magic word: 回文串，用一半，内环反.

The principle of dynamic programming is from top to bottom, from left to right, from less to more, from near to far, from known to unknown and take turns being the boss.

• Push indies one by one.
• Only the useful indies are kept in the stack. Useless indices are popped (or eaten by followed larger (or smaller) index).

The principle of traversal (DFS or BFS) between undirected graph or directed graph are similar.

• First rule: don't visited nodes again. This rule make starting from a node to traverse the undirected graph have a direction.

• The adjacent nodes of undirected graph are its non-visited neighbors.

• The adjacent nodes of directed graph are its targeted nodes.

• Truth: An undirected graph can be understood as a bidirectional directed graph. Sometimes, we make use of it.

• Prim's algorithm can be used to minimum spanning a tree. It added the closest node to the tree each time. It uses a min_distances. It is recommended to use a priority_queue.
• Kruskal's algorithm can also be used to minimum spanning a tree, but it adds the shortest edge each time. To combine the two nodes of an edge, UnionFind is used.

• This is graph, not a tree. It can have cycles and many connected components.
• Dijkstra's algorithm finds the shortest path from one vertex to all other vertices. It is like Prim's algorithm, also uses a min_distances, but the distance is to the original source vertex. All the weights of edges must not be a negative value.
• Bellman_Ford algorithm finds the shortest path from one vertex to all other vertices. It effectively works in the cases of negative edges and is able to detect negative weight cycles. It also uses min_distances. Relaxation works by continuously shortening the calculated distance. It's straightforward and easily to be coded. The improved way with a queue is commonly more efficient. Relaxing All Edges by vertices.length – 1 times gives us Single Source Shortest Path to all vertices.
• Bellman_Ford algorithm need to start from one source vertex each time and find the shortest paths to the source vertex. Floyd–Warshall algorithm can find all vertices' shortest paths.
• What Floyd–Warshall algorithm solves can also be done by iterating through vertices and apply Bellman_Ford algorithm on each vertex; But if it is a Dense Graph, Floyd–Warshall algorithm is faster.
• If all edges' weights are not negative, what Floyd–Warshall algorithm solves can also be done by iterating through vertices and apply Dijkstra algorithm on each vertex.
• The time complexity of running V times Dijkstra algorithm is E * logE * V.
• The time complexity of Floyd–Warshall algorithm is V * V * V. For a dense graph, Floyd–Warshall algorithm is still faster.
• A* algorithm use a priority queue, pop() to get the vertex closest to the destination vertex. We need to choose proper math formula to determine which one is the closest. We to the very near place of destination vertex, we can use some special method to make it can handle the last part.

|Algorithm name|Focus|Key implementation methods|mark visited| |Prim's algorithm|Vertices|| |Kruskal's algorithm|Edges|Union-Find| |Dijkstra's algorithm|Vertices|| |Bellman-Ford algorithm|Edges(Vertices+Edges for SPFA)|| |Dijkstra's by heap sort - min_distance = A*| UnionFind + Heap sort = Kruskal BFS + heap sort = A*

Add a table to show the differences between A-Start and breadth-first search

• Find all the prime numbers within 1000000.

• 583 https://leetcode.cn/problems/delete-operation-for-two-strings/ would be better use https://leetcode.cn/problems/delete-operation-for-two-strings/submissions/597725071/ as the first option.

• 704 Binary Search Algorithm

• 27 Fast and Slow Pointers

• 1047 https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/

• 150 https://leetcode.cn/problems/evaluate-reverse-polish-notation/

• 239 https://leetcode.cn/problems/sliding-window-maximum/ tag monotonic queue

• 347 https://leetcode.cn/problems/top-k-frequent-elements/ tag heap sort

• Remember to add the recursion steps (described above in this doc) first

• 144 https://leetcode.cn/problems/binary-tree-preorder-traversal/

• 94 https://leetcode.cn/problems/binary-tree-inorder-traversal/

• 145 https://leetcode.cn/problems/binary-tree-postorder-traversal/

• 102 https://leetcode.cn/problems/binary-tree-level-order-traversal/

  • 107 https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/
  • 199 https://leetcode.cn/problems/binary-tree-right-side-view/
  • 637 https://leetcode.cn/problems/average-of-levels-in-binary-tree/
  • 429 https://leetcode.cn/problems/n-ary-tree-level-order-traversal/
  • 515 https://leetcode.cn/problems/find-largest-value-in-each-tree-row/
  • 116 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/
  • 117 https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/
  • 111 https://leetcode.cn/problems/minimum-depth-of-binary-tree/
  • 513 https://leetcode.cn/problems/find-bottom-left-tree-value

• 104 https://leetcode.cn/problems/maximum-depth-of-binary-tree/

• 226 https://leetcode.cn/problems/invert-binary-tree/

• 101 https://leetcode.cn/problems/symmetric-tree/

  • 100 https://leetcode.cn/problems/same-tree/description/
  • 572 https://leetcode.cn/problems/subtree-of-another-tree/

• 222 https://leetcode.cn/problems/count-complete-tree-nodes/

• 110 https://leetcode.cn/problems/balanced-binary-tree/ 2 ways

• 257 https://leetcode.cn/problems/binary-tree-paths/

• 404 https://leetcode.cn/problems/sum-of-left-leaves/

• 112 https://leetcode.cn/problems/path-sum/

• 105 https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/

• 106 https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

• 654 https://leetcode.cn/problems/maximum-binary-tree/

• 617 https://leetcode.cn/problems/merge-two-binary-trees/

• 700 https://leetcode.cn/problems/search-in-a-binary-search-tree/

• 530 https://leetcode.cn/problems/minimum-absolute-difference-in-bst/ 783 https://leetcode.com/problems/minimum-distance-between-bst-nodes/ is the same

• 501 https://leetcode.cn/problems/find-mode-in-binary-search-tree/

• 701 https://leetcode.cn/problems/insert-into-a-binary-search-tree/ Carl's solution is shorter, but may hard to understand and think about

• 450 https://leetcode.cn/problems/delete-node-in-a-bst/ Carl's solution is shorter

• 669 https://leetcode.cn/problems/trim-a-binary-search-tree/description/

• 108 https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/

• 538 https://leetcode.cn/problems/convert-bst-to-greater-tree/

• 77 https://leetcode.cn/problems/combinations/
• 216 https://leetcode.cn/problems/combination-sum-iii/
• 39 https://leetcode.cn/problems/combination-sum/
• 17 https://leetcode.cn/problems/letter-combinations-of-a-phone-number/
• 78 https://leetcode.cn/problems/subsets/
• 90 https://leetcode.cn/problems/subsets-ii/
• 40 https://leetcode.cn/problems/combination-sum-ii/
• 131 https://leetcode.cn/problems/palindrome-partitioning/
• 93 https://leetcode.cn/problems/restore-ip-addresses/
• 491 https://leetcode.cn/problems/non-decreasing-subsequences/
• 46 https://leetcode.cn/problems/permutations/
• 332 https://leetcode.cn/problems/reconstruct-itinerary/
• 51 https://leetcode.cn/problems/n-queens/

• 455 https://leetcode.cn/problems/assign-cookies/
• 376 https://leetcode.cn/problems/wiggle-subsequence/
• 53 https://leetcode.cn/problems/maximum-subarray/
• 122 https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/
• 55 https://leetcode.cn/problems/jump-game/
• 45 https://leetcode.cn/problems/jump-game-ii/
• 1005 https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/
• 135 https://leetcode.cn/problems/candy/
• 860 https://leetcode.cn/problems/lemonade-change/
• 406 https://leetcode.cn/problems/queue-reconstruction-by-height/
• 452 https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons
• 435 https://leetcode.cn/problems/non-overlapping-intervals/
• 763 https://leetcode.cn/problems/partition-labels/
• 56 https://leetcode.cn/problems/merge-intervals/
• 738 https://leetcode.cn/problems/monotone-increasing-digits/
• 968 https://leetcode.cn/problems/binary-tree-cameras/

• 70 https://leetcode.cn/problems/climbing-stairs/
• 746 https://leetcode.cn/problems/min-cost-climbing-stairs/
• 62 https://leetcode.cn/problems/unique-paths/
• 63 https://leetcode.cn/problems/unique-paths-ii/
• 343 https://leetcode.cn/problems/integer-break/
• 115 https://leetcode.cn/problems/distinct-subsequences/

• 279 https://leetcode.cn/problems/perfect-squares/ can have solution 2

• 647 https://leetcode.cn/problems/palindromic-substrings/ very hard
• 516 https://leetcode.cn/problems/longest-palindromic-subsequence/

• 417 https://leetcode.com/problems/pacific-atlantic-water-flow/
• 399 https://leetcode.com/problems/evaluate-division/ union-find
• 1976 https://leetcode.com/problems/number-of-ways-to-arrive-at-destination/ both use Dijkstra or Bellman-Ford can solve it.
• 1263 https://leetcode.com/problems/minimum-moves-to-move-a-box-to-their-target-location/ A-star
• 695. Max Area of Island 2 other ways should be added with code
• 827 making-a-large-island breadth-first-search should be added with code

• 222 https://leetcode.cn/problems/count-complete-tree-nodes/
• 236 https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/
• 40 https://leetcode.cn/problems/combination-sum-ii/
• 131 https://leetcode.cn/problems/palindrome-partitioning/
• 332 https://leetcode.cn/problems/reconstruct-itinerary/
• 51 https://leetcode.cn/problems/n-queens/
• 37 https://leetcode.cn/problems/sudoku-solver
• 96 https://leetcode.cn/problems/unique-binary-search-trees/ Finished but slow.
• 115 https://leetcode.cn/problems/distinct-subsequences/
• 647 https://leetcode.cn/problems/palindromic-substrings/ https://leetcode.cn/problems/palindromic-substrings/submissions/597748845/
• 516 https://leetcode.cn/problems/longest-palindromic-subsequence/
• 417 https://leetcode.com/problems/pacific-atlantic-water-flow/
• 1584-min-cost-to-connect-all-points-2.md
• 1514-path-with-maximum-probability.md
• 1334 https://leetcode.com/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance
• 752 a star Add A* for 127?
• 3464 https://leetcode.cn/problems/maximize-the-distance-between-points-on-a-square
• https://leetcode.cn/problems/closest-equal-element-queries/
• https://leetcode.cn/problems/rotate-array

• https://leetcode.com/problems/k-closest-points-to-origin/
• https://leetcode.com/problems/find-special-substring-of-length-k/
• https://leetcode.cn/problems/eat-pizzas/
• https://leetcode.cn/problems/merge-intervals/
• https://leetcode.cn/problems/longest-consecutive-sequence
• https://leetcode.cn/problems/container-with-most-water
• https://leetcode.cn/problems/longest-substring-without-repeating-characters
• https://leetcode.cn/problems/product-of-array-except-self/
• https://leetcode.cn/problems/set-matrix-zeroes/
• https://leetcode.cn/problems/copy-list-with-random-pointer/
• https://leetcode.cn/problems/sort-list/
• https://leetcode.cn/problems/maximum-depth-of-binary-tree/
• https://leetcode.cn/problems/invert-binary-tree/
• https://leetcode.cn/problems/symmetric-tree/
• https://leetcode.cn/problems/binary-tree-level-order-traversal
• https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree
• https://leetcode.cn/problems/validate-binary-search-tree
• https://leetcode.cn/problems/kth-smallest-element-in-a-bst
• https://leetcode.cn/problems/binary-tree-right-side-view/
• https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/
• https://leetcode.cn/problems/positions-of-large-groups/
• https://leetcode.cn/problems/masking-personal-information
• https://leetcode.cn/problems/flipping-an-image/
• https://leetcode.cn/contest/weekly-contest-442/problems/maximum-containers-on-a-ship

• 线段树 https://leetcode.cn/problems/fruits-into-baskets-iii

https://leetcode.cn/problems/closest-equal-element-queries