[Algorithm Design and Techniques]

Author: loiane

src/ts/algorithms/dynamic-programing/knapsack-recursive.ts

@@ -0,0 +1,13 @@
+export function knapSack(capacity: number, weights: number[], values: number[], n: number): number {
+  if (n === 0 || capacity === 0) {
+    return 0;
+  }
+
+  if (weights[n - 1] > capacity) {
+    return knapSack(capacity, weights, values, n - 1);
+  } else {
+    const a: number = values[n - 1] + knapSack(capacity - weights[n - 1], weights, values, n - 1);
+    const b: number = knapSack(capacity, weights, values, n - 1);
+    return a > b ? a : b;
+  }
+}

src/ts/algorithms/dynamic-programing/knapsack.ts

@@ -0,0 +1,53 @@
+export function knapSack(capacity: number, weights: number[], values: number[], n: number) {
+  const kS: Array<Array<number>> = [];
+
+  for (let i = 0; i <= n; i++) {
+    kS[i] = [];
+  }
+
+  for (let i = 0; i <= n; i++) {
+    for (let w = 0; w <= capacity; w++) {
+      if (i === 0 || w === 0) {
+        kS[i][w] = 0;
+      } else if (weights[i - 1] <= w) {
+        const a = values[i - 1] + kS[i - 1][w - weights[i - 1]];
+        const b = kS[i - 1][w];
+        kS[i][w] = a > b ? a : b; // max(a,b)
+        console.log(a + ' can be part of the solution');
+      } else {
+        kS[i][w] = kS[i - 1][w];
+      }
+    }
+    console.log(kS[i].join());
+  }
+
+  // extra algorithm to find the items that are part of the solution
+  findValues(n, capacity, kS, values, weights);
+
+  return kS[n][capacity];
+}
+
+function findValues(
+  n: number,
+  capacity: number,
+  kS: Array<Array<number>>,
+  weights: number[],
+  values: number[]
+) {
+  let i = n;
+  let k = capacity;
+
+  console.log('Items that are part of the solution:');
+
+  while (i > 0 && k > 0) {
+    if (kS[i][k] !== kS[i - 1][k]) {
+      console.log(
+        'item ' + i + ' can be part of solution w,v: ' + weights[i - 1] + ',' + values[i - 1]
+      );
+      i--;
+      k = k - kS[i][k];
+    } else {
+      i--;
+    }
+  }
+}

src/ts/algorithms/dynamic-programing/longest-common-subsequence-print.ts

@@ -0,0 +1,59 @@
+export function lcs(wordX: string, wordY: string) {
+  const m = wordX.length;
+  const n = wordY.length;
+  const l: Array<Array<number>> = [];
+  const solution: Array<Array<string>> = [];
+
+  for (let i = 0; i <= m; i++) {
+    l[i] = [];
+    solution[i] = [];
+    for (let j = 0; j <= n; j++) {
+      l[i][j] = 0;
+      solution[i][j] = '0';
+    }
+  }
+
+  for (let i = 0; i <= m; i++) {
+    for (let j = 0; j <= n; j++) {
+      if (i === 0 || j === 0) {
+        l[i][j] = 0;
+      } else if (wordX[i - 1] === wordY[j - 1]) {
+        l[i][j] = l[i - 1][j - 1] + 1;
+        solution[i][j] = 'diagonal';
+      } else {
+        const a = l[i - 1][j];
+        const b = l[i][j - 1];
+        l[i][j] = a > b ? a : b; // max(a,b)
+        solution[i][j] = l[i][j] === l[i - 1][j] ? 'top' : 'left';
+      }
+    }
+    console.log(l[i].join());
+    console.log(solution[i].join());
+  }
+
+  printSolution(solution, wordX, m, n);
+
+  return l[m][n];
+}
+
+function printSolution(solution: Array<Array<string>>, wordX: string, m: number, n: number) {
+  let a = m;
+  let b = n;
+  let x = solution[a][b];
+  let answer = '';
+
+  while (x !== '0') {
+    if (solution[a][b] === 'diagonal') {
+      answer = wordX[a - 1] + answer;
+      a--;
+      b--;
+    } else if (solution[a][b] === 'left') {
+      b--;
+    } else if (solution[a][b] === 'top') {
+      a--;
+    }
+    x = solution[a][b];
+  }
+
+  console.log('lcs: ' + answer);
+}

src/ts/algorithms/dynamic-programing/longest-common-subsequence.ts

@@ -0,0 +1,29 @@
+export function lcs(wordX: string, wordY: string) {
+  const m = wordX.length;
+  const n = wordY.length;
+  const l: Array<Array<number>> = [];
+
+  for (let i = 0; i <= m; i++) {
+    l[i] = [];
+    for (let j = 0; j <= n; j++) {
+      l[i][j] = 0;
+    }
+  }
+
+  for (let i = 0; i <= m; i++) {
+    for (let j = 0; j <= n; j++) {
+      if (i === 0 || j === 0) {
+        l[i][j] = 0;
+      } else if (wordX[i - 1] === wordY[j - 1]) {
+        l[i][j] = l[i - 1][j - 1] + 1;
+      } else {
+        const a = l[i - 1][j];
+        const b = l[i][j - 1];
+        l[i][j] = a > b ? a : b; // max(a,b)
+      }
+    }
+    console.log(l[i].join());
+  }
+
+  return l[m][n];
+}

src/ts/algorithms/dynamic-programing/matrix-chain-multiplication.ts

@@ -0,0 +1,52 @@
+export function matrixChainOrder(p: number[]): number {
+  const n = p.length;
+
+  const m: Array<Array<number>> = [];
+  const s: Array<Array<number>> = [];
+
+  for (let i = 1; i <= n; i++) {
+    m[i] = [];
+    m[i][i] = 0;
+  }
+
+  for (let i = 0; i <= n; i++) {
+    // to help printing the optimal solution
+    s[i] = []; // auxiliary
+    for (let j = 0; j <= n; j++) {
+      s[i][j] = 0;
+    }
+  }
+
+  for (let l = 2; l < n; l++) {
+    for (let i = 1; i <= n - l + 1; i++) {
+      const j = i + l - 1;
+      m[i][j] = Number.MAX_SAFE_INTEGER;
+      for (let k = i; k <= j - 1; k++) {
+        // q = cost/scalar multiplications
+        const q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
+        if (q < m[i][j]) {
+          m[i][j] = q;
+          s[i][j] = k; // s[i,j] = Second auxiliary table that stores k
+        }
+      }
+    }
+  }
+
+  console.log(m);
+  console.log(s);
+
+  printOptimalParenthesis(s, 1, n - 1);
+
+  return m[1][n - 1];
+}
+
+function printOptimalParenthesis(s: Array<Array<number>>, i: number, j: number) {
+  if (i === j) {
+    console.log('A[' + i + ']');
+  } else {
+    console.log('(');
+    printOptimalParenthesis(s, i, s[i][j]);
+    printOptimalParenthesis(s, s[i][j] + 1, j);
+    console.log(')');
+  }
+}

src/ts/algorithms/dynamic-programing/min-coin-change.ts

@@ -0,0 +1,34 @@
+export function minCoinChange(coins: number[], amount: number) {
+  const cache: Array<Array<number>> = [];
+
+  // tslint:disable-next-line:no-shadowed-variable
+  const makeChange = function(amount: number) {
+    if (!amount) {
+      return [];
+    }
+    if (cache[amount]) {
+      return cache[amount];
+    }
+    let min: number[] = [],
+      newMin,
+      newAmount;
+    for (let i = 0; i < coins.length; i++) {
+      const coin = coins[i];
+      newAmount = amount - coin;
+      if (newAmount >= 0) {
+        newMin = makeChange(newAmount);
+      }
+      if (
+        newAmount >= 0 &&
+        (newMin.length < min.length - 1 || !min.length) &&
+        (newMin.length || !newAmount)
+      ) {
+        min = [coin].concat(newMin);
+        console.log('new Min ' + min + ' for ' + amount);
+      }
+    }
+    return (cache[amount] = min);
+  };
+
+  return makeChange(amount);
+}

src/ts/algorithms/greedy/knapsack.ts

@@ -0,0 +1,19 @@
+function knapSack(capacity: number, weights: number[], values: number[]) {
+  const n = values.length;
+  let load = 0;
+  let val = 0;
+
+  for (let i = 0; i < n && load < capacity; i++) {
+    if (weights[i] <= capacity - load) {
+      val += values[i];
+      load += weights[i];
+      console.log('using item ' + (i + 1) + ' for the solution');
+    } else {
+      const r = (capacity - load) / weights[i];
+      val += r * values[i];
+      load += weights[i];
+      console.log('using ratio of ' + r + ' for item ' + (i + 1) + ' for the solution');
+    }
+  }
+  return val;
+}

src/ts/algorithms/greedy/longest-common-subsequence.ts

@@ -0,0 +1,13 @@
+function lcs(wordX: string, wordY: string, m = wordX.length, n = wordY.length): number {
+  if (m === 0 || n === 0) {
+    return 0;
+  }
+
+  if (wordX[m - 1] === wordY[n - 1]) {
+    return 1 + lcs(wordX, wordY, m - 1, n - 1);
+  } else {
+    const a = lcs(wordX, wordY, m, n - 1);
+    const b = lcs(wordX, wordY, m - 1, n);
+    return a > b ? a : b;
+  }
+}

src/ts/algorithms/greedy/matrix-chain-multiplication.ts

@@ -0,0 +1,18 @@
+export function matrixChainOrder(p: number[], i = 1, j = p.length - 1): number {
+  if (i === j) {
+    return 0;
+  }
+
+  let min = Number.MAX_SAFE_INTEGER;
+
+  for (let k = i; k < j; k++) {
+    const count =
+      matrixChainOrder(p, i, k) + matrixChainOrder(p, k + 1, j) + p[i - 1] * p[k] * p[j];
+
+    if (count < min) {
+      min = count;
+    }
+  }
+
+  return min;
+}

src/ts/algorithms/greedy/min-coin-change.ts

@@ -0,0 +1,12 @@
+function minCoinChange(coins: number[], amount: number) {
+  const change: number[] = [];
+  let total = 0;
+  for (let i = coins.length; i >= 0; i--) {
+    const coin = coins[i];
+    while (total + coin <= amount) {
+      change.push(coin);
+      total += coin;
+    }
+  }
+  return change;
+}

src/ts/index.ts

@@ -62,6 +62,7 @@ export { findMinValue as findMinValue } from './algorithms/search/min-max-search
 
 // chapter 14
 export { binarySearch as binarySearchRecursive } from './algorithms/search/binary-search-recursive';
+export { minCoinChange as minCoinChange } from './algorithms/dynamic-programing/min-coin-change';
 
 
 /* import { hotPotato } from './others/hot-potato';

test/ts/algorithms/dynamic-programming/min-coin-change.spec.ts

@@ -0,0 +1,30 @@
+import 'mocha';
+import { expect } from 'chai';
+import { minCoinChange } from '../../../../src/ts/index';
+
+describe('Dynamic Programming: Min Coin Change', () => {
+
+  it('works with amount 0', () => {
+    expect(minCoinChange([1, 2, 3], 0)).to.deep.equal([]);
+  });
+
+  it('works with amount 1', () => {
+    expect(minCoinChange([1, 2, 3], 1)).to.deep.equal([1]);
+  });
+
+  it('works with amount 2', () => {
+    expect(minCoinChange([1, 2, 3], 2)).to.deep.equal([2]);
+  });
+
+  it('works with amount 3', () => {
+    expect(minCoinChange([1, 2, 3], 3)).to.deep.equal([3]);
+  });
+
+  it('works with amount 4', () => {
+    expect(minCoinChange([1, 2, 3], 4)).to.deep.equal([1, 3]);
+  });
+
+  it('works with amount 6', () => {
+    expect(minCoinChange([1, 2, 3], 6)).to.deep.equal([3, 3]);
+  });
+});