// Contoh: Fibonacci dengan Memoization
const fib = (n: number, memo: Record<number, number> = {}): number => {
  if (n <= 1) return n;
  if (memo[n]) return memo[n];  // Ambil dari cache!
  
  memo[n] = fib(n - 1, memo) + fib(n - 2, memo);  // Simpan ke cache
  return memo[n];
};

// Contoh: Fibonacci dengan Tabulation
const fib = (n: number): number => {
  if (n <= 1) return n;
  
  const dp: number[] = [0, 1];  // Tabel untuk menyimpan hasil
  
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];  // Isi tabel dari bawah
  }
  
  return dp[n];
};

export const knapsack = (
  capacity: number,
  weights: number[],
  values: number[]
): number => {
  const n = weights.length;
  
  // Buat tabel DP dengan ukuran (n+1) x (capacity+1)
  const dp: number[][] = Array(n + 1)
    .fill(0)
    .map(() => Array(capacity + 1).fill(0));

  // Isi tabel dari barang 1 sampai n
  for (let i = 1; i <= n; i++) {
    const w = weights[i - 1];   // Berat barang ke-i
    const v = values[i - 1];    // Nilai barang ke-i
    
    for (let c = 1; c <= capacity; c++) {
      if (w <= c) {
        // Pilih maksimal antara:
        // 1. Ambil barang ini: v + dp[i-1][c-w]
        // 2. Tidak ambil: dp[i-1][c]
        dp[i][c] = Math.max(v + dp[i - 1][c - w], dp[i - 1][c]);
      } else {
        // Berat terlalu berat, tidak bisa diambil
        dp[i][c] = dp[i - 1][c];
      }
    }
  }

  return dp[n][capacity];
};

import { knapsack } from './knapsack';

const capacity = 8;
const weights = [3, 4, 5];
const values = [30, 50, 60];

const result = knapsack(capacity, weights, values);
console.log(result); // Output: 90

export interface CoinChange {
  minCoins: number;  // Jumlah koin minimum
  coins: number[];   // Daftar koin yang digunakan
}

export const coinChange = (money: number, coins: number[]): CoinChange => {
  // Array untuk menyimpan jumlah koin minimum
  const minCoins: number[] = Array(money + 1).fill(Infinity);
  
  // Array untuk melacak koin terakhir yang digunakan
  const lastCoin: number[] = Array(money + 1).fill(-1);

  minCoins[0] = 0;  // Untuk nilai 0, butuh 0 koin

  // Untuk setiap koin
  for (const coin of coins) {
    // Coba buat semua nilai dari coin sampai target
    for (let j = coin; j <= money; j++) {
      // Jika menggunakan koin ini lebih optimal
      if (minCoins[j] > 1 + minCoins[j - coin]) {
        minCoins[j] = 1 + minCoins[j - coin];
        lastCoin[j] = coin;  // Catat koin yang digunakan
      }
    }
  }

  // Rekonstruksi solusi
  const result: CoinChange = {
    minCoins: minCoins[money],
    coins: []
  };

  let total = money;
  while (total > 0) {
    result.coins.push(lastCoin[total]);
    total -= lastCoin[total];
  }

  return result;
};

import { coinChange } from './coin_change';

const result = coinChange(13, [7, 2, 3, 6]);
console.log(result);
// Output: { minCoins: 2, coins: [6, 7] }

export const longestCommonSubsequence = (
  text1: string,
  text2: string
): string => {
  const m = text1.length;
  const n = text2.length;

  // Buat tabel DP
  const dp: number[][] = Array.from({ length: m + 1 }, () =>
    Array(n + 1).fill(0)
  );

  // Isi tabel
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      if (text1[i - 1] === text2[j - 1]) {
        // Karakter cocok, tambah 1 dari diagonal
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        // Karakter beda, ambil nilai maksimal dari atas atau kiri
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }

  // Rekonstruksi LCS dari tabel
  let i = m, j = n;
  const lcs: string[] = [];
  
  while (i > 0 && j > 0) {
    if (text1[i - 1] === text2[j - 1]) {
      // Karakter cocok, masukkan ke hasil
      lcs.unshift(text1[i - 1]);
      i--;
      j--;
    } else if (dp[i - 1][j] > dp[i][j - 1]) {
      // Nilai atas lebih besar, naik
      i--;
    } else {
      // Nilai kiri lebih besar, ke kiri
      j--;
    }
  }

  return lcs.join('');
};

import { longestCommonSubsequence } from './lcs';

console.log(longestCommonSubsequence('ABCD', 'ACDF'));
// Output: "ACD"

console.log(longestCommonSubsequence('AGGTAB', 'GXTXAYB'));
// Output: "GTAB"