NAME – SACHIN SHARMA

ROLL NO – 21EJCCS195

SECTION – C

2022 RTU SOLUTION AOA

======================================PART A ========================================

QUE 1 Define Time comlexity

Time complexity is a measure that characterizes the amount of time an algorithm takes to complete as a function of the
size of the input. It provides an estimate of the upper bound on the running time of an algorithm, expressing how the
algorithm's performance scales with the size of the input.

In simpler terms, time complexity helps us understand how the execution time of an algorithm increases or decreases
with the size of the input data. It is often expressed using big O notation, which describes the upper limit of the growth
rate of the algorithm's running time.

For example, if an algorithm has a time complexity of O(n), it means that the running time grows linearly with the size
of the input (n). If it's O(n^2), the running time grows quadratically, and so on. Time complexity is a critical concept in
algorithm analysis, helping to compare and contrast different algorithms and understand their efficiency in handling
larger datasets.

QUE 2 . Explain an algorithm with its steps.

**Merge Sort**. Merge Sort is a comparison-based sorting algorithm that follows the divide-and-conquer paradigm. It
divides the input array into two halves, sorts each half independently, and then merges the sorted halves to produce a
fully sorted array.

1. **Divide:**

- If the array has zero or one element, it is already sorted. Otherwise, divide the array into two halves.

- Recursively apply the merge sort algorithm to each half.

2. **Conquer:**

- Continue dividing the array until it is broken down into single-element subarrays (the base case).
 - At this point, each single-element subarray is considered sorted.

3. **Merge:**

- Merge two sorted subarrays into a single sorted array.

- Start with two pointers, one for each subarray, and compare the elements at those pointers.

- Take the smaller of the two elements and add it to the merged array.

- Move the pointer of the subarray from which the element was taken.

- Repeat this process until all elements from both subarrays are merged into a single sorted array.

4. **Repeat:**

- Continue merging sorted subarrays until the entire array is sorted.

QUE 3 Define 0/1 Knapsack problem.

The 0/1 Knapsack Problem is a classic optimization problem in computer science and mathematics. In this problem, you
are given a set of items, each with a weight and a value, and a knapsack with a limited capacity. The goal is to determine
the maximum value that can be obtained by selecting a subset of the items to fit into the knapsack without exceeding its
capacity. The "0/1" in the problem's name signifies that you can either include or exclude an item; there is no possibility
of including a fractional part of an item.

QUE 4 What are the differences between Greedy method and Dynamic Programming?
QUE 5 Discuss lower bound theory

Lower bound theory, often associated with computational complexity theory, is concerned with determining the
minimum amount of resources (such as time or space) required to solve a particular computational problem. The lower
bound represents a limit on the efficiency of any algorithm that solves a specific problem. This theory helps us understand
the inherent difficulty or complexity of problems and sets a benchmark for algorithmic performance.

Here are some key concepts and aspects related to lower bound theory:

1. **Decision Problem:

2. **Complexity Classes:

QUE 6 What do you mean by pattern matching?

Pattern matching is a process of finding a specific pattern or sequence of characters within a larger dataset, such as a
text, a sequence of symbols, or any structured data. The goal of pattern matching is to identify the occurrences of a
particular pattern or substring within the given data. This concept is widely used in computer science, linguistics, data
analysis, and various other fields.
In the context of computer science and programming, pattern matching is often associated with string matching, where
the goal is to find the occurrence of a specified sequence of characters (the pattern) within a larger text or string.

.**Knuth-Morris-Pratt Algorithm:**

*Boyer-Moore Algorithm:**

QUE 7 Define Randomized algoriyhm.

A randomized algorithm is an algorithm that employs a random or probabilistic component during its execution to
achieve its objectives. Unlike deterministic algorithms, which produce the same output for a given input every time
they run, randomized algorithms introduce an element of randomness to improve efficiency, simplicity, or to solve
certain types of problems more effectively.

- Two common types of randomized algorithms are Monte Carlo algorithms and Las Vegas algorithms:

- **Monte Carlo Algorithms:** These algorithms use randomness to quickly find a solution, but the solution may be
incorrect with a small probability. The running time is typically fast.

- **Las Vegas Algorithms:** These algorithms use randomness to efficiently find a correct solution. The running time
is guaranteed, but it may vary.

.QUE8: What is the assignment problem?

The assignment problem is a classical optimization problem in the field of operations research and combinatorial
optimization. It can be described as follows:

- **Problem Description:**
 - Given a set of tasks and a set of agents, the assignment problem involves finding the optimal assignment of tasks to
agents such that the total cost or weight of the assignments is minimized.

QUE 9: Define set cover problem.

The set cover problem is a classical problem in computer science and optimization theory. It can be described as
follows:

QUE IO: What is a decision problem?

A decision problem is a type of computational problem that requires a yes/no answer or a binary choice. In other
words, a decision problem poses a question that can be answered with either "yes, the solution exists" or "no, the
solution does not exist." Decision problems are fundamental in computer science and form the basis for more complex
problems.

- **Examples:**

- "Does a given graph have a Hamiltonian cycle?"

- "Is a given number prime?"

- "Does a specific configuration lead to a winning state in a board game?"

=====================================================PART B
============================================

QUE 1 Explain merge son. Using merge sort algorithm sort the following sequence ¯
38, 42, 24, 68, 45, 12, 88, 32.

Merge sort is a divide-and-conquer algorithm that recursively divides a list into two halves until each sublist contains
only one element. Then, it merges the sublists back together, combining them in a sorted manner. The steps are as
follows:

1. **Divide:** Split the unsorted list into two halves.

2. **Conquer:** Recursively sort each half.

3. **Merge:** Combine the sorted halves into a single sorted list.

### Sorting the Sequence:

Sequence: 38, 42, 24, 68, 45, 12, 88, 32

1. **Divide:**
 - Divide the sequence into two halves: [38, 42, 24, 68] and [45, 12, 88, 32].

2. **Conquer:**

- Recursively apply merge sort to each half.

Left Half: [38, 42, 24, 68]

- Divide: [38, 42] and [24, 68]

- Conquer: [38, 42] (sorted), [24, 68] (sorted)

- Merge: Combine the sorted halves to get [24, 38, 42, 68]

Right Half: [45, 12, 88, 32]

- Divide: [45, 12] and [88, 32]

- Conquer: [12, 45] (sorted), [32, 88] (sorted)

- Merge: Combine the sorted halves to get [12, 32, 45, 88]

3. **Merge:**

- Merge the two sorted halves [24, 38, 42, 68] and [12, 32, 45, 88] to obtain the final sorted sequence.

Final Sorted Sequence: [12, 24, 32, 38, 42, 45, 68, 88]

So, the sequence 38, 42, 24, 68, 45, 12, 88, 32 is sorted in ascending order using the merge sort algorithm.

QUE 2 92 Using Quick sort algorithm sort the Following sequence-

A = {13,19,9,5,12,8,7,4,21,2,6,11}
Quick Sort is another efficient divide-and-conquer sorting algorithm. It works by selecting a "pivot" element from the
array and partitioning the other elements into two subarrays according to whether they are less than or greater than
the pivot. The subarrays are then sorted recursively.

### Sorting the Sequence:

Given sequence: A = {13, 19, 9, 5, 12, 8, 7, 4, 21, 2, 6, 11}

1. **Choose a Pivot:**
- Let's choose the last element, 11, as the pivot.

2. **Partitioning:**
- Rearrange the elements so that elements smaller than the pivot are on the left, and elements greater than the
pivot are on the right.

```
Partitioned Sequence: {9, 5, 8, 7, 4, 2, 6, 11, 13, 19, 21, 12}
↑ pivot ↑
```

3. **Recursive Steps:**
- Apply the Quick Sort algorithm recursively to the left and right subarrays.

Left Subarray: {9, 5, 8, 7, 4, 2, 6, 11}

Right Subarray: {13, 19, 21, 12}

- For the left subarray:

- Choose the last element, 11, as the pivot.
- Partition the subarray.

```
Partitioned Left Subarray: {5, 8, 7, 4, 2, 6, 9, 11}
↑ pivot ↑
```

- For the right subarray:

- Choose the last element, 12, as the pivot.
- Partition the subarray.

```
Partitioned Right Subarray: {13, 19, 21, 12}
↑ pivot ↑
```

4. **Combine:**
- Combine the sorted subarrays to obtain the final sorted sequence.
 Final Sorted Sequence: {2, 4, 5, 6, 7, 8, 9, 11, 12, 13, 19, 21}

So, the given sequence {13, 19, 9, 5, 12, 8, 7, 4, 21, 2, 6, 11} is sorted in ascending order using the Quick Sort
algorithm.

QUE 4 Explain Quadratic assignment problem using a suitable example.

The Quadratic Assignment Problem (QAP) is a combinatorial optimization problem that involves assigning a set of facilities
to a set of locations in such a way as to minimize the total cost. The cost is determined by both the distances between
the locations and the flow between the facilities.

Problem Definition:
QUE 5 prove that the Hamilton cycle problem is NP-Complete.
To prove that the Hamiltonian Cycle problem is NP-complete, we need to show two things:

1. **Hamiltonian Cycle is in NP:** This means that given a proposed Hamiltonian cycle, we can quickly verify whether it
is indeed a Hamiltonian cycle in polynomial time.

2. **Hamiltonian Cycle is NP-hard:** This means that any problem in NP can be reduced to the Hamiltonian Cycle
problem in polynomial time.

1. Hamiltonian Cycle is in NP:

Given a proposed Hamiltonian cycle, we can verify in polynomial time whether it satisfies the following conditions:

- It visits every vertex exactly once.

- It forms a cycle by returning to the starting vertex.

This verification process can be done in \(O(n^2)\) time, where \(n\) is the number of vertices in the graph.

### 2. Hamiltonian Cycle is NP-hard:

To show NP-hardness, we can perform a polynomial-time reduction from a known NP-complete problem to the
Hamiltonian Cycle problem. One commonly used NP-complete problem for this purpose is the Boolean Satisfiability
Problem (SAT).

#### Reduction from SAT to Hamiltonian Cycle:

Given a Boolean formula in conjunctive normal form (CNF), we construct a graph as follows:

1. **Vertex Construction:**

- For each variable in the Boolean formula, create two vertices (representing true and false values).

- For each clause in the Boolean formula, create a cycle connecting the vertices corresponding to the literals in the
clause.

2. **Edge Construction:**
 - Connect vertices corresponding to complementary literals in different clauses.

QUE – 6 Find optimal parenthesization of matrix chain product whose sequence of dimension-
(6, 12, 6, 42, 7)
To find the optimal parenthesization of a matrix chain product, you can use dynamic programming to minimize the number of
scalar multiplications. The dimensions of the matrices are given as (6, 12, 6, 42, 7).
QUE 7 Describe Naive String Matching Algorithm in detail.

The Naive String Matching algorithm is a simple and straightforward approach to find occurrences of a pattern within a text. It
compares the pattern with substrings of the text one by one and slides the pattern one position at a time until a match is found or
the end of the text is reached. The algorithm has a time complexity of O((n-m+1)m), where n is the length of the text and m is the
length of the pattern.

### Naive String Matching Algorithm:

1. **Initialization:**

- Let n be the length of the text and m be the length of the pattern.

- Start with the leftmost position of the text.

2. **Comparison:**

- For each position i from 0 to n-m:

 Compare each character of the pattern with the corresponding character in the text starting from position i.

- If a mismatch is found at any position, break out of the loop.

3. **Match Found:**

- If the entire pattern is matched, a match is found at position i.

4. **Slide the Pattern:**

- Slide the pattern one position to the right (i.e., increment i) and repeat the comparison process.

5. **Repeat:**

- Continue the process until either a match is found or the end of the text is reached.

### Example:

Text: "ABABCABABABABCABAB"

Pattern: "ABAB"

1. **Initialization:**

- Start with the leftmost position of the text (i=0).

2. **Comparison:**

- Compare "ABAB" with the substring starting at position 0: "ABAB". Match found.

3. **Slide the Pattern:**

- Slide the pattern one position to the right (i=1).

4. **Comparison:**

- Compare "ABAB" with the substring starting at position 1: "BABC". No match.

5. **Slide the Pattern:**

- Slide the pattern one position to the right (i=2).

6. **Comparison:**

- Compare "ABAB" with the substring starting at position 2: "ABC". No match.

7. **Slide the Pattern:**

- Slide the pattern one position to the right (i=3).

8. **Comparison:**

- Compare "ABAB" with the substring starting at position 3: "BCAB". No match.

9. **Slide the Pattern:**

- Continue the process until the end of the text.

The algorithm continues until the end of the text is reached, and all occurrences of the pattern are found.
===============================================PART C ===========================================

### Q2: Dynamic Programming, Matrix Chain Multiplication, and 0/1 Knapsack Problem

#### Dynamic Programming:

Dynamic programming is a powerful optimization technique used for solving problems that can be broken down into overlapping
subproblems. It involves solving and storing the solutions to subproblems in a table to avoid redundant computations. Dynamic
programming is applicable when a problem exhibits optimal substructure and overlapping subproblems.

#### Matrix Chain Multiplication:

Matrix Chain Multiplication is a classic problem that can be efficiently solved using dynamic programming. Given a sequence of
matrices, the goal is to find the most efficient way to multiply these matrices. The objective is to minimize the total number of
scalar multiplications. The dynamic programming approach involves computing the optimal parenthesization for matrix
multiplication.

#### 0/1 Knapsack Problem:

The 0/1 Knapsack Problem is a combinatorial optimization problem. Given a set of items, each with a weight and a value, the goal
is to determine the maximum value that can be obtained by selecting a subset of items with total weight not exceeding a given
limit. This problem exhibits both optimal substructure and overlapping subproblems, making it suitable for dynamic programming.

#### Example: Matrix Chain Multiplication

Consider the matrix dimensions: A(10x30), B(30x5), C(5x60). The product (ABC) requires \(10 \times 30 \times 5 + 10 \times 5
\times 60 = 1500 + 3000 = 4500\) scalar multiplications. The dynamic programming approach optimally parenthesizes this
sequence, minimizing the total scalar multiplications.

#### Example: 0/1 Knapsack Problem

Consider a knapsack with a weight capacity of 10 and three items with weights and values:
- Item 1: Weight 2, Value 6

- Item 2: Weight 3, Value 5

- Item 3: Weight 5, Value 8

The dynamic programming approach builds a table to find the maximum value that can be obtained with a knapsack capacity of
10.

QUE 3: Boyer-Moore Algorithm and KMP Matcher

#### Boyer-Moore Algorithm:

Boyer-Moore is a string-searching algorithm that skips portions of the text based on the information from the pattern. It involves
two main heuristics: the bad character rule and the good suffix rule. The algorithm is efficient in practice and often outperforms
other string-searching algorithms.

The Boyer-Moore algorithm is a powerful string-searching algorithm that efficiently skips portions of the text based on the
information from the pattern. It employs two main heuristics: the bad character rule and the good suffix rule.

1. **Bad Character Rule:**

- When a mismatch is found, the algorithm aligns the rightmost occurrence of the mismatched character in the pattern with the
mismatched character in the text.

- If the mismatched character in the text is not present in the pattern, the entire pattern is shifted to the right by its length.
2. **Good Suffix Rule:**

- If a suffix of the pattern matches a substring of the text, the algorithm aligns the rightmost occurrence of that suffix with the
matching substring.

- If no such match is found, the algorithm looks for the longest suffix of the pattern that matches a prefix of the pattern and
aligns them.

### Finding "ABCBC" in "ACABABCABCBCA" using KMP Matcher:

The KMP algorithm is another efficient string-matching algorithm that uses a prefix function to skip unnecessary comparisons
when a mismatch occurs.

1. **Compute Prefix Function:**

- Compute the prefix function for the pattern "ABCBC."

Pattern: ABCBC

Prefix Function: 0 0 0 1 2

2. **Matching Process:**

- Start matching the pattern with the text, aligning the pattern based on the computed prefix function.

ACABABCABCBCA

|ABCBC (Match found)

3. **Repeat:**

- Continue the process until the end of the text.

 ACABABCABCBCA

|ABCBC (Match found)

ACABABCABCBCA

|ABCBC (Match found)

- Continue until all occurrences are found.

### Summary:

The Boyer-Moore algorithm provides a different approach to string matching, emphasizing efficient skipping of portions of the
text. In this case, we used the KMP algorithm to find occurrences of the pattern "ABCBC" in the text "ACABABCABCBCA," utilizing
the computed prefix function for efficient matching. The result is the discovery of all occurrences of the pattern in the text.

#### Q4: Flow Shop Scheduling and Network Capacity Assignment

### Flow Shop Scheduling:

**Flow Shop Scheduling** is a scheduling problem that arises in manufacturing environments where a set of jobs needs to be
processed on a sequence of machines. The jobs must follow the same sequence of machines, and each job has a specific
processing time on each machine. The objective is often to minimize the makespan, which is the total time taken to complete all
jobs. The problem is NP-hard and has applications in various industries, including production and logistics.
### Network Capacity Assignment Problem:

**Network Capacity Assignment** involves determining the optimal assignment of capacities to links in a network. The goal is to
maximize the overall performance of the network while satisfying certain constraints. This problem is crucial in network design,
where the capacity assignment impacts the efficiency and reliability of the network. It can be formulated as an optimization
problem, considering factors such as bandwidth, delay, and reliability.

### Las Vegas vs. Monte Carlo Algorithmic Approaches:

Both **Las Vegas** and **Monte Carlo** algorithms are probabilistic algorithms that use randomness, but they differ in terms of
their guarantees and behavior.

1. **Monte Carlo Algorithms:**

- Monte Carlo algorithms use randomness to approximate solutions to problems. They may provide incorrect results, but the
probability of correctness increases with the number of iterations.

- These algorithms are generally faster but lack certainty in their results.

- Example: Monte Carlo integration, where random samples are used to estimate the value of an integral.

2. **Las Vegas Algorithms:**

- Las Vegas algorithms also use randomness, but they guarantee correctness. The running time may vary, but the result is always
correct.

- These algorithms are slower but provide certainty in their results.

- Example: Quicksort with a random choice of pivot. While the running time may vary, the sorting result is always correct.
QUE 5 Prove that Circuit Satisfiability Problem ibelongs to the class NP. ExplainApproximation Algorithm for Vertex Cover ###
Circuit Satisfiability Problem in NP:

The Circuit Satisfiability Problem (Circuit SAT) belongs to the class NP (nondeterministic polynomial time) because given a
proposed solution (a truth assignment), we can quickly verify in polynomial time whether it satisfies the Boolean circuit.

To prove this, we need to show two things:

1. **Verification in Polynomial Time:**

- Given a proposed truth assignment, we can evaluate the Boolean circuit using this assignment in polynomial time.

- The circuit structure ensures that each gate's output can be computed in polynomial time based on the inputs.

2. **Nondeterministic Polynomial Time Verification:**

- If a nondeterministic polynomial-time algorithm guesses a truth assignment, we can use the deterministic polynomial-time
verification procedure to check if the guessed assignment satisfies the circuit.

This demonstrates that Circuit SAT is in NP, as there exists a polynomial-time verifier for any given solution.

### Approximation Algorithm for Vertex Cover:

The Vertex Cover Problem is an NP-complete problem where the goal is to find the smallest set of vertices such that every edge in
the graph is incident to at least one vertex from the set. An approximation algorithm for the Vertex Cover Problem provides a
solution that is guaranteed to be within a certain factor of the optimal solution.

One such approximation algorithm is the greedy algorithm for Vertex Cover:

1. **Greedy Vertex Cover Algorithm:**

- Start with an empty set \(C\) (the vertex cover).

- While there are uncovered edges:

- Pick an arbitrary uncovered edge \((u, v)\).

- Add both \(u\) and \(v\) to the set \(C\).

- Mark all edges incident to \(u\) and \(v\) as covered.

 - Output the set \(C\) as the approximate vertex cover.

2. **Analysis:**

- The greedy algorithm produces a vertex cover, but it may not be optimal.

- It guarantees that the size of the vertex cover is at most twice the size of the optimal vertex cover.

3. **Approximation Ratio:**

- The size of the greedy algorithm's solution is at most \(2 \times\) the size of the optimal solution.

4. **Example:**

- Consider a graph with an optimal vertex cover of size 3.

- The greedy algorithm might produce a vertex cover of size 6, but it is guaranteed to be at most \(2 \times\) the optimal size.

### Summary:

The Circuit Satisfiability Problem belongs to NP, as there exists a polynomial-time verifier for any given solution. The
approximation algorithm for Vertex Cover, specifically the greedy algorithm, provides a solution that is guaranteed to be within a
factor of 2 times the optimal solution size. While not always optimal, approximation algorithms are valuable in practice for solving
NP-complete problems efficiently.