Skip to content

Commit cfdc03d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1377
No.1377.Frog Position After T Seconds
1 parent f93a912 commit cfdc03d

File tree

6 files changed

+433
-2
lines changed

6 files changed

+433
-2
lines changed

Diff for: ‎solution/1300-1399/1377.Frog Position After T Seconds/README.md

+148-1
Original file line numberDiff line numberDiff line change
@@ -60,22 +60,169 @@
6060

6161
<!-- 这里可写通用的实现逻辑 -->
6262

63+
**方法一：BFS**
64+
6365
<!-- tabs:start -->
6466

6567
### **Python3**
6668

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

6971
```python
70-
72+
class Solution:
73+
def frogPosition(self, n: int, edges: List[List[int]], t: int, target: int) -> float:
74+
g = defaultdict(list)
75+
for u, v in edges:
76+
g[u].append(v)
77+
g[v].append(u)
78+
q = deque([(1, 1.0)])
79+
vis = [False] * (n + 1)
80+
vis[1] = True
81+
while q and t >= 0:
82+
for _ in range(len(q)):
83+
u, p = q.popleft()
84+
nxt = [v for v in g[u] if not vis[v]]
85+
if u == target and (not nxt or t == 0):
86+
return p
87+
for v in nxt:
88+
vis[v] = True
89+
q.append((v, p / len(nxt)))
90+
t -= 1
91+
return 0
7192
```
7293

7394
### **Java**
7495

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

7798
```java
99+
class Solution {
100+
public double frogPosition(int n, int[][] edges, int t, int target) {
101+
List<Integer>[] g = new List[n + 1];
102+
for (int i = 0; i <= n; ++i) {
103+
g[i] = new ArrayList<>();
104+
}
105+
for (int[] e : edges) {
106+
int u = e[0], v = e[1];
107+
g[u].add(v);
108+
g[v].add(u);
109+
}
110+
Deque<Pair<Integer, Double>> q = new ArrayDeque<>();
111+
q.offer(new Pair<>(1, 1.0));
112+
boolean[] vis = new boolean[n + 1];
113+
vis[1] = true;
114+
while (!q.isEmpty() && t >= 0) {
115+
for (int k = q.size(); k > 0; --k) {
116+
Pair<Integer, Double> x = q.poll();
117+
int u = x.getKey();
118+
double p = x.getValue();
119+
List<Integer> nxt = new ArrayList<>();
120+
for (int v : g[u]) {
121+
if (!vis[v]) {
122+
nxt.add(v);
123+
vis[v] = true;
124+
}
125+
}
126+
if (u == target && (nxt.isEmpty() || t == 0)) {
127+
return p;
128+
}
129+
for (int v : nxt) {
130+
q.offer(new Pair<>(v, p / nxt.size()));
131+
}
132+
}
133+
--t;
134+
}
135+
return 0;
136+
}
137+
}
138+
```
139+
140+
### **C++**
141+
142+
```cpp
143+
class Solution {
144+
public:
145+
double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
146+
vector<vector<int>> g(n + 1);
147+
for (auto& e : edges)
148+
{
149+
int u = e[0], v = e[1];
150+
g[u].push_back(v);
151+
g[v].push_back(u);
152+
}
153+
typedef pair<int, double> pid;
154+
queue<pid> q;
155+
q.push({1, 1.0});
156+
vector<bool> vis(n + 1);
157+
vis[1] = true;
158+
while (!q.empty() && t >= 0)
159+
{
160+
for (int k = q.size(); k; --k)
161+
{
162+
auto x = q.front();
163+
q.pop();
164+
int u = x.first;
165+
double p = x.second;
166+
vector<int> nxt;
167+
for (int v : g[u])
168+
{
169+
if (!vis[v])
170+
{
171+
vis[v] = true;
172+
nxt.push_back(v);
173+
}
174+
}
175+
if (u == target && (t == 0 || nxt.empty())) return p;
176+
for (int v : nxt) q.push({v, p / nxt.size()});
177+
}
178+
--t;
179+
}
180+
return 0;
181+
}
182+
};
183+
```
78184
185+
### **Go**
186+
187+
```go
188+
type pid struct {
189+
x int
190+
p float64
191+
}
192+
193+
func frogPosition(n int, edges [][]int, t int, target int) float64 {
194+
g := make([][]int, n+1)
195+
for _, e := range edges {
196+
u, v := e[0], e[1]
197+
g[u] = append(g[u], v)
198+
g[v] = append(g[v], u)
199+
}
200+
q := []pid{pid{1, 1.0}}
201+
vis := make([]bool, n+1)
202+
vis[1] = true
203+
for len(q) > 0 && t >= 0 {
204+
for k := len(q); k > 0; k-- {
205+
x := q[0]
206+
q = q[1:]
207+
u, p := x.x, x.p
208+
var nxt []int
209+
for _, v := range g[u] {
210+
if !vis[v] {
211+
vis[v] = true
212+
nxt = append(nxt, v)
213+
}
214+
}
215+
if u == target && (len(nxt) == 0 || t == 0) {
216+
return p
217+
}
218+
for _, v := range nxt {
219+
q = append(q, pid{v, p / float64(len(nxt))})
220+
}
221+
}
222+
t--
223+
}
224+
return 0
225+
}
79226
```
80227

81228
### **...**

Diff for: ‎solution/1300-1399/1377.Frog Position After T Seconds/README_EN.md

+148-1
Original file line numberDiff line numberDiff line change
@@ -42,18 +42,165 @@
4242

4343
## Solutions
4444

45+
BFS.
46+
4547
<!-- tabs:start -->
4648

4749
### **Python3**
4850

4951
```python
50-
52+
class Solution:
53+
def frogPosition(self, n: int, edges: List[List[int]], t: int, target: int) -> float:
54+
g = defaultdict(list)
55+
for u, v in edges:
56+
g[u].append(v)
57+
g[v].append(u)
58+
q = deque([(1, 1.0)])
59+
vis = [False] * (n + 1)
60+
vis[1] = True
61+
while q and t >= 0:
62+
for _ in range(len(q)):
63+
u, p = q.popleft()
64+
nxt = [v for v in g[u] if not vis[v]]
65+
if u == target and (not nxt or t == 0):
66+
return p
67+
for v in nxt:
68+
vis[v] = True
69+
q.append((v, p / len(nxt)))
70+
t -= 1
71+
return 0
5172
```
5273

5374
### **Java**
5475

5576
```java
77+
class Solution {
78+
public double frogPosition(int n, int[][] edges, int t, int target) {
79+
List<Integer>[] g = new List[n + 1];
80+
for (int i = 0; i <= n; ++i) {
81+
g[i] = new ArrayList<>();
82+
}
83+
for (int[] e : edges) {
84+
int u = e[0], v = e[1];
85+
g[u].add(v);
86+
g[v].add(u);
87+
}
88+
Deque<Pair<Integer, Double>> q = new ArrayDeque<>();
89+
q.offer(new Pair<>(1, 1.0));
90+
boolean[] vis = new boolean[n + 1];
91+
vis[1] = true;
92+
while (!q.isEmpty() && t >= 0) {
93+
for (int k = q.size(); k > 0; --k) {
94+
Pair<Integer, Double> x = q.poll();
95+
int u = x.getKey();
96+
double p = x.getValue();
97+
List<Integer> nxt = new ArrayList<>();
98+
for (int v : g[u]) {
99+
if (!vis[v]) {
100+
nxt.add(v);
101+
vis[v] = true;
102+
}
103+
}
104+
if (u == target && (nxt.isEmpty() || t == 0)) {
105+
return p;
106+
}
107+
for (int v : nxt) {
108+
q.offer(new Pair<>(v, p / nxt.size()));
109+
}
110+
}
111+
--t;
112+
}
113+
return 0;
114+
}
115+
}
116+
```
117+
118+
### **C++**
119+
120+
```cpp
121+
class Solution {
122+
public:
123+
double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
124+
vector<vector<int>> g(n + 1);
125+
for (auto& e : edges)
126+
{
127+
int u = e[0], v = e[1];
128+
g[u].push_back(v);
129+
g[v].push_back(u);
130+
}
131+
typedef pair<int, double> pid;
132+
queue<pid> q;
133+
q.push({1, 1.0});
134+
vector<bool> vis(n + 1);
135+
vis[1] = true;
136+
while (!q.empty() && t >= 0)
137+
{
138+
for (int k = q.size(); k; --k)
139+
{
140+
auto x = q.front();
141+
q.pop();
142+
int u = x.first;
143+
double p = x.second;
144+
vector<int> nxt;
145+
for (int v : g[u])
146+
{
147+
if (!vis[v])
148+
{
149+
vis[v] = true;
150+
nxt.push_back(v);
151+
}
152+
}
153+
if (u == target && (t == 0 || nxt.empty())) return p;
154+
for (int v : nxt) q.push({v, p / nxt.size()});
155+
}
156+
--t;
157+
}
158+
return 0;
159+
}
160+
};
161+
```
56162
163+
### **Go**
164+
165+
```go
166+
type pid struct {
167+
x int
168+
p float64
169+
}
170+
171+
func frogPosition(n int, edges [][]int, t int, target int) float64 {
172+
g := make([][]int, n+1)
173+
for _, e := range edges {
174+
u, v := e[0], e[1]
175+
g[u] = append(g[u], v)
176+
g[v] = append(g[v], u)
177+
}
178+
q := []pid{pid{1, 1.0}}
179+
vis := make([]bool, n+1)
180+
vis[1] = true
181+
for len(q) > 0 && t >= 0 {
182+
for k := len(q); k > 0; k-- {
183+
x := q[0]
184+
q = q[1:]
185+
u, p := x.x, x.p
186+
var nxt []int
187+
for _, v := range g[u] {
188+
if !vis[v] {
189+
vis[v] = true
190+
nxt = append(nxt, v)
191+
}
192+
}
193+
if u == target && (len(nxt) == 0 || t == 0) {
194+
return p
195+
}
196+
for _, v := range nxt {
197+
q = append(q, pid{v, p / float64(len(nxt))})
198+
}
199+
}
200+
t--
201+
}
202+
return 0
203+
}
57204
```
58205

59206
### **...**

Diff for: ‎solution/1300-1399/1377.Frog Position After T Seconds/Solution.cpp

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
class Solution {
2+
public:
3+
double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
4+
vector<vector<int>> g(n + 1);
5+
for (auto& e : edges)
6+
{
7+
int u = e[0], v = e[1];
8+
g[u].push_back(v);
9+
g[v].push_back(u);
10+
}
11+
typedef pair<int, double> pid;
12+
queue<pid> q;
13+
q.push({1, 1.0});
14+
vector<bool> vis(n + 1);
15+
vis[1] = true;
16+
while (!q.empty() && t >= 0)
17+
{
18+
for (int k = q.size(); k; --k)
19+
{
20+
auto x = q.front();
21+
q.pop();
22+
int u = x.first;
23+
double p = x.second;
24+
vector<int> nxt;
25+
for (int v : g[u])
26+
{
27+
if (!vis[v])
28+
{
29+
vis[v] = true;
30+
nxt.push_back(v);
31+
}
32+
}
33+
if (u == target && (t == 0 || nxt.empty())) return p;
34+
for (int v : nxt) q.push({v, p / nxt.size()});
35+
}
36+
--t;
37+
}
38+
return 0;
39+
}
40+
};

0 commit comments

Comments
 (0)