references
dz / leetcode / referencesSubgraphs
Node Tree
- abstract_data_type
- algorithmic_paradigm
- associative_array
- autocomplete
- backtracking
- binary_search
- binary_search_java
- binary_search_leetcode
- binary_search_tree
- binary_tree
- bottom_up_top_down
- boyer_moore_majority_vote_algorithm
- breadth_first_search
- combinatorial_optimization
- depth_first_search
- disjoint_data_set
- dynamic_programming
- fibbonacci
- floyds_algorithm
- greedy_algorithm
- linked_list
- longest_common_subsequence
- longest_prefix_match
- lowest_common_ancestor
- maximum_subarray_problem
- opionated_guide_binary_search
- optimal_substructure
- optimization_problem
- prefix_sum
- queues
- spell_checker
- tabulation
- tail_call
- tree_rotation
- tree_traversal
- trie
- two_pointer_technique
Nodes
| optimization_problem | |
| content | Optimization Problem (Computer Science): the problem of finding the best solution from all feasible solutions. |
| children | candidate_solution (the "best solution" is a candidate solution) |
| parents | leetcode/problems/322_coin_change |
| hyperlink | https://en.wikipedia.org/wiki/Optimization_problem |
| flashcard (front) | What is an optimization problem? |
| flashcard (back) | the problem of finding the best solution from all feasible solutions. |
| location | knowledge/leetcode/leetcode.dz:30 |
| candidate_solution | |
| content | Candidate solution: member of the set of possible solutions in the feasible region of given problems. |
| parents | optimization_problem |
| flashcard (front) | What is a candidate solution? |
| flashcard (back) | A candidate solution is a solution in the feasible region of given problems. |
| location | knowledge/leetcode/leetcode.dz:38 |
| optimal_substructure | |
| content | Optimal Substructure: in computer sience, a problem is said to have optimal substructure if an optimal solution can be constructed from optimal solutions of its subproblems. |
| children | recurrence_relation (used to represent optimal substructure) |
| parents | leetcode/paradigms/dynamic_programming, leetcode/problems/322_coin_change |
| hyperlink | https://en.wikipedia.org/wiki/Optimal_substructure |
| flashcard (front) | What is optimal substructure? |
| flashcard (back) | Optimal substructure is a property of a problem where an optimal solution can be constructed from optimal solutions of its subproblems. |
| location | knowledge/leetcode/leetcode.dz:47 |
| recurrence_relation | |
| content | Recurrence Relation: In mathematics, a recurrence relation is an equation according to which the n nth term of a sequence of numbers is equal to some combination of the previous terms. |
| parents | optimal_substructure, leetcode/problems/322_coin_change |
| hyperlink | https://en.wikipedia.org/wiki/Recurrence_relation |
| location | knowledge/leetcode/leetcode.dz:65 |
| bottom_up_top_down | |
| content | Bottom-up and Top-down design: are both strategies of information processing and ordering knowledge, used in a variety of fields including software, humanistic and scientific theories (see systemics), and management and organization. In practice they can be seen as a style of thinking, teaching, or leadership. |
| children | memoization (used in top-down DP problems) |
| parents | leetcode/problems/322_coin_change, leetcode/paradigms/dynamic_programming |
| hyperlink | https://en.wikipedia.org/wiki/Bottom%E2%80%93up_and_top%E2%80%93down_design |
| location | knowledge/leetcode/leetcode.dz:83 |
| dynamic_programming | |
| content | Dynamic Programming: A mathematicl optimization method and an algorithmic paradigm. |
| parents | leetcode/paradigms/dynamic_programming |
| hyperlink | https://en.wikipedia.org/wiki/Dynamic_programming |
| location | knowledge/leetcode/leetcode.dz:96 |
| algorithmic_paradigm | |
| content | Algorithmic Paradigm: An algorithmic paradigm is a generic model or framework which underlies the design of a class of algorithms. |
| parents | leetcode/paradigms/algorithmic_paradigm |
| hyperlink | https://en.wikipedia.org/wiki/Algorithmic_paradigm |
| location | knowledge/leetcode/leetcode.dz:102 |
| prefix_sum | |
| content | Prefix Sum |
| parents | leetcode/problems/643_maximum_average_subarray, leetcode/problems/238_product_of_array_except_self |
| hyperlink | https://en.wikipedia.org/wiki/Prefix_sum |
| location | knowledge/leetcode/leetcode.dz:117 |
| binary_search_tree | |
| content | Binary Search Tree |
| parents | leetcode/data_structures/binary_search_tree |
| hyperlink | https://en.wikipedia.org/wiki/Binary_search_tree |
| location | knowledge/leetcode/leetcode.dz:133 |
| tree_traversal | |
| content | tree traversal |
| hyperlink | https://en.wikipedia.org/wiki/Tree_traversal |
| location | knowledge/leetcode/leetcode.dz:142 |
| depth_first_search | |
| content | Depth-First-Search (DFS) |
| parents | leetcode/paradigms/depth_first_search |
| hyperlink | https://en.wikipedia.org/wiki/Depth-first_search |
| location | knowledge/leetcode/leetcode.dz:161 |
| disjoint_data_set | |
| content | Disjoint Data Set: a data structure that stores a collection of disjoint (non-overlapping) sets. |
| parents | leetcode/problems/200_number_of_islands |
| hyperlink | https://en.wikipedia.org/wiki/Disjoint-set_data_structure |
| location | knowledge/leetcode/leetcode.dz:170 |
| breadth_first_search | |
| content | Bread-first search (BFS) |
| parents | leetcode/paradigms/breadth_first_search |
| hyperlink | https://en.wikipedia.org/wiki/Breadth-first_search |
| location | knowledge/leetcode/leetcode.dz:178 |
| binary_search | |
| content | Binary Search: algorithm that finds the position of a target value in a sorted array. |
| children | sorted_array (sorted array is the data structure used in binary search) |
| parents | leetcode/paradigms/binary_search |
| hyperlink | https://en.wikipedia.org/wiki/Binary_search |
| location | knowledge/leetcode/leetcode.dz:197 |
| binary_search_java | |
| content | Binary Search code snippet in Java, with with code comments |
| parents | leetcode/paradigms/binary_search |
| remarks | Recommended by EV |
| hyperlink | https://algs4.cs.princeton.edu/11model/BinarySearch.java.html |
| location | knowledge/leetcode/leetcode.dz:207 |
| sorted_array | |
| content | Sorted Array: an array data structure where each element is sorted in numerical, alphabetical, or some other order. |
| parents | binary_search |
| hyperlink | https://en.wikipedia.org/wiki/Sorted_array |
| location | knowledge/leetcode/leetcode.dz:213 |
| opionated_guide_binary_search | |
| content | An opinionated guide to binary search |
| parents | leetcode/paradigms/binary_search |
| hyperlink | https://leetcode.com/discuss/study-guide/2371234/An-opinionated-guide-to-binary-search- |
| location | knowledge/leetcode/leetcode.dz:220 |
| backtracking | |
| content | Backtracking |
| parents | leetcode/paradigms/backtracking |
| hyperlink | https://en.wikipedia.org/wiki/Backtracking |
| location | knowledge/leetcode/leetcode.dz:228 |
| knapsack_problem | |
| content | Knapsack problem: given a set of items, each with a weight and a value, determine which items to include in the collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. |
| parents | combinatorial_optimization, leetcode/problems/39_combination_sum |
| hyperlink | https://en.wikipedia.org/wiki/Knapsack_problem |
| flashcard (front) | What is the knapsack problem? |
| flashcard (back) | The knapsack problem can be described as: given a set of items, each with a weight and a value, determine which items to include in the collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. |
| location | knowledge/leetcode/leetcode.dz:239 |
| combinatorial_optimization | |
| content | Combinatorial optimization is a subfield of mathematical optimization that consists of finding an optimal object from a finite set of objects,[1] where the set of feasible solutions is discrete or can be reduced to a discrete set. |
| children | knapsack_problem (knapsack problem is a problem in combinatorial optimization) |
| hyperlink | https://en.wikipedia.org/wiki/Combinatorial_optimization |
| location | knowledge/leetcode/leetcode.dz:257 |
| binary_search_leetcode | |
| content | Binary Search Leetcode explore card |
| parents | leetcode/paradigms/binary_search |
| hyperlink | https://leetcode.com/explore/learn/card/binary-search/ |
| location | knowledge/leetcode/leetcode.dz:275 |
| hash_table | |
| content | A hash table is a data structure that implements an associative array, also called a dictionary or map. |
| parents | associative_array, leetcode/data_structures/hash_table |
| hyperlink | https://en.wikipedia.org/wiki/Hash_table |
| location | knowledge/leetcode/leetcode.dz:316 |
| associative_array | |
| content | associative array: an abstract data type that stores a collection of key-value pairs, such that each possible key appears at most once in the collection. |
| children | hash_table (a hash table implements an associative array) |
| hyperlink | https://en.wikipedia.org/wiki/Associative_array |
| location | knowledge/leetcode/leetcode.dz:322 |
| abstract_data_type | |
| content | abstract data type: mathematical model for data types, defined by its behavior (semantics) from the point of view of a user of the data, specifically in terms of possible values, possible operations on the data of this type, and the behavior of these operations. |
| children | stack |
| hyperlink | https://en.wikipedia.org/wiki/Abstract_data_type |
| location | knowledge/leetcode/leetcode.dz:330 |
| stack | |
| content | Stack (abstract data type) |
| parents | abstract_data_type |
| hyperlink | https://en.wikipedia.org/wiki/Stack_(abstract_data_type) |
| location | knowledge/leetcode/leetcode.dz:347 |
| linked_list | |
| content | linked list |
| parents | leetcode/data_structures/linked_list |
| hyperlink | https://en.wikipedia.org/wiki/Linked_list |
| location | knowledge/leetcode/leetcode.dz:361 |
| maximum_subarray_problem | |
| content | Maximum Subarray problem |
| children | kadanes (used to solve maximum subarray problem) |
| parents | leetcode/problems/121_best_time_to_sell_and_buy_stock |
| hyperlink | https://en.wikipedia.org/wiki/Maximum_subarray_problem |
| location | knowledge/leetcode/leetcode.dz:375 |
| kadanes | |
| content | Kadane's algorithm |
| parents | leetcode/problems/121_best_time_to_sell_and_buy_stock, maximum_subarray_problem |
| hyperlink | https://en.wikipedia.org/wiki/Maximum_subarray_problem#Kadane's_algorithm |
| location | knowledge/leetcode/leetcode.dz:381 |
| greedy_algorithm | |
| content | Greedy Algorithm |
| parents | leetcode/paradigms/greedy |
| hyperlink | https://en.wikipedia.org/wiki/Greedy_algorithm |
| location | knowledge/leetcode/leetcode.dz:390 |
| two_pointer_technique | |
| content | Two-Pointer Technique (leetcode) |
| hyperlink | https://leetcode.com/articles/two-pointer-technique/ |
| location | knowledge/leetcode/leetcode.dz:404 |
| lowest_common_ancestor | |
| content | Lowest Common Ancestor: the LCA of two nodes v and w in a tree or DAG is the lowest node that has both v and w as descendants, where we define each node to be a descendant of itself |
| parents | leetcode/problems/235_lowest_common_ancestor_BST |
| hyperlink | https://en.wikipedia.org/wiki/Lowest_common_ancestor |
| location | knowledge/leetcode/leetcode.dz:425 |
| binary_tree | |
| content | Binary Tree: tree data structure in which a node has at most two children: a left child and a right child. |
| parents | leetcode/data_structures/binary_tree |
| hyperlink | https://en.wikipedia.org/wiki/Binary_tree |
| location | knowledge/leetcode/leetcode.dz:452 |
| floyds_algorithm | |
| content | Floyd's Cycle Finding Algorithm |
| children | leetcode/problems/287_find_the_duplicate_number (one solution this problem uses a variant on floyd's algorithm), leetcode/problems/2095_delete_middle_node (fast/slow pointer as seen in floyd's algorithm used to find middle of list), leetcode/data_structures/linked_list/fast_slow_pointer (Floyd's algorithm for cycle detection is the algorithm,most often associated with fast/slow pointers.), leetcode/problems/876_middle_of_linked_list (the fast/slow pointer trick made me think of floyd's algorithm), leetcode/problems/141_linked_list_cycle (Elegant solution with O(n) time and O(1) space) |
| parents | leetcode/data_structures/linked_list |
| hyperlink | https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare |
| flashcard (front) | Describe Floyd's algorithm |
| flashcard (back) | Floyd's algorithm can be used for cycle detection in linked lists (think tortois and hare). You a slow pointer a fast pointer. If there's a cycle, the fast pointer will eventually lap the fast pointer. |
| location | knowledge/leetcode/leetcode.dz:464 |
| queues | |
| content | Queue (Abstract Data Type) |
| parents | leetcode/data_structures/queue |
| hyperlink | https://en.wikipedia.org/wiki/Queue_(abstract_data_type) |
| location | knowledge/leetcode/leetcode.dz:492 |
| boyer_moore_majority_vote_algorithm | |
| content | Boyer-Moore majority vote algorithm |
| parents | leetcode/problems/169_majority_element |
| hyperlink | https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm |
| location | knowledge/leetcode/leetcode.dz:505 |
| tail_call | |
| content | tail call: subroutine performed as the final action of a procedure |
| parents | leetcode/problems/104_max_depth_binary_tree |
| hyperlink | https://en.wikipedia.org/wiki/Tail_call |
| location | knowledge/leetcode/leetcode.dz:581 |
| tree_rotation | |
| content | Tree rotation: an operation on a binary tree that changes the structure without interfering with the order of the elements. |
| parents | leetcode/data_structures/binary_tree, leetcode/problems/450_delete_node_BST |
| hyperlink | https://en.wikipedia.org/wiki/Tree_rotation |
| flashcard (front) | What does a tree rotation do? |
| flashcard (back) | A tree rotation is an operation on a binary tree that changes the structure without interfering with the order of the elements |
| location | knowledge/leetcode/leetcode.dz:884 |
| longest_common_subsequence | |
| content | Longest Common Subsequence (Wikipedia) |
| parents | leetcode/problems/1143_longest_common_subsequence |
| hyperlink | https://en.wikipedia.org/wiki/Longest_common_subsequence |
| location | knowledge/leetcode/leetcode.dz:1037 |
| memoization | |
| content | memoization: adds caching to a function that has no side effects |
| parents | leetcode/paradigms/dynamic_programming, leetcode/glossary/memoization, bottom_up_top_down |
| hyperlink | https://en.wikipedia.org/wiki/Memoization |
| location | knowledge/leetcode/leetcode.dz:1046 |
| tabulation | |
| content | tabulation: uses a table to keep track of subproblem results, and works in a bottom-up manner, solving the smallest subproblems before the large ones in an iterative manner. |
| parents | leetcode/glossary/tabulation, leetcode/paradigms/dynamic_programming |
| location | knowledge/leetcode/leetcode.dz:1057 |
| fibbonacci | |
| children | leetcode/explore/dynamic_programming/0_intro/1_what_is (fibbonacci is a classic example of DP) |
| hyperlink | https://en.wikipedia.org/wiki/Fibonacci_sequence |
| location | knowledge/leetcode/leetcode.dz:1417 |
| trie | |
| parents | leetcode/data_structures/trie |
| hyperlink | https://en.wikipedia.org/wiki/Trie |
| location | knowledge/leetcode/leetcode.dz:1531 |
| autocomplete | |
| parents | leetcode/explore/trie/3_practical_application_1/autocomplete |
| hyperlink | https://en.wikipedia.org/wiki/Autocomplete |
| location | knowledge/leetcode/leetcode.dz:1568 |
| spell_checker | |
| parents | leetcode/explore/trie/3_practical_application_1/spell_checker |
| hyperlink | https://en.wikipedia.org/wiki/Spell_checker |
| location | knowledge/leetcode/leetcode.dz:1571 |
| longest_prefix_match | |
| content | Longest Prefix Match |
| parents | leetcode/explore/trie/4_practical_application_2 |
| hyperlink | https://en.wikipedia.org/wiki/Longest_prefix_match |
| location | knowledge/leetcode/trie.dz:1623 |