feat: add solutions to lc problem: No.0673 (#2048)

No.0673.Number of Longest Increasing Subsequence

Author: yanglbme

solution/0600-0699/0673.Number of Longest Increasing Subsequence/README.md

@@ -1,26 +1,56 @@
-class Solution {
-public:
-    int findNumberOfLIS(vector<int>& nums) {
-        int maxLen = 0, ans = 0, n = nums.size();
-        vector<int> dp(n, 1), cnt(n, 1);
-        for (int i = 0; i < n; ++i) {
-            for (int j = 0; j < i; ++j) {
-                if (nums[i] > nums[j]) {
-                    if (dp[j] + 1 > dp[i]) {
-                        dp[i] = dp[j] + 1;
-                        cnt[i] = cnt[j];
-                    } else if (dp[j] + 1 == dp[i]) {
-                        cnt[i] += cnt[j];
-                    }
-                }
-            }
-            if (dp[i] > maxLen) {
-                maxLen = dp[i];
-                ans = cnt[i];
-            } else if (dp[i] == maxLen) {
-                ans += cnt[i];
-            }
-        }
-        return ans;
-    }
-};
+class BinaryIndexedTree {
+private:
+    int n;
+    vector<int> c;
+    vector<int> d;
+
+public:
+    BinaryIndexedTree(int n)
+        : n(n)
+        , c(n + 1, 0)
+        , d(n + 1, 0) {}
+
+    void update(int x, int v, int cnt) {
+        while (x <= n) {
+            if (c[x] < v) {
+                c[x] = v;
+                d[x] = cnt;
+            } else if (c[x] == v) {
+                d[x] += cnt;
+            }
+            x += x & -x;
+        }
+    }
+
+    pair<int, int> query(int x) {
+        int v = 0, cnt = 0;
+        while (x > 0) {
+            if (c[x] > v) {
+                v = c[x];
+                cnt = d[x];
+            } else if (c[x] == v) {
+                cnt += d[x];
+            }
+            x -= x & -x;
+        }
+        return {v, cnt};
+    }
+};
+
+class Solution {
+public:
+    int findNumberOfLIS(vector<int>& nums) {
+        vector<int> arr = nums;
+        sort(arr.begin(), arr.end());
+        arr.erase(unique(arr.begin(), arr.end()), arr.end());
+        int m = arr.size();
+        BinaryIndexedTree tree(m);
+        for (int x : nums) {
+            auto it = lower_bound(arr.begin(), arr.end(), x);
+            int i = distance(arr.begin(), it) + 1;
+            auto [v, cnt] = tree.query(i - 1);
+            tree.update(i, v + 1, max(cnt, 1));
+        }
+        return tree.query(m).second;
+    }
+};

solution/0600-0699/0673.Number of Longest Increasing Subsequence/README_EN.md

@@ -1,25 +1,54 @@
-func findNumberOfLIS(nums []int) int {
-	maxLen, ans, n := 0, 0, len(nums)
-	dp, cnt := make([]int, n), make([]int, n)
-	for i := 0; i < n; i++ {
-		dp[i] = 1
-		cnt[i] = 1
-		for j := 0; j < i; j++ {
-			if nums[i] > nums[j] {
-				if dp[j]+1 > dp[i] {
-					dp[i] = dp[j] + 1
-					cnt[i] = cnt[j]
-				} else if dp[j]+1 == dp[i] {
-					cnt[i] += cnt[j]
-				}
-			}
+type BinaryIndexedTree struct {
+	n int
+	c []int
+	d []int
+}
+
+func newBinaryIndexedTree(n int) BinaryIndexedTree {
+	return BinaryIndexedTree{
+		n: n,
+		c: make([]int, n+1),
+		d: make([]int, n+1),
+	}
+}
+
+func (bit *BinaryIndexedTree) update(x, v, cnt int) {
+	for x <= bit.n {
+		if bit.c[x] < v {
+			bit.c[x] = v
+			bit.d[x] = cnt
+		} else if bit.c[x] == v {
+			bit.d[x] += cnt
 		}
-		if dp[i] > maxLen {
-			maxLen = dp[i]
-			ans = cnt[i]
-		} else if dp[i] == maxLen {
-			ans += cnt[i]
+		x += x & -x
+	}
+}
+
+func (bit *BinaryIndexedTree) query(x int) (int, int) {
+	v, cnt := 0, 0
+	for x > 0 {
+		if bit.c[x] > v {
+			v = bit.c[x]
+			cnt = bit.d[x]
+		} else if bit.c[x] == v {
+			cnt += bit.d[x]
 		}
+		x -= x & -x
+	}
+	return v, cnt
+}
+
+func findNumberOfLIS(nums []int) int {
+	arr := make([]int, len(nums))
+	copy(arr, nums)
+	sort.Ints(arr)
+	m := len(arr)
+	tree := newBinaryIndexedTree(m)
+	for _, x := range nums {
+		i := sort.SearchInts(arr, x) + 1
+		v, cnt := tree.query(i - 1)
+		tree.update(i, v+1, max(cnt, 1))
 	}
+	_, ans := tree.query(m)
 	return ans
 }

solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.cpp

@@ -1,28 +1,55 @@
-class Solution {
-    public int findNumberOfLIS(int[] nums) {
-        int maxLen = 0, ans = 0, n = nums.length;
-        int[] dp = new int[n];
-        int[] cnt = new int[n];
-        for (int i = 0; i < n; i++) {
-            dp[i] = 1;
-            cnt[i] = 1;
-            for (int j = 0; j < i; j++) {
-                if (nums[i] > nums[j]) {
-                    if (dp[j] + 1 > dp[i]) {
-                        dp[i] = dp[j] + 1;
-                        cnt[i] = cnt[j];
-                    } else if (dp[j] + 1 == dp[i]) {
-                        cnt[i] += cnt[j];
-                    }
-                }
-            }
-            if (dp[i] > maxLen) {
-                maxLen = dp[i];
-                ans = cnt[i];
-            } else if (dp[i] == maxLen) {
-                ans += cnt[i];
-            }
-        }
-        return ans;
-    }
-}
+class BinaryIndexedTree {
+    private int n;
+    private int[] c;
+    private int[] d;
+
+    public BinaryIndexedTree(int n) {
+        this.n = n;
+        c = new int[n + 1];
+        d = new int[n + 1];
+    }
+
+    public void update(int x, int v, int cnt) {
+        while (x <= n) {
+            if (c[x] < v) {
+                c[x] = v;
+                d[x] = cnt;
+            } else if (c[x] == v) {
+                d[x] += cnt;
+            }
+            x += x & -x;
+        }
+    }
+
+    public int[] query(int x) {
+        int v = 0, cnt = 0;
+        while (x > 0) {
+            if (c[x] > v) {
+                v = c[x];
+                cnt = d[x];
+            } else if (c[x] == v) {
+                cnt += d[x];
+            }
+            x -= x & -x;
+        }
+        return new int[] {v, cnt};
+    }
+}
+
+public class Solution {
+    public int findNumberOfLIS(int[] nums) {
+        // int[] arr = Arrays.stream(nums).distinct().sorted().toArray();
+        int[] arr = nums.clone();
+        Arrays.sort(arr);
+        int m = arr.length;
+        BinaryIndexedTree tree = new BinaryIndexedTree(m);
+        for (int x : nums) {
+            int i = Arrays.binarySearch(arr, x) + 1;
+            int[] t = tree.query(i - 1);
+            int v = t[0];
+            int cnt = t[1];
+            tree.update(i, v + 1, Math.max(cnt, 1));
+        }
+        return tree.query(m)[1];
+    }
+}

solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.go

@@ -1,18 +1,39 @@
-class Solution:
-    def findNumberOfLIS(self, nums: List[int]) -> int:
-        maxLen, ans, n = 0, 0, len(nums)
-        dp, cnt = [1] * n, [1] * n
-        for i in range(n):
-            for j in range(i):
-                if nums[i] > nums[j]:
-                    if dp[j] + 1 > dp[i]:
-                        dp[i] = dp[j] + 1
-                        cnt[i] = cnt[j]
-                    elif dp[j] + 1 == dp[i]:
-                        cnt[i] += cnt[j]
-            if dp[i] > maxLen:
-                maxLen = dp[i]
-                ans = cnt[i]
-            elif dp[i] == maxLen:
-                ans += cnt[i]
-        return ans
+class BinaryIndexedTree:
+    __slots__ = ["n", "c", "d"]
+
+    def __init__(self, n):
+        self.n = n
+        self.c = [0] * (n + 1)
+        self.d = [0] * (n + 1)
+
+    def update(self, x, v, cnt):
+        while x <= self.n:
+            if self.c[x] < v:
+                self.c[x] = v
+                self.d[x] = cnt
+            elif self.c[x] == v:
+                self.d[x] += cnt
+            x += x & -x
+
+    def query(self, x):
+        v = cnt = 0
+        while x:
+            if self.c[x] > v:
+                v = self.c[x]
+                cnt = self.d[x]
+            elif self.c[x] == v:
+                cnt += self.d[x]
+            x -= x & -x
+        return v, cnt
+
+
+class Solution:
+    def findNumberOfLIS(self, nums: List[int]) -> int:
+        arr = sorted(set(nums))
+        m = len(arr)
+        tree = BinaryIndexedTree(m)
+        for x in nums:
+            i = bisect_left(arr, x) + 1
+            v, cnt = tree.query(i - 1)
+            tree.update(i, v + 1, max(cnt, 1))
+        return tree.query(m)[1]

solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.java

@@ -1,28 +1,59 @@
+struct BinaryIndexedTree {
+    n: usize,
+    c: Vec<i32>,
+    d: Vec<i32>,
+}
+
+impl BinaryIndexedTree {
+    fn new(n: usize) -> BinaryIndexedTree {
+        BinaryIndexedTree {
+            n,
+            c: vec![0; n + 1],
+            d: vec![0; n + 1],
+        }
+    }
+
+    fn update(&mut self, x: usize, v: i32, cnt: i32) {
+        let mut x = x as usize;
+        while x <= self.n {
+            if self.c[x] < v {
+                self.c[x] = v;
+                self.d[x] = cnt;
+            } else if self.c[x] == v {
+                self.d[x] += cnt;
+            }
+            x += x & x.wrapping_neg();
+        }
+    }
+
+    fn query(&self, mut x: usize) -> (i32, i32) {
+        let (mut v, mut cnt) = (0, 0);
+        while x > 0 {
+            if self.c[x] > v {
+                v = self.c[x];
+                cnt = self.d[x];
+            } else if self.c[x] == v {
+                cnt += self.d[x];
+            }
+            x -= x & x.wrapping_neg();
+        }
+        (v, cnt)
+    }
+}
+
 impl Solution {
     pub fn find_number_of_lis(nums: Vec<i32>) -> i32 {
-        let mut max_len = 0;
-        let mut ans = 0;
-        let n = nums.len();
-        let mut dp = vec![1; n];
-        let mut cnt = vec![1; n];
-        for i in 0..n {
-            for j in 0..i {
-                if nums[i] > nums[j] {
-                    if dp[j] + 1 > dp[i] {
-                        dp[i] = dp[j] + 1;
-                        cnt[i] = cnt[j];
-                    } else if dp[j] + 1 == dp[i] {
-                        cnt[i] += cnt[j];
-                    }
-                }
-            }
-            if dp[i] > max_len {
-                max_len = dp[i];
-                ans = cnt[i];
-            } else if dp[i] == max_len {
-                ans += cnt[i];
+        let mut arr: Vec<i32> = nums.iter().cloned().collect();
+        arr.sort();
+        let m = arr.len();
+        let mut tree = BinaryIndexedTree::new(m);
+        for x in nums.iter() {
+            if let Ok(i) = arr.binary_search(x) {
+                let (v, cnt) = tree.query(i);
+                tree.update(i + 1, v + 1, cnt.max(1));
             }
         }
+        let (_, ans) = tree.query(m);
         ans
     }
 }