mcm obst and tsp

Dynamic Programming/01Knapsack.cpp

@@ -0,0 +1,109 @@
+// Created on 29-07-2019 16:21:24 by necronomicon
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <queue>
+#include <deque>
+#include <bitset>
+#include <iterator>
+#include <list>
+#include <stack>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <limits>
+#include <iomanip>
+#include <ctime>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cassert>
+using namespace std;
+
+#define MP make_pair
+#define PB push_back
+#define ARR_MAX (int)1e5 //Max array length
+#define INF (int)1e9 //10^9
+#define EPS 1e-9 //10^-9
+#define MOD 1000000007 //10^9+7
+#define PI 3.1415926535897932384626433832795
+typedef long int int32;
+typedef unsigned long int uint32;
+typedef long long int int64;
+typedef unsigned long long int  uint64;
+typedef pair<int, int> Pii;
+typedef vector<int> Vi;
+typedef vector<string> Vs;
+typedef vector<Pii> VPii;
+typedef vector<Vi> VVi;
+typedef map<int,int> Mii;
+typedef set<int> Si;
+typedef multimap<int,int> MMii;
+typedef multiset<int> MSi;
+typedef unordered_map<int,int> UMii;
+typedef unordered_set<int> USi;
+typedef unordered_multimap<int,int> UMMii;
+typedef unordered_multiset<int> UMSi;
+typedef priority_queue<int> PQi;
+typedef queue<int> Qi;
+typedef deque<int> DQi;
+
+
+int N, capacity;
+Vi weights, price;
+VVi DP;
+
+int bruteForce(int k, int s){
+    if(k == N) return 0;
+    if(s<weights[k]) return bruteForce(k+1, s);
+    return max(price[k]+bruteForce(k+1, s-weights[k]), bruteForce(k+1, s));
+}
+
+int dpTopDown(int k, int s){
+    if(k == N) return 0;
+    if(DP[k][s] != -1) return DP[k][s];
+    if(s<weights[k]) return DP[k][s] = dpTopDown(k+1, s);
+    return DP[k][s] = max(price[k]+dpTopDown(k+1, s-weights[k]), dpTopDown(k+1, s));
+}
+
+int dpBottomUp(){
+    int ans = 0;
+    for(int i=weights[0]; i<= capacity; i++){
+        DP[0][i-weights[0]] = price[0];
+        ans = max(ans, DP[0][i-weights[0]]);
+    }
+    for(int i=1; i<N; i++){
+        for(int j=weights[i]; j<=capacity; j++){
+            DP[i][j-weights[i]] = DP[i-1][j] + price[i];
+            ans = max(ans, DP[i][j-weights[i]]);
+        }
+    }
+    return ans;
+}
+
+int main (int argc, char const *argv[]) {
+	N = 4;
+    price = {100, 70, 50, 10};
+    weights = {10, 4, 6, 12};
+    capacity = 12;
+
+    // Top Down
+    DP.clear();
+    for(int i=0; i<N; i++) DP.push_back(Vi(capacity+1, -1));
+    cout << "Top-Down: " << dpTopDown(0, capacity) << endl;
+    // for(int i=0; i<N; i++) {for(int j=0; j<=capacity; j++) {cout << DP[i][j] << ' ';} cout << endl;}
+
+    // Bottom Up
+    DP.clear();
+    for(int i=0; i<N; i++) DP.push_back(Vi(capacity+1, 0));
+    cout << "Bottom-Up: " << dpBottomUp() << endl;
+    // for(int i=0; i<N; i++) {for(int j=0; j<=capacity; j++) {cout << DP[i][j] << ' ';} cout << endl;}
+    return EXIT_SUCCESS;
+}

Dynamic Programming/MCM.cpp

@@ -0,0 +1,132 @@
+// Created on 08-09-2019 00:22:11 by necronomicon
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <queue>
+#include <deque>
+#include <bitset>
+#include <iterator>
+#include <list>
+#include <stack>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <limits>
+#include <iomanip>
+#include <ctime>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cassert>
+using namespace std;
+
+#define MP make_pair
+#define PB push_back
+#define ARR_MAX (int)1e5 //Max array length
+#define INF (int)1e9 //10^9
+#define EPS 1e-9 //10^-9
+#define MOD 1000000007 //10^9+7
+#define PI 3.1415926535897932384626433832795
+typedef long int int32;
+typedef unsigned long int uint32;
+typedef long long int int64;
+typedef unsigned long long int  uint64;
+typedef pair<int, int> Pii;
+typedef vector<int> Vi;
+typedef vector<string> Vs;
+typedef vector<Pii> VPii;
+typedef vector<Vi> VVi;
+typedef map<int,int> Mii;
+typedef set<int> Si;
+typedef multimap<int,int> MMii;
+typedef multiset<int> MSi;
+typedef unordered_map<int,int> UMii;
+typedef unordered_set<int> USi;
+typedef unordered_multimap<int,int> UMMii;
+typedef unordered_multiset<int> UMSi;
+typedef priority_queue<int> PQi;
+typedef queue<int> Qi;
+typedef deque<int> DQi;
+
+Vi P; // dimensions
+int N; // total matrices
+VVi DP, DPans;
+
+
+int bruteForce(int i, int j) {
+    if(i == j) return 0;
+    int cost = numeric_limits<int>::max();
+    for (int k = i; k < j; k++)
+    {
+        cost = min(cost, bruteForce(i,k) + bruteForce(k+1, j) + (P[i-1]*P[k]*P[j]));
+    }
+    return cost;
+}
+
+int dpTopDown(int i, int j) {
+    if(i == j) return 0;
+    if(DP[i][j] != -1) return DP[i][j];
+    int cost = numeric_limits<int>::max();
+    for (int k = i; k < j; k++)
+    {
+        cost = min(cost, dpTopDown(i,k) + dpTopDown(k+1, j) + (P[i-1]*P[k]*P[j]));
+    }
+    return DP[i][j] = cost;
+}
+
+int dpBottomUp() {
+
+    for (int i = 0; i <= N; i++) DP[i][i] = 0;
+
+    for (int l = 1; l <= N; l++)
+    {
+        for (int i = 0; i+l <= N; i++)
+        {
+            int j = i+l;
+            int min_cost = numeric_limits<int>::max();
+            for (int k = i; k < j; k++)
+            {
+                int cost = DP[i][k] + DP[k+1][j] + (P[i-1]*P[k]*P[j]);
+                if(min_cost > cost) {
+                    min_cost = cost;
+                    DPans[i][j] = k;
+                }
+            }
+            DP[i][j] = min_cost;
+        }
+    }
+    for(Vi v: DP) {
+        for(int x: v) cout << x << ' ';
+        cout << endl;
+    }
+    cout << endl;
+    for(Vi v: DPans) {
+        for(int x: v) cout << x << ' ';
+        cout << endl;
+    }
+    return DP[1][N];
+}
+
+int main (int argc, char const *argv[]) {
+
+    P = {40, 20, 30, 10, 30};
+    N = P.size()-1;
+
+    cout << "Brute-Force: " << bruteForce(1, N) << endl;
+
+    DP = VVi(P.size(), Vi(P.size(), -1));
+    cout << "Top-Down: " << dpTopDown(1, N) << endl;
+
+    DP = VVi(P.size(), Vi(P.size(), 0));
+    DPans = VVi(P.size(), Vi(P.size(), 0));
+    cout << "Bottom-Up: " << dpBottomUp() << endl;
+
+    return EXIT_SUCCESS;
+}

Dynamic Programming/OBST.cpp

@@ -0,0 +1,108 @@
+// Created on 08-09-2019 00:22:11 by necronomicon
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <queue>
+#include <deque>
+#include <bitset>
+#include <iterator>
+#include <list>
+#include <stack>
+#include <map>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <numeric>
+#include <utility>
+#include <limits>
+#include <iomanip>
+#include <ctime>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <cassert>
+using namespace std;
+
+#define MP make_pair
+#define PB push_back
+#define ARR_MAX (int)1e5 //Max array length
+#define INF (int)1e9 //10^9
+#define EPS 1e-9 //10^-9
+#define MOD 1000000007 //10^9+7
+#define PI 3.1415926535897932384626433832795
+typedef long int int32;
+typedef unsigned long int uint32;
+typedef long long int int64;
+typedef unsigned long long int  uint64;
+typedef pair<int, int> Pii;
+typedef vector<int> Vi;
+typedef vector<string> Vs;
+typedef vector<Pii> VPii;
+typedef vector<Vi> VVi;
+typedef map<int,int> Mii;
+typedef set<int> Si;
+typedef multimap<int,int> MMii;
+typedef multiset<int> MSi;
+typedef unordered_map<int,int> UMii;
+typedef unordered_set<int> USi;
+typedef unordered_multimap<int,int> UMMii;
+typedef unordered_multiset<int> UMSi;
+typedef priority_queue<int> PQi;
+typedef queue<int> Qi;
+typedef deque<int> DQi;
+
+Vi K, F; // keys and frequencies
+int N; // total nodes
+VVi DP;
+
+int calc(int l, int r) {
+    int res=0;
+    for (int i = l; i <= r; i++)
+    {
+        res += F[i];
+    }
+    return res;
+}
+
+int bruteForce(int i, int j) {
+    if(i < 0 || j >= F.size() || i > j) return 0;
+    if(i == j) return F[i];
+    int min_cost = numeric_limits<int>::max();
+    for (int k = i; k <= j; k++)
+    {
+        int cost = bruteForce(i, k-1) + bruteForce(k+1, j) + calc(i,j);
+        min_cost = min(min_cost, cost);
+    }
+    return min_cost;
+}
+
+int dpTopDown(int i, int j) {
+    if(i < 0 || j >= F.size() || i > j) return 0;
+    if(i == j) return F[i];
+    if(DP[i][j] != -1) return DP[i][j];
+    int min_cost = numeric_limits<int>::max();
+    for (int k = i; k <= j; k++)
+    {
+        int cost = bruteForce(i, k-1) + bruteForce(k+1, j) + calc(i,j);
+        min_cost = min(min_cost, cost);
+    }
+    return DP[i][j] = min_cost;
+}
+
+int main (int argc, char const *argv[]) {
+
+	K = {10, 12, 20};
+    F = {34, 8, 50};
+    N = F.size();
+
+    cout << "Brute-Force: " << bruteForce(0, N-1) << endl;
+
+    DP = VVi(N, Vi(N, -1));
+    cout << "Top-Down: " << dpTopDown(0, N-1) << endl;
+
+    return EXIT_SUCCESS;
+}