School of Computing Science and Engineering

Academic Year: 2023-24

Course Code: B22EF0404 Algorithms Lab Project Report
Semester & Batch: 4 C1

Project Details:
Longest Common Subsequences Of String Using Dynamic
Project Title:
Programming
Place of Project: REVA UNIVERSITY, BENGALURU

Student Details:

Name: PAVANAJ B BALAPPANAVAR Sign:

Mobile No: 8971637903

Email-ID: [email protected]

SRN: R22EF146

Guide and Lab Faculty Members Details

Sign:
Guide Name: Prof. Asha Date:
Grade by Guide:
Name of Lab Sign:
Faculty 1 Date:
Name of Lab Sign:
Faculty 2 Date:
Grade by Lab
Faculty
Members
(combined)
SEE Examiners
Name of Sign:
Examiner 1: Date:
Name of Sign:
Examiner 2: Date:

1
 Contents
1. Abstract 3

2. Introduction 4

3. Problem Statement. 5-7

4. Project overview. 8

4.1. Objectives 8-9

4.2. Goals 9-10

5. Implementation. 11

5.1.Problem analysis and description. 11

5.2.Modules identified. 11-12

5.3.Code with comments. 13-17

6. Output and results 18-19

7. Conclusions 19

8. References 20

2
 1. ABSTRACT

Dynamic programming (DP) is a powerful method for solving complex problems by

breaking them down into simpler subproblems and solving each subproblem just once,
storing the solutions for future reference. This paper delves into two classic applications of
dynamic programming: the Knapsack Problem and Matrix Chain Multiplication.

The Knapsack Problem, a fundamental issue in combinatorial optimization, involves

selecting items with given weights and values to maximize the total value without exceeding
a specified weight limit. We explore the 0/1 Knapsack Problem and demonstrate how
dynamic programming provides an efficient solution by constructing a table to store
intermediate results, ultimately reducing the time complexity compared to naive recursive
methods.

Matrix Chain Multiplication addresses the challenge of determining the most efficient way to
multiply a series of matrices. By leveraging dynamic programming, we minimize the number
of scalar multiplications required, thus optimizing computational efficiency. We present the
recursive formulation of the problem, followed by the dynamic programming approach that
constructs a solution through a bottom-up method, utilizing a table to record the minimum
cost of multiplying sub chains of matrices.

Both problems illustrate the essence of dynamic programming: optimal substructure and
overlapping subproblems. Through detailed examples and algorithmic analysis, this paper
underscores the significance of dynamic programming in developing efficient and scalable
solutions for a variety of computational problems.

3
 2. INTRODUCTION

In the realm of Dynamic programming (DP) is a paradigm of algorithm design that is

particularly well-suited for solving optimization problems by breaking them down into simpler
subproblems. The principle of dynamic programming is based on the recognition and
exploitation of two key properties: optimal substructure and overlapping subproblems. The
former means that the optimal solution to a problem can be constructed from optimal solutions
to its subproblems, while the latter indicates that the subproblems recur multiple times.

In this paper, we focus on two quintessential problems that exemplify the power and versatility
of dynamic programming: the Knapsack Problem and Matrix Chain Multiplication. These
problems not only demonstrate the practical utility of dynamic programming but also provide
insight into its theoretical underpinnings.

The Knapsack Problem

The Knapsack Problem is a classic problem in combinatorial optimization. Given a set of items,
each with a weight and a value, the task is to determine the number of each item to include in
a collection such that the total weight does not exceed a given limit and the total value is
maximized. This problem can be categorized into different types, such as the 0/1 Knapsack
Problem, where each item can either be taken or left, and the Fractional Knapsack Problem,
where items can be broken into smaller pieces. In this paper, we focus on the 0/1 Knapsack
Problem, demonstrating how dynamic programming can be used to develop an efficient
solution.

Matrix Chain Multiplication

Matrix Chain Multiplication is another classic problem that illustrates the application of
dynamic programming. The problem involves determining the most efficient way to multiply
a given sequence of matrices. Since matrix multiplication is associative, the order in which the
matrices are multiplied can significantly affect the computational cost. The goal is to find the
parenthesizing that minimizes the number of scalar multiplications required. This problem is
particularly important in fields such as computer graphics, scientific computing, and
optimization.

Both the Knapsack Problem and Matrix Chain Multiplication are fundamentally about making
optimal choices and efficiently managing computational resources. By exploring these
problems, this paper aims to provide a comprehensive understanding of dynamic programming
techniques and their applications. Through detailed explanations, algorithmic formulations,
and illustrative examples, we hope to demonstrate how dynamic programming can transform
complex problems into manageable tasks, leading to optimal and efficient solutions.

4
 3. PROBLEM STATEMENT

This mini-project focuses on solving problems using Dynamic Programming (DP)

techniques. Examples include the 0/1 Knapsack problem, and Matrix Chain Multiplication.
The project involves implementing DP solutions, analyzing time and space complexities, and
presenting the optimized solutions.

1. Knapsack

The Knapsack Problem involves selecting items with given weights and values to maximize
the total value without exceeding a weight limit. In the 0/1 Knapsack Problem, each item can
either be included or excluded from the knapsack.

Problem Statement

Given:

• n items, each with a weight wi and a value vi.

• A knapsack with a maximum weight capacity w.

Objective:

• Maximize the total value without exceeding the weight capacity w.

Dynamic Programming Solution

We use a table K where K[i][w] is the maximum value achievable with the first i items and
weight limit w.

1. Initialize K[0][w]=0 for all w.

2. For each item iii and weight w:

Example

Consider a knapsack with capacity W=50W = 50W=50 and three items:

• Item 1: weight = 10, value = 60

• Item 2: weight = 20, value = 100
• Item 3: weight = 30, value = 120

Using dynamic programming, we build the table K:

5
The maximum value achievable with a weight limit of 50 is 220, achieved by including items
2 and 3.

2. Matrix Chain Multiplication

The Matrix Chain Multiplication involves finding the most efficient way to multiply a
sequence of matrices. The goal is to minimize the number of scalar multiplications.

Problem Statement

Given:

• A sequence of n matrices A1, A2, …, An , where Ai has dimensions pi−1×pi.

Objective:

• Determine the optimal parenthesization to minimize the total number of scalar

multiplications.

Dynamic Programming Solution

We use a table mmm where m[i][j] represents the minimum number of scalar multiplications
needed to compute the matrix product Ai to Aj

1. Initialize m[i][i]=0 all i.

2. For chains of length l from 2 to n:

6
Example

Consider matrices A1,A2,A3 with dimensions:

• A1:10×30
• A2:30×5
• A3:5×60

We need to find the optimal way to multiply A1×A2×A3

1. Define the dimensions array p=[10,30,5,60]

2. Create the table mmm:

• For l=2:
o m[1][2]=10×30×5=1500
o m[2][3]=30×5×60=9000
• For l=3l = 3l=3:
o m[1][3]=min(10×30×60+1500,1500+10×5×60)=4500

The optimal way to multiply the matrices with minimal scalar multiplications is 4500,
achieved by computing (A1×A2)×A3.

7
 4. PROJECT OVERVIEW

This project explores two classic applications of dynamic programming: the Knapsack Problem and
Matrix Chain Multiplication. Dynamic programming is a powerful algorithmic technique used to solve
complex problems by breaking them down into simpler subproblems and solving each subproblem just
once, storing the solutions for future reference. This project aims to provide a comprehensive
understanding of these two problems, demonstrate how dynamic programming can be applied to solve
them efficiently, and highlight their practical significance.

4.1 Objectives:

1. Understanding Dynamic Programming:

To comprehend the principles of dynamic programming, including optimal substructure and

overlapping subproblems.

2. Knapsack Problem:

To develop and implement a dynamic programming solution for the 0/1 Knapsack Problem.

3. Matrix Chain Multiplication:

To formulate and solve the Matrix Chain Multiplication problem using dynamic programming.

4. Algorithm Analysis:

To analyze the time and space complexities of the dynamic programming solutions for both
problems.

5. Practical Applications:

To discuss the practical significance and applications of these problems in real-world scenarios.

8
 6. Performance Analysis:
Analyze the performance of the developed algorithms in terms of
space and time efficiency.
Compare the efficiency of the basic dynamic programming solutions
with the optimized solutions to highlight improvements.

7. Practical Implementation:
Implement the algorithms in a suitable programming language, such as
Python or C++.
Validate the correctness and efficiency of the implementations using a
variety of test cases.

8. Documentation and Reporting:

Document the problem definitions, algorithm designs, implementation
details, and test results.
Compile a comprehensive report that summarizes the findings, discusses
the strengths and limitations of the developed solutions, and provides
insights into their practical applications.

By achieving these objectives, the project aims to provide a robust understanding

of dynamic programming techniques and deliver practical, efficient solutions for
solving subsequence problems in various real-world contexts.

4.2 Goals:

1. Understanding Dynamic Programming Principles:

• Grasp the fundamental principles of dynamic programming, including

optimal substructure and overlapping subproblems.

• Learn how to identify problems that can be solved using dynamic

programming.

2. Knapsack Problem:

• Formulate the 0/1 Knapsack Problem.

• Develop and implement a dynamic programming solution to maximize the
total value without exceeding the weight limit.
• Analyze the time and space complexity of the dynamic programming solution.

3. Matrix Chain Multiplication:

• Formulate the Matrix Chain Multiplication problem.

• Develop and implement a dynamic programming approach to find the most
efficient way to multiply a sequence of matrices by minimizing scalar
multiplications.

9
 • Analyze the time and space complexity of the dynamic programming solution.

4. Algorithm Implementation and Testing:

• Implement the dynamic programming solutions for both problems in a

programming language such as Python.
• Create a set of test cases to verify the correctness and efficiency of the
implemented algorithms.

5. Complexity Analysis:

• Conduct a thorough analysis of the time and space complexities of the dynamic
programming algorithms developed for both problems.

6. Documentation and Reporting:

• Document the problem statements, dynamic programming solutions, and

algorithm analysis in detail.
• Prepare a comprehensive report summarizing the project, including
methodologies, solutions, results, and conclusions.

7. Practical Applications and Insights:

• Discuss the practical significance and applications of the Knapsack Problem and
Matrix Chain Multiplication in real-world scenarios.
• Gain insights into how dynamic programming can be utilized to solve a wide
range of optimization problems.

10
 5 PROBLEM ANALYSIS AND DESCRIPTION:

The Knapsack Problem and Matrix Chain Multiplication are two classic examples that
highlight the utility of dynamic programming in solving complex optimization problems. The
0/1 Knapsack Problem requires selecting a subset of items with given weights and values to
maximize the total value without exceeding a specified weight limit. This problem can be
approached using a dynamic programming table where each entry represents the maximum
value achievable with a certain weight capacity and subset of items. The recurrence relation
helps in filling the table by deciding whether to include or exclude an item based on its weight
and value. For instance, given items with specific weights and values, and a knapsack with a
weight capacity of 50, dynamic programming can determine the optimal subset of items to
maximize the total value without exceeding the weight limit.

Matrix Chain Multiplication focuses on finding the optimal order to multiply a sequence of
matrices to minimize the total number of scalar multiplications. Since matrix multiplication is
associative, the order of operations can significantly impact the computational cost. Using
dynamic programming, a table is constructed where each entry represents the minimum
multiplication cost for multiplying a subset of matrices. The recurrence relation for this
problem involves breaking down the multiplication sequence into smaller parts and
determining the cost for each possible partition. For example, given matrices with specific
dimensions, dynamic programming can identify the optimal parenthesization to achieve the
minimum multiplication cost. Both problems illustrate the power of dynamic programming in
breaking down complex problems into manageable subproblems and solving them efficiently.

5.1 Modules Identified:

Knapsack Problem Solution Module:

1. Dynamic Programming Table Creation: Implement a function to create a dynamic

programming table to store intermediate results for the Knapsack Problem solution.
2. Table Initialization: Develop a function to initialize the dynamic programming table
with base cases.
3. Dynamic Programming Algorithm: Implement the dynamic programming
algorithm to fill the table and compute the maximum value achievable within the
weight constraint.
4. Backtracking: Develop a function to backtrack through the dynamic programming
table to identify the items included in the optimal solution.
5. Test Cases: Create test cases to validate the correctness and efficiency of the
Knapsack Problem solution module.

11
Matrix Chain Multiplication Solution Module:

1. Dynamic Programming Table Creation: Implement a function to create a dynamic

programming table to store intermediate results for the Matrix Chain Multiplication
problem.
2. Table Initialization: Develop a function to initialize the dynamic programming table
with base cases.
3. Dynamic Programming Algorithm: Implement the dynamic programming
algorithm to fill the table and compute the minimum multiplication cost.
4. Parenthesization Reconstruction: Develop a function to reconstruct the optimal
parenthesization of matrices from the dynamic programming table.
5. Test Cases: Create test cases to validate the correctness and efficiency of the Matrix
Chain Multiplication solution module.

Utility Modules:

1. Input Parsing Module: Implement functions to parse input data for both problems,
such as item weights and values for the Knapsack Problem, and matrix dimensions for
Matrix Chain Multiplication.
2. Output Formatting Module: Develop functions to format and display the results of
the dynamic programming solutions for both problems.
3. Algorithm Analysis Module: Create functions to analyze the time and space
complexities of the dynamic programming algorithms for performance evaluation.
4. Visualization Module (Optional): Optionally, develop functions to visualize the
dynamic programming tables and optimal solutions for better understanding and
debugging purposes.

Main Program:

1. Main Function: Write the main function to orchestrate the execution of the solution
modules, including input parsing, dynamic programming algorithm execution, and
output formatting.
2. User Interaction: Implement user interaction for providing input data and displaying
the results of the dynamic programming solutions.
3. Error Handling: Include error handling mechanisms to handle invalid input data and
unexpected errors gracefully.

12
 5.2 CODE IMPLEMENTATION

#include <stdio.h>

#include <limits.h>

#define MAX_N 100

// Function to solve 0/1 Knapsack problem using memoization (top-down DP)

int knapsack_memoization(int idx, int capacity, int n, int weights[], int values[], int
dp[][MAX_N + 1]) {

if (idx == n || capacity == 0) return 0;

if (dp[idx][capacity] != -1) return dp[idx][capacity];

int not_take = knapsack_memoization(idx + 1, capacity, n, weights, values, dp);

int take = 0;

if (weights[idx] <= capacity) {

take = values[idx] + knapsack_memoization(idx + 1, capacity - weights[idx], n, weights,

values, dp);

return dp[idx][capacity] = (not_take > take) ? not_take : take;

// Function to solve Matrix Chain Multiplication using memoization (top-down DP)

int matrix_chain_order(int dims[], int i, int j, int dp[][MAX_N + 1]) {

// Base case: Single matrix (no cost)

13
if (i == j) return 0;

// Return memoized result if available

if (dp[i][j] != -1) return dp[i][j];

int min_cost = INT_MAX;

// Try all possible splits (k) between i and j

for (int k = i; k < j; k++) {

int cost = matrix_chain_order(dims, i, k, dp) // Cost of multiplying matrices from i to k

+ matrix_chain_order(dims, k + 1, j, dp) // Cost of multiplying matrices from k+1 to j

+ dims[i - 1] * dims[k] * dims[j]; // Cost of multiplying resulting matrices

// Update minimum cost

if (cost < min_cost) {

min_cost = cost;

// Memoize the computed minimum cost for matrices from i to j

return dp[i][j] = min_cost;

int main() {

char choice; // Change to char for reading 'X' or '0'

printf("Press 'X' for Knapsack or '0' for Matrix Chain Multiplication: ");

14
scanf(" %c", &choice); // Use %c to read a character, add space before %c to consume any
leading whitespace

if (choice == 'X' || choice == 'x') {

// 0/1 Knapsack problem example

int n, W;

printf("Enter the number of items for Knapsack: ");

scanf("%d", &n);

int weights[MAX_N], values[MAX_N];

printf("Enter the weights of the items:\n");

for (int i = 0; i < n; i++) {

scanf("%d", &weights[i]);

printf("Enter the values of the items:\n");

for (int i = 0; i < n; i++) {

scanf("%d", &values[i]);

printf("Enter the maximum weight capacity of the knapsack: ");

scanf("%d", &W);

// Memoization table for Knapsack

int dp_knapsack[MAX_N + 1][MAX_N + 1];

for (int i = 0; i <= n; i++) {

for (int j = 0; j <= W; j++) {

15
dp_knapsack[i][j] = -1;

// Compute maximum value using Knapsack (memoization)

int max_value_knapsack = knapsack_memoization(0, W, n, weights, values, dp_knapsack);

printf("Maximum value using Knapsack (memoization): %d\n", max_value_knapsack);

} else if (choice == '0') {

// Matrix Chain Multiplication example

int m;

printf("\nEnter the number of matrices for Matrix Chain Multiplication: ");

scanf("%d", &m);

int dims[MAX_N + 1];

printf("Enter the dimensions of the matrices:\n");

for (int i = 0; i <= m; i++) {

scanf("%d", &dims[i]);

// Memoization table for Matrix Chain Multiplication

int dp_matrix_chain[MAX_N + 1][MAX_N + 1];

for (int i = 0; i <= m; i++) {

for (int j = 0; j <= m; j++) {

dp_matrix_chain[i][j] = -1;

16
// Compute minimum cost of Matrix Chain Multiplication (memoization)

int min_cost_matrix_chain = matrix_chain_order(dims, 1, m, dp_matrix_chain);

printf("Minimum cost of Matrix Chain Multiplication (memoization): %d\n",

min_cost_matrix_chain);

} else {

printf("Invalid choice!\n");

return 0;

17
 6 OUTPUT AND RESULT:

18

18
 RESULT:

The project successfully implemented solutions for both the Knapsack Problem and Matrix
Chain Multiplication using dynamic programming techniques.

• Knapsack Problem: The dynamic programming solution efficiently computed the

maximum value achievable within the weight constraint for various input scenarios.
Test cases validated the correctness and efficiency of the implementation, ensuring
optimal solutions and selected items.
• Matrix Chain Multiplication: The dynamic programming algorithm accurately
determined the minimum multiplication cost and optimal parenthesization of matrices.
Test cases confirmed the correctness and efficiency of the solution, providing valuable
insights into the optimal order of matrix multiplication.

Additionally, utility modules were developed for input parsing, output formatting, algorithm
analysis, and optional visualization. The main program orchestrated the execution of solution
modules, handled user interaction, and implemented error handling mechanisms for robustness
and reliability. Overall, the project successfully addressed the targeted problems and provided
comprehensive results.

6. CONCLUSION

In conclusion, this project effectively addressed both the Knapsack Problem and Matrix
Chain Multiplication using dynamic programming, yielding optimal solutions validated
through rigorous testing. The developed utility modules facilitated input parsing, output
formatting, and algorithm analysis, while the main program provided a seamless user
experience. By demonstrating the practical applicability of dynamic programming in
computational optimization, this project contributes to a deeper understanding of algorithmic
problem-solving and underscores the importance of efficient solution methodologies in
tackling complex computational challenges

19
 7. References:

1. Skiena, Steven S. "The Algorithm Design Manual." Springer, 2008.

2. Cormen, Thomas H., et al. "Introduction to Algorithms." MIT Press, 2009.
3. Kleinberg, Jon, and Éva Tardos. "Algorithm Design." Pearson Education, 2005.
4. Papadimitriou, Christos H., and Kenneth Steiglitz. "Combinatorial Optimization:
Algorithms and Complexity." Dover Publications, 1998.
5. Manber, Udi. "Introduction to Algorithms: A Creative Approach." Addison-Wesley,
1989.
6. Aho, Alfred V., et al. "Algorithms." Addison-Wesley, 1983.
7. Tanimoto, Steven L. "The Design of Dynamic Programming Algorithms." Elsevier,
1982.
8. Vazirani, Vijay V. "Approximation Algorithms." Springer, 2001.
9. Dasgupta, Sanjoy, et al. "Algorithms." McGraw-Hill Education, 2008.
10. GeeksforGeeks. "Knapsack Algorithms." Available at:
https://www.geeksforgeeks.org/knapsack-problem/. Accessed on: [Insert Access
Date]

20