Add longest increase and shortest common

Author: Ren0503

src/algorithms/sets/longest-increasing-subsequence/README.md

@@ -0,0 +1,38 @@
+# Chuỗi Con Tăng Dần Dài Nhất 
+
+Bài toán về chuỗi con tăng dần dài nhất là tìm chuỗi con của một chuỗi đã cho, trong đó các phần tử của chuỗi con được sắp xếp theo thứ tự, từ thấp nhất đến cao nhất, và đấy là chuỗi con dài nhất có thể. Chuỗi con này không nhất thiết phải liền kề hoặc duy nhất.
+
+## Độ phức tạp
+
+Chuỗi con tăng dần dài nhất có thời gian giải là `O(n log n)`, với `n` là độ dài chuỗi đầu vào.
+
+Phương pháp quy hoạch động có độ phức tạp là `O(n*n)`.
+
+## Ví dụ
+
+Ta có 16 số hạng đầu tiên của chuỗi nhị phân Van der Corput:
+
+```text
+0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
+```
+
+có chuỗi con tăng dần dài nhất là:
+
+```text
+0, 2, 6, 9, 11, 15.
+```
+
+Chuỗi con tăng dần dài nhất trong ví dụ này không phải là duy nhất, ví dụ:
+
+```text
+0, 4, 6, 9, 11, 15 or
+0, 2, 6, 9, 13, 15 or
+0, 4, 6, 9, 13, 15
+```
+
+là các chuỗi con tăng dần khác có độ dài bằng nhau trong cùng một chuỗi đầu vào.
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Longest_increasing_subsequence)
+- [Dynamic Programming Approach on YouTube](https://www.youtube.com/watch?v=CE2b_-XfVDk&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/algorithms/sets/longest-increasing-subsequence/__test__/dpLongestIncreasingSubsequence.test.js

@@ -0,0 +1,36 @@
+import dpLongestIncreasingSubsequence from '../dpLongestIncreasingSubsequence';
+
+describe('dpLongestIncreasingSubsequence', () => {
+  it('should find longest increasing subsequence length', () => {
+    // Should be:
+    // 9 or
+    // 8 or
+    // 7 or
+    // 6 or
+    // ...
+    expect(dpLongestIncreasingSubsequence([
+      9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
+    ])).toBe(1);
+
+    // Should be:
+    // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+    expect(dpLongestIncreasingSubsequence([
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+    ])).toBe(10);
+
+    // Should be:
+    // -1, 0, 2, 3
+    expect(dpLongestIncreasingSubsequence([
+      3, 4, -1, 0, 6, 2, 3,
+    ])).toBe(4);
+
+    // Should be:
+    // 0, 2, 6, 9, 11, 15 or
+    // 0, 4, 6, 9, 11, 15 or
+    // 0, 2, 6, 9, 13, 15 or
+    // 0, 4, 6, 9, 13, 15
+    expect(dpLongestIncreasingSubsequence([
+      0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15,
+    ])).toBe(6);
+  });
+});

src/algorithms/sets/longest-increasing-subsequence/dpLongestIncreasingSubsequence.js

@@ -0,0 +1,51 @@
+/**
+ * Phương pháp quy hoạch động tìm chuỗi con tăng dần dài nhất.
+ * Độ phức tạp: O(n * n)
+ *
+ * @param {number[]} sequence
+ * @return {number}
+ */
+export default function dpLongestIncreasingSubsequence(sequence) {
+    // Tạo mảng chứa độ dài của chuỗi con tăng dần dài nhất và điền 1
+    // có nghĩa là mỗi phần tử là một chuỗi con tăng dần tối thiếu.
+    const lengthsArray = Array(sequence.length).fill(1);
+
+    let previousElementIndex = 0;
+    let currentElementIndex = 1;
+
+    while (currentElementIndex < sequence.length) {
+        if (sequence[previousElementIndex] < sequence[currentElementIndex]) {
+            // Nếu phần tử hiện tại lớn hơn phần tử trước đó thì nó là một 
+            // phần của chuỗi con tăng dần có độ dài lớn hơn chuỗi con tăng
+            // dần trước đó.
+            const newLength = lengthsArray[previousElementIndex] + 1;
+            if (newLength > lengthsArray[currentElementIndex]) {
+                // Chỉ tăng nếu phần tử trước đó cho ta chuỗi con có độ
+                // dài lớn hơn ta đang có ở phần tử hiện tại.
+                lengthsArray[currentElementIndex] = newLength;
+            }
+        }
+
+        // Di chuyển chỉ số phần tử trước đó sang phải.
+        previousElementIndex += 1;
+
+        // Nếu chỉ số phần tử trước đó bằng với chỉ số phần tử hiện tại thì hãy dịch 
+        // chuyển phần tử hiện tại sang phải và đặt lại chỉ số phần tử trước đó về 0.
+        if (previousElementIndex === currentElementIndex) {
+            currentElementIndex += 1;
+            previousElementIndex = 0;
+        }
+    }
+
+    // Tìm phần tử lớn nhất trong lengthsArray.
+    // Con số này là độ dài lớn nhất của chuỗi con tăng dần.
+    let longestIncreasingLength = 0;
+
+    for (let i = 0; i < lengthsArray.length; i += 1) {
+        if (lengthsArray[i] > longestIncreasingLength) {
+            longestIncreasingLength = lengthsArray[i];
+        }
+    }
+
+    return longestIncreasingLength;
+}

src/algorithms/sets/shortest-common-supersequence/README.md

@@ -0,0 +1,20 @@
+# Chuỗi Chung Ngắn Nhất
+
+Chuỗi chung ngắn nhất (SCS) của hai chuỗi `X` và `Y` là chuỗi ngắn nhất chứa `X` và `Y` như là chuỗi con.
+
+Nói đơn giản, là cho hai chuỗi `str1` và `str2`, hãy tìm chuỗi ngắn nhất chứa cả hai chuỗi `str1` và `str2`.
+
+Bài toán này có liên quan chặc chẽ với tìm chuỗi con chung dài nhất (LCS).
+
+## Ví dụ
+
+```
+Input:   str1 = "geek",  str2 = "eke"
+Output: "geeke"
+Input:   str1 = "AGGTAB",  str2 = "GXTXAYB"
+Output:  "AGXGTXAYB"
+```
+
+## Liên kết
+
+- [GeeksForGeeks](https://www.geeksforgeeks.org/shortest-common-supersequence/)

src/algorithms/sets/shortest-common-supersequence/__test__/shortestCommonSupersequence.test.js

@@ -0,0 +1,35 @@
+import shortestCommonSupersequence from '../shortestCommonSupersequence';
+
+describe('shortestCommonSupersequence', () => {
+  it('should find shortest common supersequence of two sequences', () => {
+    // LCS (longest common subsequence) is empty
+    expect(shortestCommonSupersequence(
+      ['A', 'B', 'C'],
+      ['D', 'E', 'F'],
+    )).toEqual(['A', 'B', 'C', 'D', 'E', 'F']);
+
+    // LCS (longest common subsequence) is "EE"
+    expect(shortestCommonSupersequence(
+      ['G', 'E', 'E', 'K'],
+      ['E', 'K', 'E'],
+    )).toEqual(['G', 'E', 'K', 'E', 'K']);
+
+    // LCS (longest common subsequence) is "GTAB"
+    expect(shortestCommonSupersequence(
+      ['A', 'G', 'G', 'T', 'A', 'B'],
+      ['G', 'X', 'T', 'X', 'A', 'Y', 'B'],
+    )).toEqual(['A', 'G', 'G', 'X', 'T', 'X', 'A', 'Y', 'B']);
+
+    // LCS (longest common subsequence) is "BCBA".
+    expect(shortestCommonSupersequence(
+      ['A', 'B', 'C', 'B', 'D', 'A', 'B'],
+      ['B', 'D', 'C', 'A', 'B', 'A'],
+    )).toEqual(['A', 'B', 'D', 'C', 'A', 'B', 'D', 'A', 'B']);
+
+    // LCS (longest common subsequence) is "BDABA".
+    expect(shortestCommonSupersequence(
+      ['B', 'D', 'C', 'A', 'B', 'A'],
+      ['A', 'B', 'C', 'B', 'D', 'A', 'B', 'A', 'C'],
+    )).toEqual(['A', 'B', 'C', 'B', 'D', 'C', 'A', 'B', 'A', 'C']);
+  });
+});

src/algorithms/sets/shortest-common-supersequence/shortestCommonSupersequence.js

@@ -0,0 +1,71 @@
+import longestCommonSubsequence from '../longest-common-subsequence/longestCommonSubsequence';
+
+/**
+ * @param {string[]} set1
+ * @param {string[]} set2
+ * @return {string[]}
+ */
+
+export default function shortestCommonSupersequence(set1, set2) {
+    // Tìm chuỗi con chung dài nhất của hai chuỗi.
+    const lcs = longestCommonSubsequence(set1, set2);
+
+    // Nếu LCS rỗng thì chuỗi chung ngắn nhất sẽ chỉ là nối hai chuỗi lại.
+    if (lcs.length === 1 && lcs[0] === '') {
+        return set1.concat(set2);
+    }
+
+    // Không thì ta sẽ thêm phần tử set1 và set2 vào theo thứ tự
+    // trước/trong/sau của LCS.
+    let supersequence = [];
+
+    let setIndex1 = 0;
+    let setIndex2 = 0;
+    let lcsIndex = 0;
+    let setOnHold1 = false;
+    let setOnHold2 = false;
+
+    while (lcsIndex < lcs.length) {
+        // Thêm phần tử của set1 vào chuỗi supersequence theo đúng thứ tự.
+        if (setIndex1 < set1.length) {
+            if (!setOnHold1 && set1[setIndex1] !== lcs[lcsIndex]) {
+                supersequence.push(set1[setIndex1]);
+                setIndex1 += 1;
+            } else {
+                setOnHold1 = true;
+            }
+        }
+
+        // Thêm phần tử của set2 vào chuỗi supersequence theo đúng thứ tự.
+        if (setIndex2 < set2.length) {
+            if (!setOnHold2 && set2[setIndex2] !== lcs[lcsIndex]) {
+                supersequence.push(set2[setIndex2]);
+                setIndex2 += 1;
+            } else {
+                setOnHold2 = true;
+            }
+        }
+
+        // Thêm phần tử của LCS vào chuỗi supersequence theo đúng thứ tự.
+        if (setOnHold1 && setOnHold2) {
+            supersequence.push(lcs[lcsIndex]);
+            lcsIndex += 1;
+            setIndex1 += 1;
+            setIndex2 += 1;
+            setOnHold1 = false;
+            setOnHold2 = false;
+        }
+    }
+
+    // Đính kèm phần thừa của set1.
+    if (setIndex1 < set1.length) {
+        supersequence = supersequence.concat(set1.slice(setIndex1));
+    }
+
+    // Đính kèm phần thừa của set2.
+    if (setIndex2 < set2.length) {
+        supersequence = supersequence.concat(set2.slice(setIndex2));
+    }
+
+    return supersequence;
+}