diff --git a/solution/2800-2899/2899.Last Visited Integers/README.md b/solution/2800-2899/2899.Last Visited Integers/README.md
index 4dc86b2fcd6f6..bf57d9266e898 100644
--- a/solution/2800-2899/2899.Last Visited Integers/README.md	
+++ b/solution/2800-2899/2899.Last Visited Integers/README.md	
@@ -178,6 +178,31 @@ function lastVisitedIntegers(words: string[]): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn last_visited_integers(words: Vec<String>) -> Vec<i32> {
+        let mut nums: Vec<i32> = Vec::new();
+        let mut ans: Vec<i32> = Vec::new();
+        let mut k = 0;
+
+        for w in words {
+            if w == "prev" {
+                k += 1;
+                let i = nums.len() as i32 - k;
+                ans.push(if i < 0 { -1 } else { nums[i as usize] });
+            } else {
+                k = 0;
+                nums.push(w.parse::<i32>().unwrap());
+            }
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2800-2899/2899.Last Visited Integers/README_EN.md b/solution/2800-2899/2899.Last Visited Integers/README_EN.md
index 69f936aee718b..23a2b39552d29 100644
--- a/solution/2800-2899/2899.Last Visited Integers/README_EN.md	
+++ b/solution/2800-2899/2899.Last Visited Integers/README_EN.md	
@@ -168,6 +168,31 @@ function lastVisitedIntegers(words: string[]): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn last_visited_integers(words: Vec<String>) -> Vec<i32> {
+        let mut nums: Vec<i32> = Vec::new();
+        let mut ans: Vec<i32> = Vec::new();
+        let mut k = 0;
+
+        for w in words {
+            if w == "prev" {
+                k += 1;
+                let i = nums.len() as i32 - k;
+                ans.push(if i < 0 { -1 } else { nums[i as usize] });
+            } else {
+                k = 0;
+                nums.push(w.parse::<i32>().unwrap());
+            }
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2800-2899/2899.Last Visited Integers/Solution.rs b/solution/2800-2899/2899.Last Visited Integers/Solution.rs
new file mode 100644
index 0000000000000..c32e155383d3f
--- /dev/null
+++ b/solution/2800-2899/2899.Last Visited Integers/Solution.rs	
@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn last_visited_integers(words: Vec<String>) -> Vec<i32> {
+        let mut nums: Vec<i32> = Vec::new();
+        let mut ans: Vec<i32> = Vec::new();
+        let mut k = 0;
+
+        for w in words {
+            if w == "prev" {
+                k += 1;
+                let i = nums.len() as i32 - k;
+                ans.push(if i < 0 { -1 } else { nums[i as usize] });
+            } else {
+                k = 0;
+                nums.push(w.parse::<i32>().unwrap());
+            }
+        }
+
+        ans
+    }
+}
\ No newline at end of file
diff --git a/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README.md b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README.md
index 764f0816c50f7..614ea171a7ce2 100644
--- a/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README.md	
+++ b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README.md	
@@ -140,6 +140,24 @@ function getWordsInLongestSubsequence(n: number, words: string[], groups: number
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        let mut ans = vec![];
+
+        for i in 0..n {
+            if i == 0 || groups[i as usize] != groups[(i - 1) as usize] {
+                ans.push(words[i as usize].clone());
+            }
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README_EN.md b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README_EN.md
index 442c8b51ea454..fb9ab6379010b 100644
--- a/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README_EN.md	
+++ b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/README_EN.md	
@@ -131,6 +131,24 @@ function getWordsInLongestSubsequence(n: number, words: string[], groups: number
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        let mut ans = vec![];
+
+        for i in 0..n {
+            if i == 0 || groups[i as usize] != groups[(i - 1) as usize] {
+                ans.push(words[i as usize].clone());
+            }
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/Solution.rs b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/Solution.rs
new file mode 100644
index 0000000000000..a0dd4fa8c36b5
--- /dev/null
+++ b/solution/2900-2999/2900.Longest Unequal Adjacent Groups Subsequence I/Solution.rs	
@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        let mut ans = vec![];
+
+        for i in 0..n {
+            if i == 0 || groups[i as usize] != groups[(i - 1) as usize] {
+                ans.push(words[i as usize].clone());
+            }
+        }
+
+        ans
+    }
+}
\ No newline at end of file
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README.md b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README.md
index cc37566766dd2..6bcceeeb527fa 100644
--- a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README.md	
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README.md	
@@ -68,6 +68,18 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划**
+
+我们定义 $f[i]$ 表示以第 $i$ 个单词结尾的最长相邻不相等子序列的长度，定义 $g[i]$ 表示以第 $i$ 个单词结尾的最长相邻不相等子序列的前驱下标。初始时 $f[i] = 1$, $g[i] = -1$。
+
+另外，我们定义一个变量 $mx$ 表示最长相邻不相等子序列的长度。
+
+我们枚举 $i$，枚举 $j \in [0, i)$，如果 $groups[i] \neq groups[j]$ 且 $f[i] \lt f[j] + 1$ 且 $words[i]$ 和 $words[j]$ 之间的汉明距离为 $1$，则更新 $f[i] = f[j] + 1$，$g[i] = j$，并且更新 $mx = \max(mx, f[i])$。
+
+最后，我们从 $f$ 数组中找到最大值对应的下标 $i$，然后从 $i$ 开始不断往前找，直到找到 $g[i] = -1$，这样就找到了最长相邻不相等子序列。
+
+时间复杂度 $O(n^2 \times L)$，空间复杂度 $O(n)$。其中 $L$ 表示单词的最大长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -75,7 +87,31 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def getWordsInLongestSubsequence(
+        self, n: int, words: List[str], groups: List[int]
+    ) -> List[str]:
+        def check(s: str, t: str) -> bool:
+            return len(s) == len(t) and sum(a != b for a, b in zip(s, t)) == 1
+
+        f = [1] * n
+        g = [-1] * n
+        mx = 1
+        for i, x in enumerate(groups):
+            for j, y in enumerate(groups[:i]):
+                if x != y and f[i] < f[j] + 1 and check(words[i], words[j]):
+                    f[i] = f[j] + 1
+                    g[i] = j
+                    mx = max(mx, f[i])
+        ans = []
+        for i in range(n):
+            if f[i] == mx:
+                j = i
+                while j >= 0:
+                    ans.append(words[j])
+                    j = g[j]
+                break
+        return ans[::-1]
 ```
 
 ### **Java**
@@ -83,19 +119,229 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public List<String> getWordsInLongestSubsequence(int n, String[] words, int[] groups) {
+        int[] f = new int[n];
+        int[] g = new int[n];
+        Arrays.fill(f, 1);
+        Arrays.fill(g, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = Math.max(mx, f[i]);
+                }
+            }
+        }
+        List<String> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; j >= 0; j = g[j]) {
+                    ans.add(words[j]);
+                }
+                break;
+            }
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+
+    private boolean check(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int cnt = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) != t.charAt(i)) {
+                ++cnt;
+            }
+        }
+        return cnt == 1;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    vector<string> getWordsInLongestSubsequence(int n, vector<string>& words, vector<int>& groups) {
+        auto check = [](string& s, string& t) {
+            if (s.size() != t.size()) {
+                return false;
+            }
+            int cnt = 0;
+            for (int i = 0; i < s.size(); ++i) {
+                cnt += s[i] != t[i];
+            }
+            return cnt == 1;
+        };
+        vector<int> f(n, 1);
+        vector<int> g(n, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = max(mx, f[i]);
+                }
+            }
+        }
+        vector<string> ans;
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; ~j; j = g[j]) {
+                    ans.emplace_back(words[j]);
+                }
+                break;
+            }
+        }
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func getWordsInLongestSubsequence(n int, words []string, groups []int) []string {
+	check := func(s, t string) bool {
+		if len(s) != len(t) {
+			return false
+		}
+		cnt := 0
+		for i := range s {
+			if s[i] != t[i] {
+				cnt++
+			}
+		}
+		return cnt == 1
+	}
+	f := make([]int, n)
+	g := make([]int, n)
+	for i := range f {
+		f[i] = 1
+		g[i] = -1
+	}
+	mx := 1
+	for i, x := range groups {
+		for j, y := range groups[:i] {
+			if x != y && f[i] < f[j]+1 && check(words[i], words[j]) {
+				f[i] = f[j] + 1
+				g[i] = j
+				if mx < f[i] {
+					mx = f[i]
+				}
+			}
+		}
+	}
+	ans := make([]string, 0, mx)
+	for i, x := range f {
+		if x == mx {
+			for j := i; j >= 0; j = g[j] {
+				ans = append(ans, words[j])
+			}
+			break
+		}
+	}
+	for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
+		ans[i], ans[j] = ans[j], ans[i]
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function getWordsInLongestSubsequence(n: number, words: string[], groups: number[]): string[] {
+    const f: number[] = Array(n).fill(1);
+    const g: number[] = Array(n).fill(-1);
+    let mx = 1;
+    const check = (s: string, t: string) => {
+        if (s.length !== t.length) {
+            return false;
+        }
+        let cnt = 0;
+        for (let i = 0; i < s.length; ++i) {
+            if (s[i] !== t[i]) {
+                ++cnt;
+            }
+        }
+        return cnt === 1;
+    };
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (groups[i] !== groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                f[i] = f[j] + 1;
+                g[i] = j;
+                mx = Math.max(mx, f[i]);
+            }
+        }
+    }
+    const ans: string[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (f[i] === mx) {
+            for (let j = i; ~j; j = g[j]) {
+                ans.push(words[j]);
+            }
+            break;
+        }
+    }
+    return ans.reverse();
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        fn check(s: &str, t: &str) -> bool {
+            s.len() == t.len() && s.chars().zip(t.chars()).filter(|(a, b)| a != b).count() == 1
+        }
+
+        let n = n as usize;
+
+        let mut f = vec![1; n];
+        let mut g = vec![-1; n];
+
+        let mut mx = 1;
+
+        for i in 0..n {
+            let x = groups[i] as usize;
+            for j in 0..i {
+                let y = groups[j] as usize;
+                if x != y && f[i] < f[j] + 1 && check(&words[i], &words[j]) {
+                    f[i] = f[j] + 1;
+                    g[i] = j as i32;
+                    mx = mx.max(f[i]);
+                }
+            }
+        }
+
+        let mut ans = vec![];
+        let mut i = n - 1;
+
+        while f[i] != mx {
+            i -= 1;
+        }
+
+        let mut j = i as i32;
+        while j >= 0 {
+            ans.push(words[j as usize].clone());
+            j = g[j as usize];
+        }
+
+        ans.reverse();
+        ans
+    }
+}
 ```
 
 ### **...**
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README_EN.md b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README_EN.md
index 1c7a144327668..615e4aaddffc1 100644
--- a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README_EN.md	
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/README_EN.md	
@@ -62,30 +62,276 @@ Hence, it is the only answer.
 
 ## Solutions
 
+**Solution 1: Dynamic Programming**
+
+We define $f[i]$ as the length of the longest adjacent non-equal subsequence ending with the $i$-th word, and $g[i]$ as the predecessor index of the longest adjacent non-equal subsequence ending with the $i$-th word. Initially, we set $f[i] = 1$ and $g[i] = -1$.
+
+In addition, we define a variable $mx$ to represent the length of the longest adjacent non-equal subsequence.
+
+We traverse $i$ and $j \in [0, i)$, and if $groups[i] \neq groups[j]$, $f[i] \lt f[j] + 1$, and the Hamming distance between $words[i]$ and $words[j]$ is $1$, we update $f[i] = f[j] + 1$, $g[i] = j$, and update $mx = \max(mx, f[i])$.
+
+Finally, we find the index $i$ corresponding to the maximum value in the $f$ array, and then continuously search backwards from $i$ until we find $g[i] = -1$, which gives us the longest adjacent non-equal subsequence.
+
+The time complexity is $O(n^2 \times L)$, and the space complexity is $O(n)$. Here, $L$ represents the maximum length of a word.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def getWordsInLongestSubsequence(
+        self, n: int, words: List[str], groups: List[int]
+    ) -> List[str]:
+        def check(s: str, t: str) -> bool:
+            return len(s) == len(t) and sum(a != b for a, b in zip(s, t)) == 1
+
+        f = [1] * n
+        g = [-1] * n
+        mx = 1
+        for i, x in enumerate(groups):
+            for j, y in enumerate(groups[:i]):
+                if x != y and f[i] < f[j] + 1 and check(words[i], words[j]):
+                    f[i] = f[j] + 1
+                    g[i] = j
+                    mx = max(mx, f[i])
+        ans = []
+        for i in range(n):
+            if f[i] == mx:
+                j = i
+                while j >= 0:
+                    ans.append(words[j])
+                    j = g[j]
+                break
+        return ans[::-1]
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public List<String> getWordsInLongestSubsequence(int n, String[] words, int[] groups) {
+        int[] f = new int[n];
+        int[] g = new int[n];
+        Arrays.fill(f, 1);
+        Arrays.fill(g, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = Math.max(mx, f[i]);
+                }
+            }
+        }
+        List<String> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; j >= 0; j = g[j]) {
+                    ans.add(words[j]);
+                }
+                break;
+            }
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+
+    private boolean check(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int cnt = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) != t.charAt(i)) {
+                ++cnt;
+            }
+        }
+        return cnt == 1;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    vector<string> getWordsInLongestSubsequence(int n, vector<string>& words, vector<int>& groups) {
+        auto check = [](string& s, string& t) {
+            if (s.size() != t.size()) {
+                return false;
+            }
+            int cnt = 0;
+            for (int i = 0; i < s.size(); ++i) {
+                cnt += s[i] != t[i];
+            }
+            return cnt == 1;
+        };
+        vector<int> f(n, 1);
+        vector<int> g(n, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = max(mx, f[i]);
+                }
+            }
+        }
+        vector<string> ans;
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; ~j; j = g[j]) {
+                    ans.emplace_back(words[j]);
+                }
+                break;
+            }
+        }
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func getWordsInLongestSubsequence(n int, words []string, groups []int) []string {
+	check := func(s, t string) bool {
+		if len(s) != len(t) {
+			return false
+		}
+		cnt := 0
+		for i := range s {
+			if s[i] != t[i] {
+				cnt++
+			}
+		}
+		return cnt == 1
+	}
+	f := make([]int, n)
+	g := make([]int, n)
+	for i := range f {
+		f[i] = 1
+		g[i] = -1
+	}
+	mx := 1
+	for i, x := range groups {
+		for j, y := range groups[:i] {
+			if x != y && f[i] < f[j]+1 && check(words[i], words[j]) {
+				f[i] = f[j] + 1
+				g[i] = j
+				if mx < f[i] {
+					mx = f[i]
+				}
+			}
+		}
+	}
+	ans := make([]string, 0, mx)
+	for i, x := range f {
+		if x == mx {
+			for j := i; j >= 0; j = g[j] {
+				ans = append(ans, words[j])
+			}
+			break
+		}
+	}
+	for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
+		ans[i], ans[j] = ans[j], ans[i]
+	}
+	return ans
+}
+```
+
+### **TypeScript**
+
+```ts
+function getWordsInLongestSubsequence(n: number, words: string[], groups: number[]): string[] {
+    const f: number[] = Array(n).fill(1);
+    const g: number[] = Array(n).fill(-1);
+    let mx = 1;
+    const check = (s: string, t: string) => {
+        if (s.length !== t.length) {
+            return false;
+        }
+        let cnt = 0;
+        for (let i = 0; i < s.length; ++i) {
+            if (s[i] !== t[i]) {
+                ++cnt;
+            }
+        }
+        return cnt === 1;
+    };
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (groups[i] !== groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                f[i] = f[j] + 1;
+                g[i] = j;
+                mx = Math.max(mx, f[i]);
+            }
+        }
+    }
+    const ans: string[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (f[i] === mx) {
+            for (let j = i; ~j; j = g[j]) {
+                ans.push(words[j]);
+            }
+            break;
+        }
+    }
+    return ans.reverse();
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        fn check(s: &str, t: &str) -> bool {
+            s.len() == t.len() && s.chars().zip(t.chars()).filter(|(a, b)| a != b).count() == 1
+        }
+
+        let n = n as usize;
+
+        let mut f = vec![1; n];
+        let mut g = vec![-1; n];
+
+        let mut mx = 1;
+
+        for i in 0..n {
+            let x = groups[i] as usize;
+            for j in 0..i {
+                let y = groups[j] as usize;
+                if x != y && f[i] < f[j] + 1 && check(&words[i], &words[j]) {
+                    f[i] = f[j] + 1;
+                    g[i] = j as i32;
+                    mx = mx.max(f[i]);
+                }
+            }
+        }
+
+        let mut ans = vec![];
+        let mut i = n - 1;
+
+        while f[i] != mx {
+            i -= 1;
+        }
+
+        let mut j = i as i32;
+        while j >= 0 {
+            ans.push(words[j as usize].clone());
+            j = g[j as usize];
+        }
+
+        ans.reverse();
+        ans
+    }
+}
 ```
 
 ### **...**
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.cpp b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.cpp
new file mode 100644
index 0000000000000..38551ac4a8cf6
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.cpp	
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    vector<string> getWordsInLongestSubsequence(int n, vector<string>& words, vector<int>& groups) {
+        auto check = [](string& s, string& t) {
+            if (s.size() != t.size()) {
+                return false;
+            }
+            int cnt = 0;
+            for (int i = 0; i < s.size(); ++i) {
+                cnt += s[i] != t[i];
+            }
+            return cnt == 1;
+        };
+        vector<int> f(n, 1);
+        vector<int> g(n, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = max(mx, f[i]);
+                }
+            }
+        }
+        vector<string> ans;
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; ~j; j = g[j]) {
+                    ans.emplace_back(words[j]);
+                }
+                break;
+            }
+        }
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.go b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.go
new file mode 100644
index 0000000000000..1725730b40191
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.go	
@@ -0,0 +1,45 @@
+func getWordsInLongestSubsequence(n int, words []string, groups []int) []string {
+	check := func(s, t string) bool {
+		if len(s) != len(t) {
+			return false
+		}
+		cnt := 0
+		for i := range s {
+			if s[i] != t[i] {
+				cnt++
+			}
+		}
+		return cnt == 1
+	}
+	f := make([]int, n)
+	g := make([]int, n)
+	for i := range f {
+		f[i] = 1
+		g[i] = -1
+	}
+	mx := 1
+	for i, x := range groups {
+		for j, y := range groups[:i] {
+			if x != y && f[i] < f[j]+1 && check(words[i], words[j]) {
+				f[i] = f[j] + 1
+				g[i] = j
+				if mx < f[i] {
+					mx = f[i]
+				}
+			}
+		}
+	}
+	ans := make([]string, 0, mx)
+	for i, x := range f {
+		if x == mx {
+			for j := i; j >= 0; j = g[j] {
+				ans = append(ans, words[j])
+			}
+			break
+		}
+	}
+	for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
+		ans[i], ans[j] = ans[j], ans[i]
+	}
+	return ans
+}
\ No newline at end of file
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.java b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.java
new file mode 100644
index 0000000000000..06ece0ee09667
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public List<String> getWordsInLongestSubsequence(int n, String[] words, int[] groups) {
+        int[] f = new int[n];
+        int[] g = new int[n];
+        Arrays.fill(f, 1);
+        Arrays.fill(g, -1);
+        int mx = 1;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < i; ++j) {
+                if (groups[i] != groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                    f[i] = f[j] + 1;
+                    g[i] = j;
+                    mx = Math.max(mx, f[i]);
+                }
+            }
+        }
+        List<String> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (f[i] == mx) {
+                for (int j = i; j >= 0; j = g[j]) {
+                    ans.add(words[j]);
+                }
+                break;
+            }
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+
+    private boolean check(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int cnt = 0;
+        for (int i = 0; i < s.length(); ++i) {
+            if (s.charAt(i) != t.charAt(i)) {
+                ++cnt;
+            }
+        }
+        return cnt == 1;
+    }
+}
\ No newline at end of file
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.py b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.py
new file mode 100644
index 0000000000000..8ab328ca57aa7
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.py	
@@ -0,0 +1,25 @@
+class Solution:
+    def getWordsInLongestSubsequence(
+        self, n: int, words: List[str], groups: List[int]
+    ) -> List[str]:
+        def check(s: str, t: str) -> bool:
+            return len(s) == len(t) and sum(a != b for a, b in zip(s, t)) == 1
+
+        f = [1] * n
+        g = [-1] * n
+        mx = 1
+        for i, x in enumerate(groups):
+            for j, y in enumerate(groups[:i]):
+                if x != y and f[i] < f[j] + 1 and check(words[i], words[j]):
+                    f[i] = f[j] + 1
+                    g[i] = j
+                    mx = max(mx, f[i])
+        ans = []
+        for i in range(n):
+            if f[i] == mx:
+                j = i
+                while j >= 0:
+                    ans.append(words[j])
+                    j = g[j]
+                break
+        return ans[::-1]
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.rs b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.rs
new file mode 100644
index 0000000000000..ab0ab3148ead7
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.rs	
@@ -0,0 +1,42 @@
+impl Solution {
+    pub fn get_words_in_longest_subsequence(n: i32, words: Vec<String>, groups: Vec<i32>) -> Vec<String> {
+        fn check(s: &str, t: &str) -> bool {
+            s.len() == t.len() && s.chars().zip(t.chars()).filter(|(a, b)| a != b).count() == 1
+        }
+
+        let n = n as usize;
+
+        let mut f = vec![1; n];
+        let mut g = vec![-1; n];
+
+        let mut mx = 1;
+
+        for i in 0..n {
+            let x = groups[i] as usize;
+            for j in 0..i {
+                let y = groups[j] as usize;
+                if x != y && f[i] < f[j] + 1 && check(&words[i], &words[j]) {
+                    f[i] = f[j] + 1;
+                    g[i] = j as i32;
+                    mx = mx.max(f[i]);
+                }
+            }
+        }
+
+        let mut ans = vec![];
+        let mut i = n - 1;
+
+        while f[i] != mx {
+            i -= 1;
+        }
+
+        let mut j = i as i32;
+        while j >= 0 {
+            ans.push(words[j as usize].clone());
+            j = g[j as usize];
+        }
+
+        ans.reverse();
+        ans
+    }
+}
\ No newline at end of file
diff --git a/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.ts b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.ts
new file mode 100644
index 0000000000000..63d9dc9ad9a0b
--- /dev/null
+++ b/solution/2900-2999/2901.Longest Unequal Adjacent Groups Subsequence II/Solution.ts	
@@ -0,0 +1,36 @@
+function getWordsInLongestSubsequence(n: number, words: string[], groups: number[]): string[] {
+    const f: number[] = Array(n).fill(1);
+    const g: number[] = Array(n).fill(-1);
+    let mx = 1;
+    const check = (s: string, t: string) => {
+        if (s.length !== t.length) {
+            return false;
+        }
+        let cnt = 0;
+        for (let i = 0; i < s.length; ++i) {
+            if (s[i] !== t[i]) {
+                ++cnt;
+            }
+        }
+        return cnt === 1;
+    };
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (groups[i] !== groups[j] && f[i] < f[j] + 1 && check(words[i], words[j])) {
+                f[i] = f[j] + 1;
+                g[i] = j;
+                mx = Math.max(mx, f[i]);
+            }
+        }
+    }
+    const ans: string[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (f[i] === mx) {
+            for (let j = i; ~j; j = g[j]) {
+                ans.push(words[j]);
+            }
+            break;
+        }
+    }
+    return ans.reverse();
+}