Skip to content

Commit 4b6d5a6

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.2246,2247 (#1511)
* No.2246.Longest Path With Different Adjacent Characters * No.2247.Maximum Cost of Trip With K Highways
1 parent b18c822 commit 4b6d5a6

File tree

15 files changed

+942
-41
lines changed

15 files changed

+942
-41
lines changed

‎solution/0200-0299/0228.Summary Ranges/README.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@
6161

6262
我们可以用双指针 $i$ 和 $j$ 找出每个区间的左右端点。
6363

64-
遍历数组，当 $j + 1 < n$ 且 $nums[j + 1] = nums[j] + 1$ 时，$j$ 向右移动，否则区间 $[i, j]$ 已经找到，将其加入答案，然后将 $i$ 移动到 $j + 1$ 的位置，继续寻找下一个区间。
64+
遍历数组，当 $j + 1 < n$ 且 $nums[j + 1] = nums[j] + 1$ 时，指针 $j$ 向右移动，否则区间 $[i, j]$ 已经找到，将其加入答案，然后将指针 $i$ 移动到 $j + 1$ 的位置，继续寻找下一个区间。
6565

6666
时间复杂度 $O(n)$，其中 $n$ 为数组长度。空间复杂度 $O(1)$。
6767

‎solution/2200-2299/2246.Longest Path With Different Adjacent Characters/README.md

+131-13
Original file line numberDiff line numberDiff line change
@@ -52,45 +52,163 @@
5252

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

55+
**方法一：树形 DP**
56+
57+
我们先根据数组 $parent$ 构建邻接表 $g$，其中 $g[i]$ 表示节点 $i$ 的所有子节点。
58+
59+
然后我们从根节点开始 DFS，对于每个节点 $i$，我们遍历 $g[i]$ 中的每个子节点 $j$，如果 $s[i] \neq s[j]$，那么我们就可以从 $i$ 节点出发，经过 $j$ 节点，到达某个叶子节点，这条路径的长度为 $x = 1 + dfs(j)$，我们用 $mx$ 记录最长的一条从节点 $i$ 出发的路径长度。同时，在遍历的过程中，更新答案 $ans = \max(ans, mx + x)$。
60+
61+
最后，我们返回 $ans + 1$ 即可。
62+
63+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点个数。
64+
5565
<!-- tabs:start -->
5666

5767
### **Python3**
5868

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

6171
```python
62-
72+
class Solution:
73+
def longestPath(self, parent: List[int], s: str) -> int:
74+
def dfs(i: int) -> int:
75+
mx = 0
76+
nonlocal ans
77+
for j in g[i]:
78+
x = dfs(j) + 1
79+
if s[i] != s[j]:
80+
ans = max(ans, mx + x)
81+
mx = max(mx, x)
82+
return mx
83+
84+
g = defaultdict(list)
85+
for i in range(1, len(parent)):
86+
g[parent[i]].append(i)
87+
ans = 0
88+
dfs(0)
89+
return ans + 1
6390
```
6491

6592
### **Java**
6693

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

6996
```java
97+
class Solution {
98+
private List<Integer>[] g;
99+
private String s;
100+
private int ans;
101+
102+
public int longestPath(int[] parent, String s) {
103+
int n = parent.length;
104+
g = new List[n];
105+
this.s = s;
106+
Arrays.setAll(g, k -> new ArrayList<>());
107+
for (int i = 1; i < n; ++i) {
108+
g[parent[i]].add(i);
109+
}
110+
dfs(0);
111+
return ans + 1;
112+
}
113+
114+
private int dfs(int i) {
115+
int mx = 0;
116+
for (int j : g[i]) {
117+
int x = dfs(j) + 1;
118+
if (s.charAt(i) != s.charAt(j)) {
119+
ans = Math.max(ans, mx + x);
120+
mx = Math.max(mx, x);
121+
}
122+
}
123+
return mx;
124+
}
125+
}
126+
```
127+
128+
### **C++**
129+
130+
```cpp
131+
class Solution {
132+
public:
133+
int longestPath(vector<int>& parent, string s) {
134+
int n = parent.size();
135+
vector<int> g[n];
136+
for (int i = 1; i < n; ++i) {
137+
g[parent[i]].push_back(i);
138+
}
139+
int ans = 0;
140+
function<int(int)> dfs = [&](int i) -> int {
141+
int mx = 0;
142+
for (int j : g[i]) {
143+
int x = dfs(j) + 1;
144+
if (s[i] != s[j]) {
145+
ans = max(ans, mx + x);
146+
mx = max(mx, x);
147+
}
148+
}
149+
return mx;
150+
};
151+
dfs(0);
152+
return ans + 1;
153+
}
154+
};
155+
```
156+
157+
### **Go**
158+
159+
```go
160+
func longestPath(parent []int, s string) int {
161+
n := len(parent)
162+
g := make([][]int, n)
163+
for i := 1; i < n; i++ {
164+
g[parent[i]] = append(g[parent[i]], i)
165+
}
166+
ans := 0
167+
var dfs func(int) int
168+
dfs = func(i int) int {
169+
mx := 0
170+
for _, j := range g[i] {
171+
x := dfs(j) + 1
172+
if s[i] != s[j] {
173+
ans = max(ans, x+mx)
174+
mx = max(mx, x)
175+
}
176+
}
177+
return mx
178+
}
179+
dfs(0)
180+
return ans + 1
181+
}
70182
183+
func max(a, b int) int {
184+
if a > b {
185+
return a
186+
}
187+
return b
188+
}
71189
```
72190

73191
### **TypeScript**
74192

75193
```ts
76194
function longestPath(parent: number[], s: string): number {
77195
const n = parent.length;
78-
let graph = Array.from({ length: n }, v => []);
79-
for (let i = 1; i < n; i++) {
80-
graph[parent[i]].push(i);
196+
const g: number[][] = Array.from({ length: n }, () => []);
197+
for (let i = 1; i < n; ++i) {
198+
g[parent[i]].push(i);
81199
}
82200
let ans = 0;
83-
function dfs(x: number): number {
84-
let maxLen = 0;
85-
for (let y of graph[x]) {
86-
let len = dfs(y) + 1;
87-
if (s.charAt(x) !== s.charAt(y)) {
88-
ans = Math.max(maxLen + len, ans);
89-
maxLen = Math.max(len, maxLen);
201+
const dfs = (i: number): number => {
202+
let mx = 0;
203+
for (const j of g[i]) {
204+
const x = dfs(j) + 1;
205+
if (s[i] !== s[j]) {
206+
ans = Math.max(ans, mx + x);
207+
mx = Math.max(mx, x);
90208
}
91209
}
92-
return maxLen;
93-
}
210+
return mx;
211+
};
94212
dfs(0);
95213
return ans + 1;
96214
}

‎solution/2200-2299/2246.Longest Path With Different Adjacent Characters/README_EN.md

+122-13
Original file line numberDiff line numberDiff line change
@@ -47,36 +47,145 @@ It can be proven that there is no longer path that satisfies the conditions.
4747
### **Python3**
4848

4949
```python
50-
50+
class Solution:
51+
def longestPath(self, parent: List[int], s: str) -> int:
52+
def dfs(i: int) -> int:
53+
mx = 0
54+
nonlocal ans
55+
for j in g[i]:
56+
x = dfs(j) + 1
57+
if s[i] != s[j]:
58+
ans = max(ans, mx + x)
59+
mx = max(mx, x)
60+
return mx
61+
62+
g = defaultdict(list)
63+
for i in range(1, len(parent)):
64+
g[parent[i]].append(i)
65+
ans = 0
66+
dfs(0)
67+
return ans + 1
5168
```
5269

5370
### **Java**
5471

5572
```java
73+
class Solution {
74+
private List<Integer>[] g;
75+
private String s;
76+
private int ans;
77+
78+
public int longestPath(int[] parent, String s) {
79+
int n = parent.length;
80+
g = new List[n];
81+
this.s = s;
82+
Arrays.setAll(g, k -> new ArrayList<>());
83+
for (int i = 1; i < n; ++i) {
84+
g[parent[i]].add(i);
85+
}
86+
dfs(0);
87+
return ans + 1;
88+
}
89+
90+
private int dfs(int i) {
91+
int mx = 0;
92+
for (int j : g[i]) {
93+
int x = dfs(j) + 1;
94+
if (s.charAt(i) != s.charAt(j)) {
95+
ans = Math.max(ans, mx + x);
96+
mx = Math.max(mx, x);
97+
}
98+
}
99+
return mx;
100+
}
101+
}
102+
```
103+
104+
### **C++**
56105

106+
```cpp
107+
class Solution {
108+
public:
109+
int longestPath(vector<int>& parent, string s) {
110+
int n = parent.size();
111+
vector<int> g[n];
112+
for (int i = 1; i < n; ++i) {
113+
g[parent[i]].push_back(i);
114+
}
115+
int ans = 0;
116+
function<int(int)> dfs = [&](int i) -> int {
117+
int mx = 0;
118+
for (int j : g[i]) {
119+
int x = dfs(j) + 1;
120+
if (s[i] != s[j]) {
121+
ans = max(ans, mx + x);
122+
mx = max(mx, x);
123+
}
124+
}
125+
return mx;
126+
};
127+
dfs(0);
128+
return ans + 1;
129+
}
130+
};
131+
```
132+
133+
### **Go**
134+
135+
```go
136+
func longestPath(parent []int, s string) int {
137+
n := len(parent)
138+
g := make([][]int, n)
139+
for i := 1; i < n; i++ {
140+
g[parent[i]] = append(g[parent[i]], i)
141+
}
142+
ans := 0
143+
var dfs func(int) int
144+
dfs = func(i int) int {
145+
mx := 0
146+
for _, j := range g[i] {
147+
x := dfs(j) + 1
148+
if s[i] != s[j] {
149+
ans = max(ans, x+mx)
150+
mx = max(mx, x)
151+
}
152+
}
153+
return mx
154+
}
155+
dfs(0)
156+
return ans + 1
157+
}
158+
159+
func max(a, b int) int {
160+
if a > b {
161+
return a
162+
}
163+
return b
164+
}
57165
```
58166

59167
### **TypeScript**
60168

61169
```ts
170+
function longestPath(parent: number[], s: string): number {
62171
function longestPath(parent: number[], s: string): number {
63172
const n = parent.length;
64-
let graph = Array.from({ length: n }, v => []);
65-
for (let i = 1; i < n; i++) {
66-
graph[parent[i]].push(i);
173+
const g: number[][] = Array.from({ length: n }, () => []);
174+
for (let i = 1; i < n; ++i) {
175+
g[parent[i]].push(i);
67176
}
68177
let ans = 0;
69-
function dfs(x: number): number {
70-
let maxLen = 0;
71-
for (let y of graph[x]) {
72-
let len = dfs(y) + 1;
73-
if (s.charAt(x) !== s.charAt(y)) {
74-
ans = Math.max(maxLen + len, ans);
75-
maxLen = Math.max(len, maxLen);
178+
const dfs = (i: number): number => {
179+
let mx = 0;
180+
for (const j of g[i]) {
181+
const x = dfs(j) + 1;
182+
if (s[i] !== s[j]) {
183+
ans = Math.max(ans, mx + x);
184+
mx = Math.max(mx, x);
76185
}
77186
}
78-
return maxLen;
79-
}
187+
return mx;
188+
};
80189
dfs(0);
81190
return ans + 1;
82191
}

‎solution/2200-2299/2246.Longest Path With Different Adjacent Characters/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int longestPath(vector<int>& parent, string s) {
4+
int n = parent.size();
5+
vector<int> g[n];
6+
for (int i = 1; i < n; ++i) {
7+
g[parent[i]].push_back(i);
8+
}
9+
int ans = 0;
10+
function<int(int)> dfs = [&](int i) -> int {
11+
int mx = 0;
12+
for (int j : g[i]) {
13+
int x = dfs(j) + 1;
14+
if (s[i] != s[j]) {
15+
ans = max(ans, mx + x);
16+
mx = max(mx, x);
17+
}
18+
}
19+
return mx;
20+
};
21+
dfs(0);
22+
return ans + 1;
23+
}
24+
};

0 commit comments

Comments
 (0)