Name - AASHISH KUMAR

ROLL- 122CS0560

ASSIGNMENT - 10

Q1. 0/1 Knapsack Problem

. Using Memoization Method

#include <iostream>
#include <vector>
using namespace std;

int knapSackRec(int W, vector<int>& wt, vector<int>& val, int index,

vector<vector<int>>& dp) {
if (index < 0)
return 0;
if (dp[index][W] != -1)
return dp[index][W];
if (wt[index] > W) {
dp[index][W] = knapSackRec(W, wt, val, index - 1, dp);
return dp[index][W];
} else {
dp[index][W] = max(val[index] + knapSackRec(W - wt[index], wt, val,
index - 1, dp), knapSackRec(W, wt, val, index - 1, dp));
return dp[index][W];
}
}

int knapSack(int W, vector<int>& wt, vector<int>& val, int n) {

vector<vector<int>> dp(n, vector<int>(W + 1, -1));
return knapSackRec(W, wt, val, n - 1, dp);
}

int main() {
int n;
cout << "Enter the number of items: ";
cin >> n;

vector<int> value(n);
vector<int> weight(n);

cout << "Enter the values of items: ";

for (int i = 0; i < n; ++i)
cin >> value[i];

cout << "Enter the weights of items: ";

 for (int i = 0; i < n; ++i)
cin >> weight[i];

int W;
cout << "Enter the capacity of the knapsack: ";
cin >> W;

cout << knapSack(W, weight, value, n);

return 0;
}

. Using Tabulation Method

#include <iostream>
#include <vector>

using namespace std;

int KS(vector<int>& v, vector<int>& w, int C, int i) {

if (i == 0 || C == 0) {
return 0;
}

if (w[i - 1] > C) {
return KS(v, w, C, i - 1);
}

else {
return max(v[i - 1] + KS(v, w, C - w[i - 1], i - 1), KS(v, w, C, i - 1));
}
}

int main() {
int N, C;
cout << "Enter the number of items: ";
cin >> N;

vector<int> v(N);
vector<int> w(N);
 cout << "Enter the values of items: ";
for (int i = 0; i < N; ++i) {
cin >> v[i];
}

cout << "Enter the weights of items: ";

for (int i = 0; i < N; ++i) {
cin >> w[i];
}

cout << "Enter the knapsack capacity: ";

cin >> C;

cout << "Maximum value subset: " << KS(v, w, C, N) << endl;

return 0;
}

. Using Recursion Method

#include <iostream>
#include <vector>

using namespace std;

int KS(vector<int>& v, vector<int>& w, int C, int i) {

if (i == 0 || C == 0) {
return 0;
}

if (w[i - 1] > C) {
return KS(v, w, C, i - 1);
}

else {
return max(v[i - 1] + KS(v, w, C - w[i - 1], i - 1), KS(v, w, C, i - 1));
}
}

int main() {
int N, C;
 cout << "Enter the number of items: ";
cin >> N;

vector<int> v(N);
vector<int> w(N);

cout << "Enter the values of items: ";

for (int i = 0; i < N; ++i) {
cin >> v[i];
}

cout << "Enter the weights of items: ";

for (int i = 0; i < N; ++i) {
cin >> w[i];
}

cout << "Enter the knapsack capacity: ";

cin >> C;

cout << "Maximum value subset: " << KS(v, w, C, N) << endl;

return 0;
}
Q2. Matrix Chain Multiplication

#include <bits/stdc++.h>
using namespace std;

int mcmRecursive(const vector<int>& d, int i, int j) {

if (i == j)
return 0;

int minOps = INT_MAX;

for (int k = i; k < j; ++k) {
int cost = mcmRecursive(d, i, k) + mcmRecursive(d, k + 1, j) + d[i - 1] * d[k] * d[j];
if (cost < minOps)
minOps = cost;
}
return minOps;
}

int main() {
int n;
cout << "Enter the number of dimentions: ";
cin >> n;

vector<int> dims(n);
cout << "Enter values for each dimention: ";
for (int i = 0; i < n; ++i)
cin >> dims[i];

cout << "Minimum number of multiplications (recursive): "

<< mcmRecursive(dims, 1, n-1) << endl;

return 0;
}

#include <bits/stdc++.h>
using namespace std;

int mcmDP(const vector<int>& d) {

int n = d.size() - 1; // Number of matrices
vector<vector<int>> dp(n, vector<int>(n, 0));

for (int len = 2; len < n; ++len) {

for (int i = 1; i < n - len + 1; ++i) {
int j = i + len - 1;
 dp[i][j] = INT_MAX;
for (int k = i; k <= j - 1; ++k) {
int cost = dp[i][k] + dp[k + 1][j] + d[i - 1] * d[k] * d[j];
if (cost < dp[i][j])
dp[i][j] = cost;
}
}
}

return dp[1][n - 1];

}

int main() {
int n;
cout << "Enter the number of dimentions: ";
cin >> n;

vector<int> dims(n);
cout << "Enter values for each dimention: ";
for (int i = 0; i < n; ++i)
cin >> dims[i];

cout << "Minimum number of multiplications (DP): "

<< mcmDP(dims) << endl;

return 0;
}
Q3. Convex Polygon Triangulation

#include <bits/stdc++.h>
using namespace std;

double dist(pair<int, int> p1, pair<int, int> p2) {

return sqrt(pow(p1.first - p2.first, 2) + pow(p1.second - p2.second, 2));
}

double minPerimeterRec(const vector<pair<int, int>>& poly, int i, int j) {

if (j - i < 2) // Not enough vertices to form a triangle
return 0;

double minPerim = INT_MAX;

for (int k = i + 1; k < j; ++k) {
double perim = dist(poly[i], poly[j]) + dist(poly[j], poly[k]) + dist(poly[k], poly[i]);
double subPerim = minPerimeterRec(poly, i, k) + minPerimeterRec(poly, k, j);
minPerim = min(minPerim, perim + subPerim);
}
return minPerim;
}

//RECURSIVE
double minPerimeterRecWrapper(const vector<pair<int, int>>& poly) {
return minPerimeterRec(poly, 0, poly.size() - 1);
}

// Dynamic Programming
double minPerimeterDP(const vector<pair<int, int>>& poly) {
int n = poly.size();
vector<vector<double>> dp(n, vector<double>(n, 0));

for (int len = 3; len <= n; ++len) {

for (int i = 0; i < n - len + 1; ++i) {
int j = i + len - 1;
dp[i][j] = INT_MAX;
for (int k = i + 1; k < j; ++k) {
double perim = dist(poly[i], poly[j]) + dist(poly[j], poly[k]) + dist(poly[k], poly[i]);
dp[i][j] = min(dp[i][j], perim + dp[i][k] + dp[k][j]);
}
}
}

return dp[0][n - 1];

}
int main() {
vector<pair<int, int>> poly;

cout<<"Enter no of vertices: "<<endl;

int n;
cin>>n;

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

cout<<"Enter first and second vertex: "<<endl;
int j,k;
cin>>j;
cin>>k;
poly.push_back({j,k});
}

cout << "Minimum perimeter triangulation (recursive): "

<< minPerimeterRecWrapper(poly) << endl;

cout << "Minimum perimeter triangulation (DP): "

<< minPerimeterDP(poly) << endl;

return 0;
}
Q4 . Reduction of MCM to polygon triangulation

#include<bits/stdc++.h>
using namespace std;

// Recursive
double minPerimeterRec(const vector<pair<int, int>>& poly, int i, int j) {
if (j - i < 2)
return 0;

double minPerim = INT_MAX;

for (int k = i + 1; k < j; ++k) {
double perim = sqrt(pow(poly[i].first - poly[j].first, 2) + pow(poly[i].second - poly[j].second,
2)) +
sqrt(pow(poly[j].first - poly[k].first, 2) + pow(poly[j].second - poly[k].second, 2)) +
sqrt(pow(poly[k].first - poly[i].first, 2) + pow(poly[k].second - poly[i].second, 2));
double subPerim = minPerimeterRec(poly, i, k) + minPerimeterRec(poly, k, j);
minPerim = min(minPerim, perim + subPerim);
}
return minPerim;
}

double minPerimeterRecWrapper(const vector<pair<int, int>>& poly) {

return minPerimeterRec(poly, 0, poly.size() - 1);
}

// Dynamic Programming
double minPerimeterDP(const vector<pair<int, int>>& poly) {
int n = poly.size();
vector<vector<double>> dp(n, vector<double>(n, 0));

for (int len = 3; len <= n; ++len) {

for (int i = 0; i < n - len + 1; ++i) {
int j = i + len - 1;
dp[i][j] = INT_MAX;
for (int k = i + 1; k < j; ++k) {
double perim = sqrt(pow(poly[i].first - poly[j].first, 2) + pow(poly[i].second -
poly[j].second, 2)) +
sqrt(pow(poly[j].first - poly[k].first, 2) + pow(poly[j].second - poly[k].second,
2)) +
sqrt(pow(poly[k].first - poly[i].first, 2) + pow(poly[k].second - poly[i].second,
2));
dp[i][j] = min(dp[i][j], perim + dp[i][k] + dp[k][j]);
}
}
}
 return dp[0][n - 1];
}

int main() {
int n;
cout << "Enter the number of dimentions: ";
cin >> n;

vector<int> dims(n);
cout << "Enter values for each dimention: ";
for (int i = 0; i < n; ++i)
cin >> dims[i];

// Convert MCM instance to polygon

vector<pair<int, int>> polygon;
for (int i = 0; i < dims.size() - 1; ++i)
polygon.push_back({dims[i], dims[i + 1]});

// Solve polygon triangulation using recursive approach

cout << "Minimum perimeter triangulation (recursive): "
<< minPerimeterRecWrapper(polygon) << endl;

// Solve polygon triangulation using dynamic programming approach

cout << "Minimum perimeter triangulation (DP): "
<< minPerimeterDP(polygon) << endl;

return 0;
}
 Name - AASHISH KUMAR
ROLL- 122CS0560

ASSIGNMENT - 10

Q5. Edit Distance

. Using Memoization Method

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
using namespace std;

int minEditDistance(string str1, string str2, int m, int n, unordered_map<string,

int>& memo) {
if (m == 0) return n;
if (n == 0) return m;

string key = to_string(m) + "|" + to_string(n);

if (memo.find(key) != memo.end())
return memo[key];

if (str1[m - 1] == str2[n - 1])

return memo[key] = minEditDistance(str1, str2, m - 1, n - 1, memo);

int insert = minEditDistance(str1, str2, m, n - 1, memo);

int remove = minEditDistance(str1, str2, m - 1, n, memo);
int replace = minEditDistance(str1, str2, m - 1, n - 1, memo);

return memo[key] = 1 + min(insert, min(remove, replace));

}

int main() {
string str1, str2;
cout << "Enter the first string: ";
cin >> str1;
cout << "Enter the second string: ";
cin >> str2;

unordered_map<string, int> memo;

cout << "Minimum edits required: " << minEditDistance(str1, str2,
str1.length(), str2.length(), memo);
return 0;
}
. Using Tabulation Method
#include <iostream>
#include <string>
#include <vector>
using namespace std;

int minEditDistance(string str1, string str2) {

int m = str1.length();
int n = str2.length();
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));

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

dp[i][0] = i;
for (int j = 0; j <= n; ++j)
dp[0][j] = j;

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

for (int j = 1; j <= n; ++j) {
if (str1[i - 1] == str2[j - 1])
dp[i][j] = dp[i - 1][j - 1];
else
dp[i][j] = 1 + min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]);
}
}
return dp[m][n];
}

int main() {
string str1, str2;
cout << "Enter the first string: ";
cin >> str1;
cout << "Enter the second string: ";
cin >> str2;

cout << "Minimum edits required: " << minEditDistance(str1, str2);

return 0;
}

. Using Recursion Method

#include <iostream>
#include <string>
using namespace std;

int minEditDistance(string str1, string str2, int m, int n) {

if (m == 0) return n;
if (n == 0) return m;

if (str1[m - 1] == str2[n - 1])

return minEditDistance(str1, str2, m - 1, n - 1);

return 1 + min(min(minEditDistance(str1, str2, m, n - 1),

minEditDistance(str1, str2, m - 1, n)),
minEditDistance(str1, str2, m - 1, n - 1));
}

int main() {
string str1, str2;
cout << "Enter the first string: ";
cin >> str1;
cout << "Enter the second string: ";
cin >> str2;

cout << "Minimum edits required: " << minEditDistance(str1, str2,

str1.length(), str2.length());
return 0;
}