Skip to content

Commit feae4e7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0688
No.0688.Knight Probability in Chessboard
1 parent a5fc999 commit feae4e7

File tree

6 files changed

+283
-4
lines changed

6 files changed

+283
-4
lines changed

‎solution/0600-0699/0688.Knight Probability in Chessboard/README.md

+99-2
Original file line numberDiff line numberDiff line change
@@ -48,22 +48,59 @@
4848

4949
<!-- 这里可写通用的实现逻辑 -->
5050

51+
动态规划。`dp[l][i][j]` 表示骑士从 `(i, j)` 出发，走了 l 步后，仍留在棋盘上的概率。
52+
5153
<!-- tabs:start -->
5254

5355
### **Python3**
5456

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

5759
```python
58-
60+
class Solution:
61+
def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
62+
dp = [[[0] * n for _ in range(n)] for _ in range(k + 1)]
63+
for l in range(k + 1):
64+
for i in range(n):
65+
for j in range(n):
66+
if l == 0:
67+
dp[l][i][j] = 1
68+
else:
69+
for a, b in ((-2, -1), (-2, 1), (2, -1), (2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2)):
70+
x, y = i + a, j + b
71+
if 0 <= x < n and 0 <= y < n:
72+
dp[l][i][j] += dp[l - 1][x][y] / 8
73+
return dp[k][row][column]
5974
```
6075

6176
### **Java**
6277

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

6580
```java
66-
81+
class Solution {
82+
public double knightProbability(int n, int k, int row, int column) {
83+
double[][][] dp = new double[k + 1][n][n];
84+
int[] dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
85+
for (int l = 0; l <= k; ++l) {
86+
for (int i = 0; i < n; ++i) {
87+
for (int j = 0; j < n; ++j) {
88+
if (l == 0) {
89+
dp[l][i][j] = 1;
90+
} else {
91+
for (int d = 0; d < 8; ++d) {
92+
int x = i + dirs[d], y = j + dirs[d + 1];
93+
if (x >= 0 && x < n && y >= 0 && y < n) {
94+
dp[l][i][j] += dp[l - 1][x][y] / 8;
95+
}
96+
}
97+
}
98+
}
99+
}
100+
}
101+
return dp[k][row][column];
102+
}
103+
}
67104
```
68105

69106
### **TypeScript**
@@ -93,6 +130,66 @@ function knightProbability(n: number, k: number, row: number, column: number): n
93130
};
94131
```
95132

133+
### **C++**
134+
135+
```cpp
136+
class Solution {
137+
public:
138+
double knightProbability(int n, int k, int row, int column) {
139+
vector<vector<vector<double>>> dp(k + 1, vector<vector<double>>(n, vector<double>(n)));
140+
vector<int> dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
141+
for (int l = 0; l <= k; ++l)
142+
{
143+
for (int i = 0; i < n; ++i)
144+
{
145+
for (int j = 0; j < n; ++j)
146+
{
147+
if (l == 0) dp[l][i][j] = 1;
148+
else
149+
{
150+
for (int d = 0; d < 8; ++d)
151+
{
152+
int x = i + dirs[d], y = j + dirs[d + 1];
153+
if (x >= 0 && x < n && y >= 0 && y < n)
154+
dp[l][i][j] += dp[l - 1][x][y] / 8;
155+
}
156+
}
157+
}
158+
}
159+
}
160+
return dp[k][row][column];
161+
}
162+
};
163+
```
164+
165+
### **Go**
166+
167+
```go
168+
func knightProbability(n int, k int, row int, column int) float64 {
169+
dp := make([][][]float64, k+1)
170+
dirs := []int{-2, -1, 2, 1, -2, 1, 2, -1, -2}
171+
for l := range dp {
172+
dp[l] = make([][]float64, n)
173+
for i := 0; i < n; i++ {
174+
dp[l][i] = make([]float64, n)
175+
for j := 0; j < n; j++ {
176+
if l == 0 {
177+
dp[l][i][j] = 1
178+
} else {
179+
for d := 0; d < 8; d++ {
180+
x, y := i+dirs[d], j+dirs[d+1]
181+
if 0 <= x && x < n && 0 <= y && y < n {
182+
dp[l][i][j] += dp[l-1][x][y] / 8
183+
}
184+
}
185+
}
186+
}
187+
}
188+
}
189+
return dp[k][row][column]
190+
}
191+
```
192+
96193
### **...**
97194

98195
```

‎solution/0600-0699/0688.Knight Probability in Chessboard/README_EN.md

+97-2
Original file line numberDiff line numberDiff line change
@@ -53,13 +53,48 @@ The total probability the knight stays on the board is 0.0625.
5353
### **Python3**
5454

5555
```python
56-
56+
class Solution:
57+
def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
58+
dp = [[[0] * n for _ in range(n)] for _ in range(k + 1)]
59+
for l in range(k + 1):
60+
for i in range(n):
61+
for j in range(n):
62+
if l == 0:
63+
dp[l][i][j] = 1
64+
else:
65+
for a, b in ((-2, -1), (-2, 1), (2, -1), (2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2)):
66+
x, y = i + a, j + b
67+
if 0 <= x < n and 0 <= y < n:
68+
dp[l][i][j] += dp[l - 1][x][y] / 8
69+
return dp[k][row][column]
5770
```
5871

5972
### **Java**
6073

6174
```java
62-
75+
class Solution {
76+
public double knightProbability(int n, int k, int row, int column) {
77+
double[][][] dp = new double[k + 1][n][n];
78+
int[] dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
79+
for (int l = 0; l <= k; ++l) {
80+
for (int i = 0; i < n; ++i) {
81+
for (int j = 0; j < n; ++j) {
82+
if (l == 0) {
83+
dp[l][i][j] = 1;
84+
} else {
85+
for (int d = 0; d < 8; ++d) {
86+
int x = i + dirs[d], y = j + dirs[d + 1];
87+
if (x >= 0 && x < n && y >= 0 && y < n) {
88+
dp[l][i][j] += dp[l - 1][x][y] / 8;
89+
}
90+
}
91+
}
92+
}
93+
}
94+
}
95+
return dp[k][row][column];
96+
}
97+
}
6398
```
6499

65100
### **TypeScript**
@@ -89,6 +124,66 @@ function knightProbability(n: number, k: number, row: number, column: number): n
89124
};
90125
```
91126

127+
### **C++**
128+
129+
```cpp
130+
class Solution {
131+
public:
132+
double knightProbability(int n, int k, int row, int column) {
133+
vector<vector<vector<double>>> dp(k + 1, vector<vector<double>>(n, vector<double>(n)));
134+
vector<int> dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
135+
for (int l = 0; l <= k; ++l)
136+
{
137+
for (int i = 0; i < n; ++i)
138+
{
139+
for (int j = 0; j < n; ++j)
140+
{
141+
if (l == 0) dp[l][i][j] = 1;
142+
else
143+
{
144+
for (int d = 0; d < 8; ++d)
145+
{
146+
int x = i + dirs[d], y = j + dirs[d + 1];
147+
if (x >= 0 && x < n && y >= 0 && y < n)
148+
dp[l][i][j] += dp[l - 1][x][y] / 8;
149+
}
150+
}
151+
}
152+
}
153+
}
154+
return dp[k][row][column];
155+
}
156+
};
157+
```
158+
159+
### **Go**
160+
161+
```go
162+
func knightProbability(n int, k int, row int, column int) float64 {
163+
dp := make([][][]float64, k+1)
164+
dirs := []int{-2, -1, 2, 1, -2, 1, 2, -1, -2}
165+
for l := range dp {
166+
dp[l] = make([][]float64, n)
167+
for i := 0; i < n; i++ {
168+
dp[l][i] = make([]float64, n)
169+
for j := 0; j < n; j++ {
170+
if l == 0 {
171+
dp[l][i][j] = 1
172+
} else {
173+
for d := 0; d < 8; d++ {
174+
x, y := i+dirs[d], j+dirs[d+1]
175+
if 0 <= x && x < n && 0 <= y && y < n {
176+
dp[l][i][j] += dp[l-1][x][y] / 8
177+
}
178+
}
179+
}
180+
}
181+
}
182+
}
183+
return dp[k][row][column]
184+
}
185+
```
186+
92187
### **...**
93188

94189
```

‎solution/0600-0699/0688.Knight Probability in Chessboard/Solution.cpp

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
class Solution {
2+
public:
3+
double knightProbability(int n, int k, int row, int column) {
4+
vector<vector<vector<double>>> dp(k + 1, vector<vector<double>>(n, vector<double>(n)));
5+
vector<int> dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
6+
for (int l = 0; l <= k; ++l)
7+
{
8+
for (int i = 0; i < n; ++i)
9+
{
10+
for (int j = 0; j < n; ++j)
11+
{
12+
if (l == 0) dp[l][i][j] = 1;
13+
else
14+
{
15+
for (int d = 0; d < 8; ++d)
16+
{
17+
int x = i + dirs[d], y = j + dirs[d + 1];
18+
if (x >= 0 && x < n && y >= 0 && y < n)
19+
dp[l][i][j] += dp[l - 1][x][y] / 8;
20+
}
21+
}
22+
}
23+
}
24+
}
25+
return dp[k][row][column];
26+
}
27+
};

‎solution/0600-0699/0688.Knight Probability in Chessboard/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
func knightProbability(n int, k int, row int, column int) float64 {
2+
dp := make([][][]float64, k+1)
3+
dirs := []int{-2, -1, 2, 1, -2, 1, 2, -1, -2}
4+
for l := range dp {
5+
dp[l] = make([][]float64, n)
6+
for i := 0; i < n; i++ {
7+
dp[l][i] = make([]float64, n)
8+
for j := 0; j < n; j++ {
9+
if l == 0 {
10+
dp[l][i][j] = 1
11+
} else {
12+
for d := 0; d < 8; d++ {
13+
x, y := i+dirs[d], j+dirs[d+1]
14+
if 0 <= x && x < n && 0 <= y && y < n {
15+
dp[l][i][j] += dp[l-1][x][y] / 8
16+
}
17+
}
18+
}
19+
}
20+
}
21+
}
22+
return dp[k][row][column]
23+
}

‎solution/0600-0699/0688.Knight Probability in Chessboard/Solution.java

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public double knightProbability(int n, int k, int row, int column) {
3+
double[][][] dp = new double[k + 1][n][n];
4+
int[] dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
5+
for (int l = 0; l <= k; ++l) {
6+
for (int i = 0; i < n; ++i) {
7+
for (int j = 0; j < n; ++j) {
8+
if (l == 0) {
9+
dp[l][i][j] = 1;
10+
} else {
11+
for (int d = 0; d < 8; ++d) {
12+
int x = i + dirs[d], y = j + dirs[d + 1];
13+
if (x >= 0 && x < n && y >= 0 && y < n) {
14+
dp[l][i][j] += dp[l - 1][x][y] / 8;
15+
}
16+
}
17+
}
18+
}
19+
}
20+
}
21+
return dp[k][row][column];
22+
}
23+
}

‎solution/0600-0699/0688.Knight Probability in Chessboard/Solution.py

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def knightProbability(self, n: int, k: int, row: int, column: int) -> float:
3+
dp = [[[0] * n for _ in range(n)] for _ in range(k + 1)]
4+
for l in range(k + 1):
5+
for i in range(n):
6+
for j in range(n):
7+
if l == 0:
8+
dp[l][i][j] = 1
9+
else:
10+
for a, b in ((-2, -1), (-2, 1), (2, -1), (2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2)):
11+
x, y = i + a, j + b
12+
if 0 <= x < n and 0 <= y < n:
13+
dp[l][i][j] += dp[l - 1][x][y] / 8
14+
return dp[k][row][column]

0 commit comments

Comments
 (0)