Skip to content

Commit c2787a0

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1857
No.1857.Largest Color Value in a Directed Graph
1 parent 0959504 commit c2787a0

File tree

6 files changed

+531
-2
lines changed

6 files changed

+531
-2
lines changed

‎solution/1800-1899/1857.Largest Color Value in a Directed Graph/README.md

+184-1
Original file line numberDiff line numberDiff line change
@@ -51,22 +51,205 @@
5151

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

54+
**方法一：拓扑排序 + 动态规划**
55+
56+
求出每个点的入度，进行拓扑排序。每个点维护一个长度为 $26$ 的数组，记录每个字母从任意起点到当前点的出现次数。
57+
58+
时间复杂度 $O(n+m)$，空间复杂度 $O(n+m)$。
59+
5460
<!-- tabs:start -->
5561

5662
### **Python3**
5763

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

6066
```python
61-
67+
class Solution:
68+
def largestPathValue(self, colors: str, edges: List[List[int]]) -> int:
69+
n = len(colors)
70+
indeg = [0] * n
71+
g = defaultdict(list)
72+
for a, b in edges:
73+
g[a].append(b)
74+
indeg[b] += 1
75+
q = deque()
76+
dp = [[0] * 26 for _ in range(n)]
77+
for i, v in enumerate(indeg):
78+
if v == 0:
79+
q.append(i)
80+
c = ord(colors[i]) - ord('a')
81+
dp[i][c] += 1
82+
cnt = 0
83+
ans = 1
84+
while q:
85+
i = q.popleft()
86+
cnt += 1
87+
for j in g[i]:
88+
indeg[j] -= 1
89+
if indeg[j] == 0:
90+
q.append(j)
91+
c = ord(colors[j]) - ord('a')
92+
for k in range(26):
93+
dp[j][k] = max(dp[j][k], dp[i][k] + (c == k))
94+
ans = max(ans, dp[j][k])
95+
return -1 if cnt < n else ans
6296
```
6397

6498
### **Java**
6599

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

68102
```java
103+
class Solution {
104+
public int largestPathValue(String colors, int[][] edges) {
105+
int n = colors.length();
106+
List<Integer>[] g = new List[n];
107+
for (int i = 0; i < n; ++i) {
108+
g[i] = new ArrayList<>();
109+
}
110+
int[] indeg = new int[n];
111+
for (int[] e : edges) {
112+
int a = e[0], b = e[1];
113+
g[a].add(b);
114+
++indeg[b];
115+
}
116+
Deque<Integer> q = new ArrayDeque<>();
117+
int[][] dp = new int[n][26];
118+
for (int i = 0; i < n; ++i) {
119+
if (indeg[i] == 0) {
120+
q.offer(i);
121+
int c = colors.charAt(i) - 'a';
122+
++dp[i][c];
123+
}
124+
}
125+
int cnt = 0;
126+
int ans = 1;
127+
while (!q.isEmpty()) {
128+
int i = q.pollFirst();
129+
++cnt;
130+
for (int j : g[i]) {
131+
if (--indeg[j] == 0) {
132+
q.offer(j);
133+
}
134+
int c = colors.charAt(j) - 'a';
135+
for (int k = 0; k < 26; ++k) {
136+
dp[j][k] = Math.max(dp[j][k], dp[i][k] + (c == k ? 1 : 0));
137+
ans = Math.max(ans, dp[j][k]);
138+
}
139+
}
140+
}
141+
return cnt == n ? ans : -1;
142+
}
143+
}
144+
```
145+
146+
### **C++**
147+
148+
```cpp
149+
class Solution {
150+
public:
151+
int largestPathValue(string colors, vector<vector<int>>& edges) {
152+
int n = colors.size();
153+
vector<vector<int>> g(n);
154+
vector<int> indeg(n);
155+
for (auto& e : edges)
156+
{
157+
int a = e[0], b = e[1];
158+
g[a].push_back(b);
159+
++indeg[b];
160+
}
161+
queue<int> q;
162+
vector<vector<int>> dp(n, vector<int>(26));
163+
for (int i = 0; i < n; ++i)
164+
{
165+
if (indeg[i] == 0)
166+
{
167+
q.push(i);
168+
int c = colors[i] - 'a';
169+
dp[i][c]++;
170+
}
171+
}
172+
int cnt = 0;
173+
int ans = 1;
174+
while (!q.empty())
175+
{
176+
int i = q.front();
177+
q.pop();
178+
++cnt;
179+
for (int j : g[i])
180+
{
181+
if (--indeg[j] == 0) q.push(j);
182+
int c = colors[j] - 'a';
183+
for (int k = 0; k < 26; ++k)
184+
{
185+
dp[j][k] = max(dp[j][k], dp[i][k] + (c == k));
186+
ans = max(ans, dp[j][k]);
187+
}
188+
}
189+
}
190+
return cnt == n ? ans : -1;
191+
}
192+
};
193+
```
69194
195+
### **Go**
196+
197+
```go
198+
func largestPathValue(colors string, edges [][]int) int {
199+
n := len(colors)
200+
g := make([][]int, n)
201+
indeg := make([]int, n)
202+
for _, e := range edges {
203+
a, b := e[0], e[1]
204+
g[a] = append(g[a], b)
205+
indeg[b]++
206+
}
207+
q := []int{}
208+
dp := make([][]int, n)
209+
for i := range dp {
210+
dp[i] = make([]int, 26)
211+
}
212+
for i, v := range indeg {
213+
if v == 0 {
214+
q = append(q, i)
215+
c := colors[i] - 'a'
216+
dp[i][c]++
217+
}
218+
}
219+
cnt := 0
220+
ans := 1
221+
for len(q) > 0 {
222+
i := q[0]
223+
q = q[1:]
224+
cnt++
225+
for _, j := range g[i] {
226+
indeg[j]--
227+
if indeg[j] == 0 {
228+
q = append(q, j)
229+
}
230+
c := int(colors[j] - 'a')
231+
for k := 0; k < 26; k++ {
232+
t := 0
233+
if c == k {
234+
t = 1
235+
}
236+
dp[j][k] = max(dp[j][k], dp[i][k]+t)
237+
ans = max(ans, dp[j][k])
238+
}
239+
}
240+
}
241+
if cnt == n {
242+
return ans
243+
}
244+
return -1
245+
}
246+
247+
func max(a, b int) int {
248+
if a > b {
249+
return a
250+
}
251+
return b
252+
}
70253
```
71254

72255
### **...**

‎solution/1800-1899/1857.Largest Color Value in a Directed Graph/README_EN.md

+178-1
Original file line numberDiff line numberDiff line change
@@ -62,13 +62,190 @@
6262
### **Python3**
6363

6464
```python
65-
65+
class Solution:
66+
def largestPathValue(self, colors: str, edges: List[List[int]]) -> int:
67+
n = len(colors)
68+
indeg = [0] * n
69+
g = defaultdict(list)
70+
for a, b in edges:
71+
g[a].append(b)
72+
indeg[b] += 1
73+
q = deque()
74+
dp = [[0] * 26 for _ in range(n)]
75+
for i, v in enumerate(indeg):
76+
if v == 0:
77+
q.append(i)
78+
c = ord(colors[i]) - ord('a')
79+
dp[i][c] += 1
80+
cnt = 0
81+
ans = 1
82+
while q:
83+
i = q.popleft()
84+
cnt += 1
85+
for j in g[i]:
86+
indeg[j] -= 1
87+
if indeg[j] == 0:
88+
q.append(j)
89+
c = ord(colors[j]) - ord('a')
90+
for k in range(26):
91+
dp[j][k] = max(dp[j][k], dp[i][k] + (c == k))
92+
ans = max(ans, dp[j][k])
93+
return -1 if cnt < n else ans
6694
```
6795

6896
### **Java**
6997

7098
```java
99+
class Solution {
100+
public int largestPathValue(String colors, int[][] edges) {
101+
int n = colors.length();
102+
List<Integer>[] g = new List[n];
103+
for (int i = 0; i < n; ++i) {
104+
g[i] = new ArrayList<>();
105+
}
106+
int[] indeg = new int[n];
107+
for (int[] e : edges) {
108+
int a = e[0], b = e[1];
109+
g[a].add(b);
110+
++indeg[b];
111+
}
112+
Deque<Integer> q = new ArrayDeque<>();
113+
int[][] dp = new int[n][26];
114+
for (int i = 0; i < n; ++i) {
115+
if (indeg[i] == 0) {
116+
q.offer(i);
117+
int c = colors.charAt(i) - 'a';
118+
++dp[i][c];
119+
}
120+
}
121+
int cnt = 0;
122+
int ans = 1;
123+
while (!q.isEmpty()) {
124+
int i = q.pollFirst();
125+
++cnt;
126+
for (int j : g[i]) {
127+
if (--indeg[j] == 0) {
128+
q.offer(j);
129+
}
130+
int c = colors.charAt(j) - 'a';
131+
for (int k = 0; k < 26; ++k) {
132+
dp[j][k] = Math.max(dp[j][k], dp[i][k] + (c == k ? 1 : 0));
133+
ans = Math.max(ans, dp[j][k]);
134+
}
135+
}
136+
}
137+
return cnt == n ? ans : -1;
138+
}
139+
}
140+
```
141+
142+
### **C++**
143+
144+
```cpp
145+
class Solution {
146+
public:
147+
int largestPathValue(string colors, vector<vector<int>>& edges) {
148+
int n = colors.size();
149+
vector<vector<int>> g(n);
150+
vector<int> indeg(n);
151+
for (auto& e : edges)
152+
{
153+
int a = e[0], b = e[1];
154+
g[a].push_back(b);
155+
++indeg[b];
156+
}
157+
queue<int> q;
158+
vector<vector<int>> dp(n, vector<int>(26));
159+
for (int i = 0; i < n; ++i)
160+
{
161+
if (indeg[i] == 0)
162+
{
163+
q.push(i);
164+
int c = colors[i] - 'a';
165+
dp[i][c]++;
166+
}
167+
}
168+
int cnt = 0;
169+
int ans = 1;
170+
while (!q.empty())
171+
{
172+
int i = q.front();
173+
q.pop();
174+
++cnt;
175+
for (int j : g[i])
176+
{
177+
if (--indeg[j] == 0) q.push(j);
178+
int c = colors[j] - 'a';
179+
for (int k = 0; k < 26; ++k)
180+
{
181+
dp[j][k] = max(dp[j][k], dp[i][k] + (c == k));
182+
ans = max(ans, dp[j][k]);
183+
}
184+
}
185+
}
186+
return cnt == n ? ans : -1;
187+
}
188+
};
189+
```
71190
191+
### **Go**
192+
193+
```go
194+
func largestPathValue(colors string, edges [][]int) int {
195+
n := len(colors)
196+
g := make([][]int, n)
197+
indeg := make([]int, n)
198+
for _, e := range edges {
199+
a, b := e[0], e[1]
200+
g[a] = append(g[a], b)
201+
indeg[b]++
202+
}
203+
q := []int{}
204+
dp := make([][]int, n)
205+
for i := range dp {
206+
dp[i] = make([]int, 26)
207+
}
208+
for i, v := range indeg {
209+
if v == 0 {
210+
q = append(q, i)
211+
c := colors[i] - 'a'
212+
dp[i][c]++
213+
}
214+
}
215+
cnt := 0
216+
ans := 1
217+
for len(q) > 0 {
218+
i := q[0]
219+
q = q[1:]
220+
cnt++
221+
for _, j := range g[i] {
222+
indeg[j]--
223+
if indeg[j] == 0 {
224+
q = append(q, j)
225+
}
226+
c := int(colors[j] - 'a')
227+
for k := 0; k < 26; k++ {
228+
t := 0
229+
if c == k {
230+
t = 1
231+
}
232+
dp[j][k] = max(dp[j][k], dp[i][k]+t)
233+
ans = max(ans, dp[j][k])
234+
}
235+
}
236+
}
237+
if cnt == n {
238+
return ans
239+
}
240+
return -1
241+
}
242+
243+
func max(a, b int) int {
244+
if a > b {
245+
return a
246+
}
247+
return b
248+
}
72249
```
73250

74251
### **...**

0 commit comments

Comments
 (0)