Topic 01: Comparing Kruskal, Prim’s algorithm, Boruvka’s algorithm in MST

Minimum Spanning Tree (MST):

Given connected graph G with positive edge weights, find a min weight set of
edges that connects all of the vertices. https://www.javatpoint.com/minimum-
spanning-tree-introduction
Analyze Kruskal’s, Prim’s algorithm and , Boruvka’s algorithm to solve MST
(Minimum Spanning Tree) problem with different number of inputs (at least 3).

Topic 02: Greedy, Backtracking Algorithm and DSatur Algorithm Comparison in

Graph Coloring Problem
Graph Coloring Problem:
Graph Coloring is a technique of coloring vertices on a graph so that no
neighboring nodes have the same color. The problem is, given m colors, find a
way of coloring the vertices of a graph such that no two adjacent vertices are
colored using same color.
Analyze Greedy, Backtracking Algorithm and DSatur Algorithm to solve Graph
coloring problem with different number of Vertices (at least 3).

Topic 03: Solving Travelling Salesman Problem Using Greedy Algorithm and
Brute Force Algorithm and Dynamic Programming
Travelling Salesman Problem (TSP):

Given a set of cities and the distance between every pair of cities, the problem is
to find the shortest possible route that visits every city exactly once and returns to
the starting point.
Analyze Using Greedy Algorithm, Brute Force Algorithm and Dynamic
Programming to solve TSP with different number of Cities (at least 3).

Topic 04: Design and Analysis 0/1 Knapsack Problem

0/1 Knapsack:
Given weights and values of n items, put these items in a knapsack of capacity W
to get the maximum total value in the knapsack. In other words, given two integer
arrays val[0..n-1] and wt[0..n-1] which represent values and weights associated
with n items respectively. Also given an integer W which represents knapsack
capacity, find out the maximum value subset of val[] such that sum of the weights
of this subset is smaller than or equal to W. You cannot break an item, either pick
the complete item or don’t pick it (0-1 property).
Analyze Using Greedy Algorithm, Brute Force Algorithm and Dynamic
Programming to solve 0/1 knapsack problem with different number of items (at
least 3).

Topic 05: Coin Change Problem using Brute Force, Greedy Algorithm and
Dynamic Programming

Coin Change:

Given an integer array of coins [] of size N representing different types of

currency and an integer sum, The task is to find the number of ways to
make sum by using different combinations from coins[].
Note: Assume that you have an infinite supply of each type of coin.

Analyze Using Greedy Algorithm, Brute Force Algorithm and Dynamic

Programming to solve Coin change problem with different size of the coin[] array
and different value of sum (at least 3).

Topic 06: Comparing Exhaustive Search Algorithm, Greedy Algorithm and

Priority Queue (Max heap) implementation in Job Scheduling Problem
Job scheduling problem:
Job scheduling is the problem of scheduling jobs out of a set of N jobs on a single
processor which maximizes profit as much as possible. Consider N jobs, each
taking unit time for execution. Each job is having some profit and deadline
associated with it. Profit earned only if the job is completed on or before its
deadline. Each job has deadline di ≥ 1 and profit pi ≥ 0. At a time, only one job can
be active on the processor.
Analyze Using Exhaustive Search Algorithm, Greedy Algorithm and Priority
Queue(Max heap) implementation to solve Job Scheduling Problem with different
number of jobs (at least 3).

Topic 07: Design and Analysis Fractional Knapsack Problem

Fractional Knapsack:
A thief is robbing a store and can carry a maximal weight of W into his knapsack.
There are n items available in the store and weight of ith item is wi and its profit is
pi. What items should the thief take? In this context, the items should be selected in
such a way that the thief will carry those items for which he will gain maximum
profit. items can be broken into smaller pieces. So, the thief may take only a
fraction xi of ith item.
Analyze Using Greedy Algorithm, Brute Force Algorithm and Dynamic
Programming to solve fractional knapsack problem with different number of items
(at least 3).

Topic 08: Rod-Cutting Problem using Brute force and Dynamic Programming: -
1) unbounded knapsack 2) Iterative Solution.

Rod-Cutting Problem:

Given a rod of length n inches and an array of prices that includes prices of all
pieces of size smaller than n. Determine the maximum value obtainable by
cutting up the rod and selling the pieces. For example, if the length of the rod is 8
and the values of different pieces are given as the following, then the maximum
obtainable value is 22 (by cutting in two pieces of lengths 2 and 6)
length | 1 2 3 4 5 6 7 8
--------------------------------------------
price | 1 5 8 9 10 17 17 20
And if the prices are as following, then the maximum obtainable value is 24 (by
cutting in eight pieces of length 1)

length | 1 2 3 4 5 6 7 8
--------------------------------------------
price | 3 5 8 9 10 17 17 20

Analyze Using Brute Force Algorithm and Dynamic Programming to solve rod-
cutting problem with different length of rod (at least 3).

Topic 09: Activity Selection problem using Greedy approach: - 1) Activities are
sorted 2) Activities are unsorted and Dynamic Programming.

Activity Selection Problem:

You are given n activities with their start and finish times. Select the maximum
number of activities that can be performed by a single person, assuming that a
person can only work on a single activity at a time.
Examples:
Input: start[] = {10, 12, 20}, finish[] = {20, 25, 30}
Output: 0 2

Explanation: A person can perform at most two activities. The

maximum set of activities that can be executed
is {0, 2} [ These are indexes in start[] and finish[] ]

Input: start[] = {1, 3, 0, 5, 8, 5}, finish[] = {2, 4, 6, 7, 9, 9};

Output: 0 1 3 4

Explanation: A person can perform at most four activities. The

maximum set of activities that can be executed
is {0, 1, 3, 4} [ These are indexes in start[] and finish[]]

Analyze Using Greedy approach and Dynamic Programming to solve activity

selection problem with different number of activities (at least 3).
Topic 10: LCS using brute force, Dynamic Programming and character swapping

LCS:

Given two sequences, find the length of longest subsequence present in both. A
subsequence is a sequence that appears in the same relative order, but not
necessarily contiguous. For example, “abc”, “abg”, “bdf”, “aeg”, ‘”acefg” etc are
subsequences of “abcdefg”.

Analyze Using Brute force, Dynamic Programming and Character swapping to

solve LCS with different length of the sequences (at least 3).

Topic 11: Single source shortest path between two cities using DFS, Dijkstra
Algorithm and Bellmon Ford Algorithm.

Problem statement:

Given a graph of N Nodes and E edges in form of {U, V, W} such that there
exists an edge between U and V with weight W. You are given an integer K and
source src and destination dst. The task is to find the cheapest cost path from
given source to destination from K stops.
Example:

Input: N = 3, edges = [[0, 1, 100], [1, 2, 100], [0, 2, 500]], src = 0, dst = 2, k =
1
Output: 200
Explanation:

The Cheapest Price is from City 0 to City 2. With just one stop, it just costs 200
which is our Output.
Input: N = 3, edges = [[0, 1, 100], [1, 2, 100], [0, 2, 500]], src = 0, dst = 2, k =
0
Output: 500

Analyze Using DFS, Dijkstra Algorithm and Bellmon Ford Algorithm to solve the
problem with different number of nodes and edges (at least 3).
Topic 12: Matrix Chain Multiplication using Brute Force and Dynamic
Programming

Matrix chain Multiplication:

Given the dimension of a sequence of matrices in an array arr[], where the

dimension of the ith matrix is (arr[i-1] * arr[i]), the task is to find the most
efficient way to multiply these matrices together such that the total number of
element multiplications is minimum.

Examples:
Input: arr[] = {40, 20, 30, 10, 30}

Output: 26000

Explanation:
There are 4 matrices of dimensions 40×20, 20×30, 30×10, 10×30.
Let the input 4 matrices be A, B, C and D.
The minimum number of multiplications are obtained by
putting parenthesis in following way (A(BC))D.
The minimum is 20*30*10 + 40*20*10 + 40*10*30

Analyze Using Brute Force and Dynamic Programming

to solve the problem with different length of the array arr[] (at least 3).

Time-Complexity Analysis:

Keep track of time taken to implement all the solving techniques for each

number of input and plot them in a 2-dimensional coordinate system taking n

(Number of input) as x values and t (execution time) as y values. All the curves
should be plotted on the same graph.