The knuth morris pratt

The Knuth-Morris-Pratt (KMP) algorithm is a string-searching algorithm that efficiently finds occurrences of
a pattern within a text. It avoids unnecessary comparisons by utilizing information about the pattern itself.

NP NP hard
1. **P (Polynomial Time):** Problems that can be solved by a deterministic Turing machine in polynomial
time. This means the running time of the algorithm is polynomial with respect to the size of the input.
2. **NP (Nondeterministic Polynomial Time):** Problems for which a solution can be checked quickly (in
polynomial time) given a proposed solution. It's not known whether every problem in NP can be solved
quickly, but if a solution is provided, it can be verified quickly.
3. **NP-Hard (Nondeterministic Polynomial Time Hard):** A problem is NP-hard if every problem in NP can
be reduced to it in polynomial time. In other words, if you could solve an NP-hard problem in polynomial
time, you could solve any problem in NP in polynomial time.
4. **NP-Complete (Nondeterministic Polynomial Time Complete):** A problem is NP-complete if it is both
NP and NP-hard. NP-complete problems are considered the hardest problems in NP, and if any NP-
complete problem can be solved in polynomial time, then all problems in NP can be solved in polynomial
time.
The relationship between P, NP, NP-hard, and NP-complete is crucial in the field of computational
complexity theory. The central question is whether P equals NP, meaning every problem that can be
checked quickly can also be solved quickly. This question remains unresolved and is one of the most
significant open problems in computer science.

0/1 knapsack
The 0/1 Knapsack Problem is a classic optimization problem. Given a set of items, each with a weight and
a value, determine the maximum value that can be obtained by selecting a subset of the items without
exceeding a given weight capacity.
Here's a simple dynamic programming algorithm for the 0/1 Knapsack Problem:
1. **Initialization:** Create a table, typically a 2D array, where `dp[i][w]` represents the maximum value that
can be obtained with a knapsack capacity of `w` and considering the first `i` items.
2. **Base Case:** Initialize the first row and column of the table with zeros since there are no items to
consider (i.e., `dp[i][0] = dp[0][w] = 0` for all `i` and `w`).
3. **Fill the Table:** For each item `i`, consider whether including it in the knapsack would increase the total
value. Update the table accordingly
4. **Result:** The final result is in `dp[n][W]`, where `n` is the number of items, and `W` is the total capacity
of the knapsack.
This algorithm has a time complexity of O(nW), where `n` is the number of items and `W` is the capacity of
the knapsack. It's a dynamic programming approach that efficiently solves this optimization problem.

The Rabin-Karp algorithm is a string-searching algorithm that searches for a pattern within a text using
hash functions. It's particularly useful for multiple pattern searches.
Here's a simplified explanation of the Rabin-Karp algorithm:
1. **Hash Function:** Choose a hash function to map the characters of the pattern and substrings of the
text to hash values. This hash function should have the property that if two strings are equal, their hash
values are also equal.
2. **Calculate Hashes:** Compute the hash values for the pattern and the initial window of text of the same
length.
3. **Slide and Check:** Slide the window one character at a time and recalculate the hash value for the
new substring. If the hash value of the current substring matches the hash value of the pattern, then
compare character by character to confirm the match.
4. **Rolling Hash:** To efficiently calculate the hash value for the next substring, use a rolling hash
technique that takes advantage of the previous hash value.
The key idea is to quickly eliminate potential matches based on hash values before performing detailed
character-by-character comparisons. This can lead to significant performance improvements, especially in
scenarios with long texts and patterns.
Rabin-Karp has a time complexity of O((n + m) * q), where 'n' is the length of the text, 'm' is the length of the
pattern, and 'q' is the number of possible hash values (size of the hash table). The average-case time
complexity is often better than brute-force algorithms for string matching.
String matching with finite automata is a technique that uses deterministic finite automata (DFAs) to
efficiently search for occurrences of a pattern within a text. The idea is to preprocess the pattern to
construct a DFA that recognizes the pattern, and then use this DFA to scan the text.
Here's a brief overview of the algorithm:

1. **Preprocessing (DFA Construction):**

- Construct a DFA that recognizes the pattern. The states of the DFA represent the characters in the
pattern and transitions are determined by the characters in the alphabet.
- For each state, calculate the "failure function" that indicates where to go in case of a mismatch.

2. **String Matching:**
- Start in the initial state of the DFA.
- Process each character in the text, transitioning between states according to the DFA.
- If a mismatch occurs at some state, use the failure function to efficiently find the next state.

This algorithm avoids unnecessary character comparisons and efficiently skips portions of the text that
cannot match the pattern.

The time complexity for constructing the DFA is O(m * |Σ|), where 'm' is the length of the pattern and |Σ| is
the size of the alphabet. Once the DFA is constructed, the time complexity for string matching is O(n),
where 'n' is the length of the text. The DFA-based approach can be particularly advantageous for multiple
pattern searches and is used in applications like lexical analysis in compilers.
The naive string matching algorithm, also known as the brute-force or straightforward approach, is a
simple method to find all occurrences of a pattern within a text. It involves systematically comparing the
pattern with substrings of the text.

Here's a basic description of the naive string matching algorithm:

1. **Algorithm Steps:**
- Start with the first character of the text.
- For each position in the text, compare the characters of the pattern with the corresponding characters in
the text.
- If a mismatch is found, move to the next position in the text and repeat the comparison.
- If a match is found, record the starting position of the match.
- Continue this process until the end of the text is reached.

2. **Time Complexity:**
- The worst-case time complexity is O((n - m + 1) * m), where 'n' is the length of the text and 'm' is the
length of the pattern.
- In the worst case, the algorithm may need to compare all characters in the pattern with all characters in
each substring of the text.

3. **Advantages and Disadvantages:**

- **Advantage:** Simple to understand and implement.
- **Disadvantage:** Inefficient for large texts or patterns, especially when there are many mismatches.

While the naive algorithm is not the most efficient for large-scale string matching, it serves as a baseline
understanding for more advanced algorithms, such as those based on automata or dynamic programming,
which are designed to improve efficiency.

Matrix chain multiplication is a dynamic programming algorithm that aims to find the most efficient way to
multiply a given sequence of matrices. The goal is to minimize the total number of scalar multiplications
needed to compute the product.

Here are the key steps of the algorithm:

1. **Problem Formulation:**
- Given a sequence of matrices \(A_1, A_2, \ldots, A_n\), where the dimensions of matrix \(A_i\) are \(p_{i-
1} \times p_i\) for \(i = 1, 2, \ldots, n\), the goal is to find the optimal way to parenthesize the matrices to
minimize the total number of scalar multiplications.

2. **Subproblem Definition:**
 - Define the subproblem as finding the optimal parenthesization for a subsequence of matrices \(A_i,
A_{i+1}, \ldots, A_j\).

3. **Recurrence Relation:**

4. **Dynamic Programming Table:**

- Build a table \(m\) to store the results of subproblems, filling it in a bottom-up manner.

5. **Optimal Parenthesization:**
- Backtrack through the table to determine the optimal way to parenthesize the matrices.

6. **Time Complexity:**
- The time complexity is \(O(n^3)\), where \(n\) is the number of matrices.

Matrix chain multiplication is a classic example of dynamic programming, and its application can be
found in various areas, including computer graphics, optimization problems, and numerical simulations.

The Optimal Binary Search Tree (OBST) problem is a classic dynamic programming problem that involves
finding the most efficient binary search tree for a given set of keys with their respective probabilities of
being searched.

Here's an overview of the problem and the algorithm to solve it:

1. **Problem Statement:**
- Given a sorted sequence of keys \(K = \{k_1, k_2, \ldots, k_n\}\) and their probabilities \(P = \{p_1, p_2,
\ldots, p_n\}\), construct a binary search tree with minimum expected search cost.

2. **Dynamic Programming Approach:**

- Define \(C[i, j]\) as the cost of the optimal binary search tree for keys \(k_i, k_{i+1}, \ldots, k_j\).
- The recurrence relation is given by:
\[C[i, j] = \min_{i \leq r \leq j} \left\{C[i, r-1] + C[r+1, j] + \sum_{k=i}^{j} p_k\right\}\]
- This recurrence reflects the optimal substructure of the problem.

3. **Dynamic Programming Table:**

- Build a table \(C\) to store the results of subproblems, filling it in a bottom-up manner.

4. **Optimal Binary Search Tree:**

- Backtrack through the table to determine the structure of the optimal binary search tree.

5. **Time Complexity:**
- The time complexity is \(O(n^3)\), where \(n\) is the number of keys.

The OBST problem is applied in scenarios where efficient search is crucial, such as in compilers for symbol
table lookups and database systems. The dynamic programming approach efficiently finds the optimal
solution by breaking down the problem into smaller subproblems.

The Floyd-Warshall algorithm is a dynamic programming algorithm used for finding the shortest paths
between all pairs of vertices in a weighted graph, including negative-weight edges (but with no negative-
weight cycles). It works for both directed and undirected graphs.

Here's an overview of the Floyd-Warshall algorithm:

1. **Initialization:**
- Create a matrix \(D\) where \(D[i][j]\) represents the shortest distance between vertices \(i\) and \(j\).
- Initialize \(D[i][j]\) to the weight of the edge between \(i\) and \(j\) if there is an edge; otherwise, set it to
infinity.
- Set \(D[i][i]\) to 0 for all \(i\).

2. **Dynamic Programming:**
- For each vertex \(k\), iterate through all pairs of vertices \(i\) and \(j\).
 - Update \(D[i][j]\) to the minimum of its current value and the sum of the distances from \(i\) to \(k\) and
from \(k\) to \(j\):
\[D[i][j] = \min(D[i][j], D[i][k] + D[k][j])\]

3. **Result:**
- The matrix \(D\) will contain the shortest distances between all pairs of vertices.

4. **Negative Cycles:**
- If there is a negative-weight cycle, the algorithm can detect it. The matrix \(D\) will have negative values
on its diagonal after the algorithm is executed.

5. **Time Complexity:**
- The time complexity is \(O(V^3)\), where \(V\) is the number of vertices in the graph.

The Floyd-Warshall algorithm is convenient for dense graphs, where the number of edges is close to
\(V^2\). It's not the most efficient for sparse graphs, as algorithms like Dijkstra's or Bellman-Ford may be
more suitable in those cases.

A Hamiltonian cycle in a graph is a cycle that visits every vertex exactly once and returns to the starting
vertex. If there exists a Hamiltonian cycle in a graph, the graph is said to be Hamiltonian.

Here are some key points related to Hamiltonian cycles:

1. **Existence:**
- Determining whether a Hamiltonian cycle exists in a given graph is an NP-complete problem, meaning
there is no known polynomial-time algorithm for solving it in the general case.

2. **Hamiltonian Path:**
- A Hamiltonian path is a path in a graph that visits every vertex exactly once but may not return to the
starting vertex. If a graph has a Hamiltonian path, it is called a Hamiltonian graph.

3. **Necessary Condition:**
- If a Hamiltonian cycle exists in a graph, removing any single vertex and its incident edges should not
disconnect the graph.

4. **Dirac's Theorem:**
- Dirac's theorem states that if a graph has \(n\) vertices (\(n \geq 3\)) and every vertex has degree at
least \(n/2\), then the graph contains a Hamiltonian cycle.

5. **Ore's Theorem:**
- Ore's theorem is another criterion for the existence of Hamiltonian cycles. If a graph has \(n\) vertices
(\(n \geq 3\)) and for every pair of non-adjacent vertices, the sum of their degrees is at least \(n\), then the
graph contains a Hamiltonian cycle.

6. **Algorithmic Approaches:**
- While finding Hamiltonian cycles in a general graph is computationally hard, various heuristics and
approximation algorithms exist for specific cases or special classes of graphs.

In practice, determining the existence of Hamiltonian cycles often involves applying specific theorems or
using algorithms tailored to the characteristics of the given graph.

Single-source shortest path algorithms are used to find the shortest paths from a single source vertex to
all other vertices in a weighted graph. Two well-known algorithms for this purpose are Dijkstra's algorithm
and Bellman-Ford algorithm. Here's a brief overview of each:

1. **Dijkstra's Algorithm:**
- **Algorithm Steps:**
1. Initialize distances from the source to all other vertices as infinity and the distance to the source itself
as 0.
2. Create a priority queue to store vertices and their current distances.
 3. Process vertices in the priority queue, updating distances to adjacent vertices.
4. Continue until all vertices are processed or the destination is reached.
- **Analysis:**
- Works well for graphs with non-negative weights.
- Time complexity is \(O((V + E) \log V)\), where \(V\) is the number of vertices and \(E\) is the number of
edges.

2. **Bellman-Ford Algorithm:**
- **Algorithm Steps:**
1. Initialize distances from the source to all vertices as infinity and the distance to the source itself as 0.
2. Relax all edges \(V-1\) times, where \(V\) is the number of vertices.
3. If any distance is updated during the \(V\)-th iteration, the graph contains a negative-weight cycle.
- **Analysis:**
- Can handle graphs with negative weights but not negative-weight cycles.
- Time complexity is \(O(VE)\), where \(V\) is the number of vertices and \(E\) is the number of edges.

3. **Comparison:**
- Dijkstra's algorithm is more efficient for graphs with non-negative weights.
- Bellman-Ford is more versatile and can handle graphs with negative weights but is less efficient.
When choosing between these algorithms, consider the characteristics of the graph, specifically whether it
has negative weights or cycles. Additionally, Dijkstra's algorithm is commonly used in scenarios where the
graph is a dense graph (many edges) and has non-negative weights.

Strassen's algorithm is an algorithm for matrix multiplication that was designed to perform fewer
multiplications than the standard matrix multiplication algorithm. It was introduced by Volker Strassen in
1969.

The standard matrix multiplication algorithm (sometimes referred to as the naive algorithm) for two \(n
\times n\) matrices involves \(n^3\) multiplications. Strassen's algorithm reduces this to \(O(n^{\log_2 7})
\approx O(n^{2.81})\) multiplications.

Here's a simplified overview of Strassen's algorithm:

1. **Matrix Splitting:**
- Given two \(n \times n\) matrices, A and B, split them into four \(n/2 \times n/2\) submatrices each:
\(A_{11}, A_{12}, A_{21}, A_{22}\) and \(B_{11}, B_{12}, B_{21}, B_{22}\).

2. **Recursive Steps:**
- Calculate seven products recursively:
\[
\begin{align*}
P_1 &= A_{11} \cdot (B_{12} - B_{22}) \\
P_2 &= (A_{11} + A_{12}) \cdot B_{22} \\
P_3 &= (A_{21} + A_{22}) \cdot B_{11} \\
P_4 &= A_{22} \cdot (B_{21} - B_{11}) \\
P_5 &= (A_{11} + A_{22}) \cdot (B_{11} + B_{22}) \\
P_6 &= (A_{12} - A_{22}) \cdot (B_{21} + B_{22}) \\
P_7 &= (A_{11} - A_{21}) \cdot (B_{11} + B_{12}) \\
\end{align*}
\]

3. **Combine Results:**
- Calculate the four submatrices of the result matrix \(C\):
\[
\begin{align*}
C_{11} &= P_5 + P_4 - P_2 + P_6 \\
C_{12} &= P_1 + P_2 \\
C_{21} &= P_3 + P_4 \\
C_{22} &= P_5 + P_1 - P_3 - P_7 \\
\end{align*}
 \]

Strassen's algorithm is more efficient for large matrices, but due to constant factors and increased
overhead, it may not always outperform the standard algorithm for small matrices. It has significance in the
field of algorithm design and complexity theory.

Both Merge Sort and Quick Sort are popular sorting algorithms that use different approaches to achieve
efficient sorting.

### Merge Sort:

1. **Divide and Conquer:**

- Merge Sort follows the divide-and-conquer paradigm.
- It recursively divides the array into two halves until each subarray contains a single element.

2. **Merge Operation:**
- After dividing, it merges the subarrays in a sorted manner.
- The merge operation combines two sorted arrays into a single sorted array.

3. **Stable Sort:**
- Merge Sort is a stable sorting algorithm, meaning equal elements maintain their relative order.

4. **Time Complexity:**
- The time complexity of Merge Sort is \(O(n \log n)\) in the worst, average, and best cases.
- It has a higher time complexity constant compared to Quick Sort but is more consistent.

5. **Space Complexity:**
- The space complexity is \(O(n)\) due to the additional space required for merging.

### Quick Sort:

1. **Divide and Conquer:**

- Quick Sort also follows the divide-and-conquer paradigm.
- It selects a 'pivot' element and partitions the array into two subarrays: elements less than the pivot and
elements greater than the pivot.

2. **In-Place Sorting:**
- Quick Sort is an in-place sorting algorithm, meaning it sorts the array without requiring additional
memory.

3. **Unstable Sort:**
- Quick Sort is generally an unstable sorting algorithm. The relative order of equal elements may change
during sorting.

4. **Time Complexity:**
- The average and best-case time complexity is \(O(n \log n)\), making it efficient for large datasets.
- However, the worst-case time complexity is \(O(n^2)\), which occurs when the pivot selection
consistently results in unbalanced partitions.

5. **Space Complexity:**
- The space complexity is \(O(\log n)\) due to the recursive call stack.

### Comparison:

- **Advantages of Merge Sort:**

- Consistent \(O(n \log n)\) time complexity.
- Stable sorting.

- **Advantages of Quick Sort:**

- In-place sorting, requiring less memory.
 - Often faster in practice for average and best cases.

- **Disadvantages of Quick Sort:**

- Worst-case time complexity is \(O(n^2)\).
- Unstable sorting.

The choice between Merge Sort and Quick Sort depends on the specific requirements of the problem, the
characteristics of the data, and the desired trade-offs between time and space complexity.

Graph coloring is a problem of assigning colors to the vertices of a graph in such a way that no two
adjacent vertices share the same color. The minimum number of colors needed to color a graph is called its
chromatic number.

Here are some key points related to graph coloring:

1. **Chromatic Number:**
- The chromatic number (\(\chi(G)\)) of a graph \(G\) is the minimum number of colors needed to color the
vertices such that no two adjacent vertices have the same color.

2. **Coloring Rules:**
- Adjacent vertices must have different colors.
- The coloring is often represented as a function \(f: V(G) \rightarrow \{1, 2, \ldots, \chi(G)\}\), where
\(V(G)\) is the set of vertices.

3. **Graph Coloring Problems:**

- **Vertex Coloring:** Assign colors to vertices.
- **Edge Coloring:** Assign colors to edges.
- **Face Coloring (for planar graphs):** Assign colors to faces.

4. **Chromatic Polynomial:**
- The chromatic polynomial of a graph \(G\), denoted as \(P_G(k)\), represents the number of ways to
color the graph using \(k\) colors.

5. **Applications:**
- Graph coloring has applications in scheduling, register allocation in compilers, frequency assignment in
wireless communication, and various other areas.

6. **Greedy Coloring Algorithm:**

- The greedy coloring algorithm is a simple heuristic. It iteratively assigns colors to vertices, choosing the
smallest available color for each vertex.

7. **Optimization Problems:**
- Finding the chromatic number is an NP-complete problem. The problem of deciding if a graph is \(k\)-
colorable is NP-complete for \(k \geq 3\).

Graph coloring is a well-studied problem in graph theory, and various algorithms and heuristics have been
developed to find or approximate the chromatic number of a graph. The study of graph coloring has
connections with combinatorial optimization, algorithmic complexity, and real-world applications.

Huffman coding is a variable-length prefix coding algorithm used for lossless data compression. It was
developed by David A. Huffman in 1952.

### Key Concepts:

1. **Frequency-Based Coding:**
- Huffman coding assigns variable-length codes to different symbols based on their frequencies in the
given data.
- More frequent symbols get shorter codes, and less frequent symbols get longer codes.

2. **Huffman Tree:**
 - The algorithm builds a binary tree called the Huffman tree.
- The tree is constructed in a bottom-up manner, starting with individual nodes representing symbols.
- At each step, two nodes with the lowest frequencies are combined into a new node, and this process is
repeated until a single root node is formed.

3. **Code Assignments:**
- Assign codes to the symbols based on their position in the Huffman tree.
- Left edges represent a '0' bit, and right edges represent a '1' bit.
- The codes are then obtained by traversing from the root to each leaf.

### Huffman Coding Algorithm:

1. **Frequency Analysis:**
- Calculate the frequency of each symbol in the input data.

2. **Priority Queue:**
- Create a priority queue (min-heap) based on the frequencies of symbols.

3. **Build Huffman Tree:**

- While there is more than one node in the priority queue, remove the two nodes with the lowest
frequencies, create a new internal node with these nodes as children, and insert the new node back into
the priority queue.
- The last remaining node in the queue is the root of the Huffman tree.

4. **Assign Codes:**
- Traverse the Huffman tree to assign binary codes to each symbol.

### Example:

Consider the symbols A, B, C, D with frequencies 4, 3, 2, 1, respectively.

1. Build the Huffman tree:

```
10
/ \
4 6
/\ /\
A BC D
```

2. Assign codes:

```
A: 0
B: 10
C: 110
D: 111
```

### Compression and Decompression:

- To compress data, replace each symbol with its Huffman code.

- To decompress, traverse the Huffman tree using the received binary stream to reconstruct the original
symbols.

Huffman coding is widely used in various compression algorithms, including popular formats like JPEG and
MP3. Its efficiency is based on the variable-length codes, where frequently occurring symbols have shorter
codes, resulting in overall compression of the data.
Let's discuss some common sorting and searching algorithms along with their analysis.

### Sorting Algorithms:

1. **Bubble Sort:**
- **Description:** Repeatedly swap adjacent elements if they are in the wrong order.
- **Time Complexity:** \(O(n^2)\) in the worst case.
- **Space Complexity:** \(O(1)\).
- **Stability:** Stable.

2. **Selection Sort:**
- **Description:** Select the minimum element from the unsorted part and swap it with the first unsorted
element.
- **Time Complexity:** \(O(n^2)\) in the worst case.
- **Space Complexity:** \(O(1)\).
- **Stability:** Not stable.

3. **Insertion Sort:**
- **Description:** Build the sorted array in a gradually increasing manner by repeatedly taking elements
from the unsorted part and inserting them into their correct position.
- **Time Complexity:** \(O(n^2)\) in the worst case.
- **Space Complexity:** \(O(1)\).
- **Stability:** Stable.

4. **Merge Sort:**
- **Description:** Divide the array into two halves, recursively sort each half, and then merge the sorted
halves.
- **Time Complexity:** \(O(n \log n)\) in the worst, average, and best cases.
- **Space Complexity:** \(O(n)\).
- **Stability:** Stable.

5. **Quick Sort:**
- **Description:** Choose a pivot, partition the array into elements smaller and larger than the pivot, and
recursively sort the subarrays.
- **Time Complexity:** \(O(n^2)\) in the worst case, \(O(n \log n)\) on average.
- **Space Complexity:** \(O(\log n)\) on average.
- **Stability:** Not stable.

6. **Heap Sort:**
- **Description:** Build a max-heap from the array and repeatedly extract the maximum element from the
heap.
- **Time Complexity:** \(O(n \log n)\) in the worst, average, and best cases.
- **Space Complexity:** \(O(1)\).
- **Stability:** Not stable.

### Searching Algorithms:

1. **Linear Search:**
- **Description:** Iterate through each element until the target is found.
- **Time Complexity:** \(O(n)\) in the worst case.
- **Space Complexity:** \(O(1)\).

2. **Binary Search:**
- **Description:** Divide the sorted array in half and eliminate half of the remaining elements at each step.
- **Time Complexity:** \(O(\log n)\) in the worst case.
- **Space Complexity:** \(O(1)\).
3. **Hashing (Hash Table):**
- **Description:** Store elements in a data structure that allows for efficient insertion and retrieval.
- **Time Complexity:** \(O(1)\) on average for retrieval, \(O(n)\) in the worst case.
- **Space Complexity:** Depends on the load factor.
4. **Jump Search:**
- **Description:** Divide the array into blocks and perform linear search in the block where the target
might be.
- **Time Complexity:** \(O(\sqrt{n})\) in the worst case.
- **Space Complexity:** \(O(1)\).

5. **Interpolation Search:**
- **Description:** Estimate the position of the target based on its value and perform binary search.
- **Time Complexity:** \(O(\log \log n)\) on average for uniformly distributed data, \(O(n)\) in the worst
case.
- **Space Complexity:** \(O(1)\).

These complexities provide insights into the efficiency of each algorithm in terms of time and space. The
choice of a sorting or searching algorithm depends on factors like the size of the dataset, distribution of
data, and memory constraints.

The Knapsack Problem is a classic optimization problem that involves selecting a subset of items with
given weights and values to maximize the total value without exceeding a given weight capacity. There are
two main variations: the 0/1 Knapsack Problem and the Fractional Knapsack Problem.

### 0/1 Knapsack Problem:

1. **Problem Statement:**
- Given a set of items, each with a weight \(w_i\) and a value \(v_i\), determine the maximum value that
can be obtained by selecting a subset of items without exceeding a given weight capacity \(W\).

2. **Dynamic Programming Algorithm:**

- **Initialization:** Create a 2D array \(dp\) where \(dp[i][w]\) represents the maximum value that can be
obtained with a knapsack capacity of \(w\) and considering the first \(i\) items.
- **Base Case:** Initialize the first row and column of \(dp\) with zeros.
- **Fill the Table:** For each item \(i\), consider whether including it in the knapsack would increase the
total value.
\[dp[i][w] = \max(dp[i-1][w], dp[i-1][w-w_i] + v_i)\]
- **Result:** The final result is in \(dp[n][W]\), where \(n\) is the number of items and \(W\) is the total
capacity of the knapsack.

### Fractional Knapsack Problem:

1. **Problem Statement:**
- Given a set of items, each with a weight \(w_i\) and a value \(v_i\), determine the maximum value that
can be obtained by selecting fractions of items without exceeding a given weight capacity \(W\).

2. **Greedy Algorithm:**
- **Calculate Ratios:** Calculate the value-to-weight ratios for each item: \(r_i = \frac{v_i}{w_i}\).
- **Sort Items:** Sort the items based on their ratios in non-decreasing order.
- **Fill the Knapsack:** Starting with the highest ratio, add items to the knapsack until the weight capacity
is reached.

The 0/1 Knapsack Problem has a time complexity of \(O(nW)\), where \(n\) is the number of items and \(W\)
is the capacity of the knapsack. The Fractional Knapsack Problem, solved by the greedy algorithm, has a
time complexity of \(O(n \log n)\) due to sorting.

These algorithms are fundamental in optimization problems and have applications in various fields,
including resource allocation, finance, and scheduling.