feat: add solution for deleting duplicate folders in a file system No.3409

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/README.md

@@ -82,10 +82,28 @@ tags:
 
 <!-- tabs:start -->
 
-#### Python3
-
 ```python
-
+class Solution:
+    def longestSubsequence(self, nums: List[int]) -> int:
+        mx = max(nums)
+        mn = min(nums)
+
+        diff = mx - mn
+        dp = [[0] * (diff + 1) for _ in range(mx + 1)]
+        ans = 0
+
+        for n in nums:
+            maxnum = 1
+            for i in range(diff, -1, -1):
+                if n + i <= mx and dp[n + i][i] + 1 > maxnum:
+                    maxnum = dp[n + i][i] + 1
+                if n - i >= 0 and dp[n - i][i] + 1 > maxnum:
+                    maxnum = dp[n - i][i] + 1
+
+                dp[n][i] = maxnum
+                ans = max(maxnum,ans)
+
+        return ans
 ```
 
 #### Java
@@ -97,13 +115,105 @@ tags:
 #### C++
 
 ```cpp
-
+class Solution {
+ public:
+  int longestSubsequence(vector<int>& nums) {
+    const int mx = ranges::max(nums);
+    vector<vector<int>> dp(mx + 1, vector<int>(mx + 1));
+
+    for (const int num : nums) {
+      for (int prev = 1; prev <= mx; ++prev) {
+        const int diff = abs(num - prev);
+        dp[num][diff] = max(dp[num][diff], dp[prev][diff] + 1);
+      }
+      for (int j = mx - 1; j >= 0; --j)
+        dp[num][j] = max(dp[num][j], dp[num][j + 1]);
+    }
+
+    return ranges::max_element(dp, ranges::less{}, [](const vector<int>& row) {
+      return row[0];
+    })->at(0);
+  }
+};
 ```
 
 #### Go
 
 ```go
+func longestSubsequence(nums []int) int {
+	mx, mn := nums[0], nums[0]
+	for _, v := range nums {
+		if v > mx {
+			mx = v
+		}
+		if v < mn {
+			mn = v
+		}
+	}
+	diff := mx - mn
+	dp := make([][]int, mx+1)
+	for i := range dp {
+		dp[i] = make([]int, diff+1)
+	}
+
+	ans := 0
+
+	for _, n := range nums {
+		maxnum := 1
+		for d := diff; d >= 0; d-- {
+			if n+d <= mx && dp[n+d][d]+1 > maxnum {
+				maxnum = dp[n+d][d] + 1
+			}
+			if n-d >= 0 && dp[n-d][d]+1 > maxnum {
+				maxnum = dp[n-d][d] + 1
+			}
+			dp[n][d] = maxnum
+			if maxnum > ans {
+				ans = maxnum
+			}
+		}
+	}
+
+	return ans
+}
+```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn longest_subsequence(nums: Vec<i32>) -> i32 {
+        let mx = *nums.iter().max().unwrap();
+        let mn = *nums.iter().min().unwrap();
+        let diff = (mx - mn) as usize;
+
+        let mut dp = vec![vec![0; diff + 1]; (mx + 1) as usize];
+
+        let mut ans = 0;
+
+        for &n in nums.iter() {
+            let n_usize = n as usize;
+            let mut maxnum = 1;
+
+            for d in (0..=diff).rev() {
+                if n_usize + d <= mx as usize {
+                    if dp[n_usize + d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize + d][d] + 1;
+                    }
+                }
+                if n_usize >= d {
+                    if dp[n_usize - d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize - d][d] + 1;
+                    }
+                }
+                dp[n_usize][d] = maxnum;
+                ans = ans.max(maxnum);
+            }
+        }
+
+        ans
+    }
+}
 ```
 
 <!-- tabs:end -->

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/README_EN.md

@@ -83,7 +83,27 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def longestSubsequence(self, nums: List[int]) -> int:
+        mx = max(nums)
+        mn = min(nums)
+
+        diff = mx - mn
+        dp = [[0] * (diff + 1) for _ in range(mx + 1)]
+        ans = 0
+
+        for n in nums:
+            maxnum = 1
+            for i in range(diff, -1, -1):
+                if n + i <= mx and dp[n + i][i] + 1 > maxnum:
+                    maxnum = dp[n + i][i] + 1
+                if n - i >= 0 and dp[n - i][i] + 1 > maxnum:
+                    maxnum = dp[n - i][i] + 1
+
+                dp[n][i] = maxnum
+                ans = max(maxnum,ans)
+
+        return ans
 ```
 
 #### Java
@@ -95,12 +115,106 @@ tags:
 #### C++
 
 ```cpp
-
+class Solution {
+ public:
+  int longestSubsequence(vector<int>& nums) {
+    const int mx = ranges::max(nums);
+    vector<vector<int>> dp(mx + 1, vector<int>(mx + 1));
+
+    for (const int num : nums) {
+      for (int prev = 1; prev <= mx; ++prev) {
+        const int diff = abs(num - prev);
+        dp[num][diff] = max(dp[num][diff], dp[prev][diff] + 1);
+      }
+      for (int j = mx - 1; j >= 0; --j)
+        dp[num][j] = max(dp[num][j], dp[num][j + 1]);
+    }
+
+    return ranges::max_element(dp, ranges::less{}, [](const vector<int>& row) {
+      return row[0];
+    })->at(0);
+  }
+};
 ```
 
 #### Go
 
 ```go
+func longestSubsequence(nums []int) int {
+	mx, mn := nums[0], nums[0]
+	for _, v := range nums {
+		if v > mx {
+			mx = v
+		}
+		if v < mn {
+			mn = v
+		}
+	}
+	diff := mx - mn
+	dp := make([][]int, mx+1)
+	for i := range dp {
+		dp[i] = make([]int, diff+1)
+	}
+
+	ans := 0
+
+	for _, n := range nums {
+		maxnum := 1
+		for d := diff; d >= 0; d-- {
+			if n+d <= mx && dp[n+d][d]+1 > maxnum {
+				maxnum = dp[n+d][d] + 1
+			}
+			if n-d >= 0 && dp[n-d][d]+1 > maxnum {
+				maxnum = dp[n-d][d] + 1
+			}
+			dp[n][d] = maxnum
+			if maxnum > ans {
+				ans = maxnum
+			}
+		}
+	}
+
+	return ans
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn longest_subsequence(nums: Vec<i32>) -> i32 {
+        let mx = *nums.iter().max().unwrap();
+        let mn = *nums.iter().min().unwrap();
+        let diff = (mx - mn) as usize;
+
+        let mut dp = vec![vec![0; diff + 1]; (mx + 1) as usize];
+
+        let mut ans = 0;
+
+        for &n in nums.iter() {
+            let n_usize = n as usize;
+            let mut maxnum = 1;
+
+            for d in (0..=diff).rev() {
+                if n_usize + d <= mx as usize {
+                    if dp[n_usize + d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize + d][d] + 1;
+                    }
+                }
+                if n_usize >= d {
+                    if dp[n_usize - d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize - d][d] + 1;
+                    }
+                }
+                dp[n_usize][d] = maxnum;
+                ans = ans.max(maxnum);
+            }
+        }
+
+        ans
+    }
+}
+
 
 ```
 

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/Solution.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+#include <ranges>
+#include <vector>
+using namespace std;
+using namespace std::ranges;
+
+class Solution {
+public:
+    int longestSubsequence(vector<int>& nums) {
+        const int mx = max(nums);
+        vector<vector<int>> dp(mx + 1, vector<int>(mx + 1));
+
+        for (const int num : nums) {
+            for (int prev = 1; prev <= mx; ++prev) {
+                const int diff = abs(num - prev);
+                dp[num][diff] = max(dp[num][diff], dp[prev][diff] + 1);
+            }
+            for (int j = mx - 1; j >= 0; --j)
+                dp[num][j] = max(dp[num][j], dp[num][j + 1]);
+        }
+
+        return max_element(dp, less{}, [](const vector<int>& row) {
+            return row[0];
+        })->at(0);
+    }
+};

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/Solution.go

@@ -0,0 +1,36 @@
+func longestSubsequence(nums []int) int {
+	mx, mn := nums[0], nums[0]
+	for _, v := range nums {
+		if v > mx {
+			mx = v
+		}
+		if v < mn {
+			mn = v
+		}
+	}
+	diff := mx - mn
+	dp := make([][]int, mx+1)
+	for i := range dp {
+		dp[i] = make([]int, diff+1)
+	}
+
+	ans := 0
+
+	for _, n := range nums {
+		maxnum := 1
+		for d := diff; d >= 0; d-- {
+			if n+d <= mx && dp[n+d][d]+1 > maxnum {
+				maxnum = dp[n+d][d] + 1
+			}
+			if n-d >= 0 && dp[n-d][d]+1 > maxnum {
+				maxnum = dp[n-d][d] + 1
+			}
+			dp[n][d] = maxnum
+			if maxnum > ans {
+				ans = maxnum
+			}
+		}
+	}
+
+	return ans
+}

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/Solution.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    def longestSubsequence(self, nums: List[int]) -> int:
+        mx = max(nums)
+        mn = min(nums)
+
+        diff = mx - mn
+        dp = [[0] * (diff + 1) for _ in range(mx + 1)]
+        ans = 0
+
+        for n in nums:
+            maxnum = 1
+            for i in range(diff, -1, -1):
+                if n + i <= mx and dp[n + i][i] + 1 > maxnum:
+                    maxnum = dp[n + i][i] + 1
+                if n - i >= 0 and dp[n - i][i] + 1 > maxnum:
+                    maxnum = dp[n - i][i] + 1
+
+                dp[n][i] = maxnum
+                ans = max(maxnum, ans)
+
+        return ans

solution/3400-3499/3409.Longest Subsequence With Decreasing Adjacent Difference/Solution.rs

@@ -0,0 +1,33 @@
+impl Solution {
+    pub fn longest_subsequence(nums: Vec<i32>) -> i32 {
+        let mx = *nums.iter().max().unwrap();
+        let mn = *nums.iter().min().unwrap();
+        let diff = (mx - mn) as usize;
+
+        let mut dp = vec![vec![0; diff + 1]; (mx + 1) as usize];
+
+        let mut ans = 0;
+
+        for &n in nums.iter() {
+            let n_usize = n as usize;
+            let mut maxnum = 1;
+
+            for d in (0..=diff).rev() {
+                if n_usize + d <= mx as usize {
+                    if dp[n_usize + d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize + d][d] + 1;
+                    }
+                }
+                if n_usize >= d {
+                    if dp[n_usize - d][d] + 1 > maxnum {
+                        maxnum = dp[n_usize - d][d] + 1;
+                    }
+                }
+                dp[n_usize][d] = maxnum;
+                ans = ans.max(maxnum);
+            }
+        }
+
+        ans
+    }
+}