Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit cfdc03d

Browse files
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

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

Lines changed: 148 additions & 1 deletion
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
### **...**

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

Lines changed: 148 additions & 1 deletion
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
### **...**
Lines changed: 40 additions & 0 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /