Skip to content

Commit 18139a3

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0730
No.0730.Count Different Palindromic Subsequences
1 parent 2815f83 commit 18139a3

File tree

6 files changed

+377
-2
lines changed

6 files changed

+377
-2
lines changed

‎solution/0700-0799/0730.Count Different Palindromic Subsequences/README.md

+130-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,151 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：区间 DP**
56+
5557
<!-- tabs:start -->
5658

5759
### **Python3**
5860

5961
<!-- 这里可写当前语言的特殊实现逻辑 -->
6062

6163
```python
62-
64+
class Solution:
65+
def countPalindromicSubsequences(self, s: str) -> int:
66+
mod = 10**9 + 7
67+
n = len(s)
68+
dp = [[[0] * 4 for _ in range(n)] for _ in range(n)]
69+
for i, c in enumerate(s):
70+
dp[i][i][ord(c) - ord('a')] = 1
71+
for l in range(2, n + 1):
72+
for i in range(n - l + 1):
73+
j = i + l - 1
74+
for c in 'abcd':
75+
k = ord(c) - ord('a')
76+
if s[i] == s[j] == c:
77+
dp[i][j][k] = 2 + sum(dp[i + 1][j - 1])
78+
elif s[i] == c:
79+
dp[i][j][k] = dp[i][j - 1][k]
80+
elif s[j] == c:
81+
dp[i][j][k] = dp[i + 1][j][k]
82+
else:
83+
dp[i][j][k] = dp[i + 1][j - 1][k]
84+
return sum(dp[0][-1]) % mod
6385
```
6486

6587
### **Java**
6688

6789
<!-- 这里可写当前语言的特殊实现逻辑 -->
6890

6991
```java
92+
class Solution {
93+
private final int MOD = (int) 1e9 + 7;
94+
95+
public int countPalindromicSubsequences(String s) {
96+
int n = s.length();
97+
long[][][] dp = new long[n][n][4];
98+
for (int i = 0; i < n; ++i) {
99+
dp[i][i][s.charAt(i) - 'a'] = 1;
100+
}
101+
for (int l = 2; l <= n; ++l) {
102+
for (int i = 0; i + l <= n; ++i) {
103+
int j = i + l - 1;
104+
for (char c = 'a'; c <= 'd'; ++c) {
105+
int k = c - 'a';
106+
if (s.charAt(i) == c && s.charAt(j) == c) {
107+
dp[i][j][k] = 2 + dp[i + 1][j - 1][0] + dp[i + 1][j - 1][1] + dp[i + 1][j - 1][2] + dp[i + 1][j - 1][3];
108+
dp[i][j][k] %= MOD;
109+
} else if (s.charAt(i) == c) {
110+
dp[i][j][k] = dp[i][j - 1][k];
111+
} else if (s.charAt(j) == c) {
112+
dp[i][j][k] = dp[i + 1][j][k];
113+
} else {
114+
dp[i][j][k] = dp[i + 1][j - 1][k];
115+
}
116+
}
117+
}
118+
}
119+
long ans = 0;
120+
for (int k = 0; k < 4; ++k) {
121+
ans += dp[0][n - 1][k];
122+
}
123+
return (int) (ans % MOD);
124+
}
125+
}
126+
```
127+
128+
### **C++**
129+
130+
```cpp
131+
using ll = long long;
132+
133+
class Solution {
134+
public:
135+
int countPalindromicSubsequences(string s) {
136+
int mod = 1e9 + 7;
137+
int n = s.size();
138+
vector<vector<vector<ll>>> dp(n, vector<vector<ll>>(n, vector<ll>(4)));
139+
for (int i = 0; i < n; ++i) dp[i][i][s[i] - 'a'] = 1;
140+
for (int l = 2; l <= n; ++l)
141+
{
142+
for (int i = 0; i + l <= n; ++i)
143+
{
144+
int j = i + l - 1;
145+
for (char c = 'a'; c <= 'd'; ++c)
146+
{
147+
int k = c - 'a';
148+
if (s[i] == c && s[j] == c) dp[i][j][k] = 2 + accumulate(dp[i + 1][j - 1].begin(), dp[i + 1][j - 1].end(), 0ll) % mod;
149+
else if (s[i] == c) dp[i][j][k] = dp[i][j - 1][k];
150+
else if (s[j] == c) dp[i][j][k] = dp[i + 1][j][k];
151+
else dp[i][j][k] = dp[i + 1][j - 1][k];
152+
}
153+
}
154+
}
155+
ll ans = accumulate(dp[0][n - 1].begin(), dp[0][n - 1].end(), 0ll);
156+
return (int) (ans % mod);
157+
}
158+
};
159+
```
70160
161+
### **Go**
162+
163+
```go
164+
func countPalindromicSubsequences(s string) int {
165+
mod := int(1e9) + 7
166+
n := len(s)
167+
dp := make([][][]int, n)
168+
for i := range dp {
169+
dp[i] = make([][]int, n)
170+
for j := range dp[i] {
171+
dp[i][j] = make([]int, 4)
172+
}
173+
}
174+
for i, c := range s {
175+
dp[i][i][c-'a'] = 1
176+
}
177+
for l := 2; l <= n; l++ {
178+
for i := 0; i+l <= n; i++ {
179+
j := i + l - 1
180+
for _, c := range [4]byte{'a', 'b', 'c', 'd'} {
181+
k := int(c - 'a')
182+
if s[i] == c && s[j] == c {
183+
dp[i][j][k] = 2 + (dp[i+1][j-1][0]+dp[i+1][j-1][1]+dp[i+1][j-1][2]+dp[i+1][j-1][3])%mod
184+
} else if s[i] == c {
185+
dp[i][j][k] = dp[i][j-1][k]
186+
} else if s[j] == c {
187+
dp[i][j][k] = dp[i+1][j][k]
188+
} else {
189+
dp[i][j][k] = dp[i+1][j-1][k]
190+
}
191+
}
192+
}
193+
}
194+
ans := 0
195+
for _, v := range dp[0][n-1] {
196+
ans += v
197+
}
198+
return ans % mod
199+
}
71200
```
72201

73202
### **...**

‎solution/0700-0799/0730.Count Different Palindromic Subsequences/README_EN.md

+128-1
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,140 @@ Note that &#39;bcb&#39; is counted only once, even though it occurs twice.
4545
### **Python3**
4646

4747
```python
48-
48+
class Solution:
49+
def countPalindromicSubsequences(self, s: str) -> int:
50+
mod = 10**9 + 7
51+
n = len(s)
52+
dp = [[[0] * 4 for _ in range(n)] for _ in range(n)]
53+
for i, c in enumerate(s):
54+
dp[i][i][ord(c) - ord('a')] = 1
55+
for l in range(2, n + 1):
56+
for i in range(n - l + 1):
57+
j = i + l - 1
58+
for c in 'abcd':
59+
k = ord(c) - ord('a')
60+
if s[i] == s[j] == c:
61+
dp[i][j][k] = 2 + sum(dp[i + 1][j - 1])
62+
elif s[i] == c:
63+
dp[i][j][k] = dp[i][j - 1][k]
64+
elif s[j] == c:
65+
dp[i][j][k] = dp[i + 1][j][k]
66+
else:
67+
dp[i][j][k] = dp[i + 1][j - 1][k]
68+
return sum(dp[0][-1]) % mod
4969
```
5070

5171
### **Java**
5272

5373
```java
74+
class Solution {
75+
private final int MOD = (int) 1e9 + 7;
76+
77+
public int countPalindromicSubsequences(String s) {
78+
int n = s.length();
79+
long[][][] dp = new long[n][n][4];
80+
for (int i = 0; i < n; ++i) {
81+
dp[i][i][s.charAt(i) - 'a'] = 1;
82+
}
83+
for (int l = 2; l <= n; ++l) {
84+
for (int i = 0; i + l <= n; ++i) {
85+
int j = i + l - 1;
86+
for (char c = 'a'; c <= 'd'; ++c) {
87+
int k = c - 'a';
88+
if (s.charAt(i) == c && s.charAt(j) == c) {
89+
dp[i][j][k] = 2 + dp[i + 1][j - 1][0] + dp[i + 1][j - 1][1] + dp[i + 1][j - 1][2] + dp[i + 1][j - 1][3];
90+
dp[i][j][k] %= MOD;
91+
} else if (s.charAt(i) == c) {
92+
dp[i][j][k] = dp[i][j - 1][k];
93+
} else if (s.charAt(j) == c) {
94+
dp[i][j][k] = dp[i + 1][j][k];
95+
} else {
96+
dp[i][j][k] = dp[i + 1][j - 1][k];
97+
}
98+
}
99+
}
100+
}
101+
long ans = 0;
102+
for (int k = 0; k < 4; ++k) {
103+
ans += dp[0][n - 1][k];
104+
}
105+
return (int) (ans % MOD);
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
using ll = long long;
114+
115+
class Solution {
116+
public:
117+
int countPalindromicSubsequences(string s) {
118+
int mod = 1e9 + 7;
119+
int n = s.size();
120+
vector<vector<vector<ll>>> dp(n, vector<vector<ll>>(n, vector<ll>(4)));
121+
for (int i = 0; i < n; ++i) dp[i][i][s[i] - 'a'] = 1;
122+
for (int l = 2; l <= n; ++l)
123+
{
124+
for (int i = 0; i + l <= n; ++i)
125+
{
126+
int j = i + l - 1;
127+
for (char c = 'a'; c <= 'd'; ++c)
128+
{
129+
int k = c - 'a';
130+
if (s[i] == c && s[j] == c) dp[i][j][k] = 2 + accumulate(dp[i + 1][j - 1].begin(), dp[i + 1][j - 1].end(), 0ll) % mod;
131+
else if (s[i] == c) dp[i][j][k] = dp[i][j - 1][k];
132+
else if (s[j] == c) dp[i][j][k] = dp[i + 1][j][k];
133+
else dp[i][j][k] = dp[i + 1][j - 1][k];
134+
}
135+
}
136+
}
137+
ll ans = accumulate(dp[0][n - 1].begin(), dp[0][n - 1].end(), 0ll);
138+
return (int) (ans % mod);
139+
}
140+
};
141+
```
54142
143+
### **Go**
144+
145+
```go
146+
func countPalindromicSubsequences(s string) int {
147+
mod := int(1e9) + 7
148+
n := len(s)
149+
dp := make([][][]int, n)
150+
for i := range dp {
151+
dp[i] = make([][]int, n)
152+
for j := range dp[i] {
153+
dp[i][j] = make([]int, 4)
154+
}
155+
}
156+
for i, c := range s {
157+
dp[i][i][c-'a'] = 1
158+
}
159+
for l := 2; l <= n; l++ {
160+
for i := 0; i+l <= n; i++ {
161+
j := i + l - 1
162+
for _, c := range [4]byte{'a', 'b', 'c', 'd'} {
163+
k := int(c - 'a')
164+
if s[i] == c && s[j] == c {
165+
dp[i][j][k] = 2 + (dp[i+1][j-1][0]+dp[i+1][j-1][1]+dp[i+1][j-1][2]+dp[i+1][j-1][3])%mod
166+
} else if s[i] == c {
167+
dp[i][j][k] = dp[i][j-1][k]
168+
} else if s[j] == c {
169+
dp[i][j][k] = dp[i+1][j][k]
170+
} else {
171+
dp[i][j][k] = dp[i+1][j-1][k]
172+
}
173+
}
174+
}
175+
}
176+
ans := 0
177+
for _, v := range dp[0][n-1] {
178+
ans += v
179+
}
180+
return ans % mod
181+
}
55182
```
56183

57184
### **...**

‎solution/0700-0799/0730.Count Different Palindromic Subsequences/Solution.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
using ll = long long;
2+
3+
class Solution {
4+
public:
5+
int countPalindromicSubsequences(string s) {
6+
int mod = 1e9 + 7;
7+
int n = s.size();
8+
vector<vector<vector<ll>>> dp(n, vector<vector<ll>>(n, vector<ll>(4)));
9+
for (int i = 0; i < n; ++i) dp[i][i][s[i] - 'a'] = 1;
10+
for (int l = 2; l <= n; ++l)
11+
{
12+
for (int i = 0; i + l <= n; ++i)
13+
{
14+
int j = i + l - 1;
15+
for (char c = 'a'; c <= 'd'; ++c)
16+
{
17+
int k = c - 'a';
18+
if (s[i] == c && s[j] == c) dp[i][j][k] = 2 + accumulate(dp[i + 1][j - 1].begin(), dp[i + 1][j - 1].end(), 0ll) % mod;
19+
else if (s[i] == c) dp[i][j][k] = dp[i][j - 1][k];
20+
else if (s[j] == c) dp[i][j][k] = dp[i + 1][j][k];
21+
else dp[i][j][k] = dp[i + 1][j - 1][k];
22+
}
23+
}
24+
}
25+
ll ans = accumulate(dp[0][n - 1].begin(), dp[0][n - 1].end(), 0ll);
26+
return (int) (ans % mod);
27+
}
28+
};

‎solution/0700-0799/0730.Count Different Palindromic Subsequences/Solution.go

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
func countPalindromicSubsequences(s string) int {
2+
mod := int(1e9) + 7
3+
n := len(s)
4+
dp := make([][][]int, n)
5+
for i := range dp {
6+
dp[i] = make([][]int, n)
7+
for j := range dp[i] {
8+
dp[i][j] = make([]int, 4)
9+
}
10+
}
11+
for i, c := range s {
12+
dp[i][i][c-'a'] = 1
13+
}
14+
for l := 2; l <= n; l++ {
15+
for i := 0; i+l <= n; i++ {
16+
j := i + l - 1
17+
for _, c := range [4]byte{'a', 'b', 'c', 'd'} {
18+
k := int(c - 'a')
19+
if s[i] == c && s[j] == c {
20+
dp[i][j][k] = 2 + (dp[i+1][j-1][0]+dp[i+1][j-1][1]+dp[i+1][j-1][2]+dp[i+1][j-1][3])%mod
21+
} else if s[i] == c {
22+
dp[i][j][k] = dp[i][j-1][k]
23+
} else if s[j] == c {
24+
dp[i][j][k] = dp[i+1][j][k]
25+
} else {
26+
dp[i][j][k] = dp[i+1][j-1][k]
27+
}
28+
}
29+
}
30+
}
31+
ans := 0
32+
for _, v := range dp[0][n-1] {
33+
ans += v
34+
}
35+
return ans % mod
36+
}

‎solution/0700-0799/0730.Count Different Palindromic Subsequences/Solution.java

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
class Solution {
2+
private final int MOD = (int) 1e9 + 7;
3+
4+
public int countPalindromicSubsequences(String s) {
5+
int n = s.length();
6+
long[][][] dp = new long[n][n][4];
7+
for (int i = 0; i < n; ++i) {
8+
dp[i][i][s.charAt(i) - 'a'] = 1;
9+
}
10+
for (int l = 2; l <= n; ++l) {
11+
for (int i = 0; i + l <= n; ++i) {
12+
int j = i + l - 1;
13+
for (char c = 'a'; c <= 'd'; ++c) {
14+
int k = c - 'a';
15+
if (s.charAt(i) == c && s.charAt(j) == c) {
16+
dp[i][j][k] = 2 + dp[i + 1][j - 1][0] + dp[i + 1][j - 1][1] + dp[i + 1][j - 1][2] + dp[i + 1][j - 1][3];
17+
dp[i][j][k] %= MOD;
18+
} else if (s.charAt(i) == c) {
19+
dp[i][j][k] = dp[i][j - 1][k];
20+
} else if (s.charAt(j) == c) {
21+
dp[i][j][k] = dp[i + 1][j][k];
22+
} else {
23+
dp[i][j][k] = dp[i + 1][j - 1][k];
24+
}
25+
}
26+
}
27+
}
28+
long ans = 0;
29+
for (int k = 0; k < 4; ++k) {
30+
ans += dp[0][n - 1][k];
31+
}
32+
return (int) (ans % MOD);
33+
}
34+
}

0 commit comments

Comments
 (0)