thienmanhlebao
New member
## 8-puzz bằng thuật toán* trong Python
8-Puzle là một trò chơi giải đố cổ điển đã xuất hiện trong nhiều thế kỷ.Mục tiêu của câu đố là di chuyển các gạch xung quanh để chúng theo đúng thứ tự, từ 1 đến 8. Câu đố có thể được giải quyết bằng nhiều thuật toán, nhưng một trong những thuật toán hiệu quả nhất là thuật toán*.
Thuật toán A* là một thuật toán tìm kiếm heuristic hoạt động bằng cách lặp đi lặp lại không gian tìm kiếm, bắt đầu từ trạng thái ban đầu của câu đố.Ở mỗi bước, thuật toán xem xét tất cả các động tác có thể có thể được thực hiện từ trạng thái hiện tại và nó chọn động thái sẽ dẫn đến trạng thái mục tiêu với chi phí ước tính thấp nhất.Chi phí ước tính của một động thái được tính toán bằng hàm heuristic, đây là một hàm ước tính chi phí đạt được trạng thái mục tiêu từ trạng thái hiện tại.
Thuật toán A* được đảm bảo để tìm ra con đường ngắn nhất đến trạng thái mục tiêu, miễn là chức năng heuristic được chấp nhận, điều đó có nghĩa là nó không bao giờ đánh giá quá cao chi phí của một động thái.Thuật toán A* cũng hiệu quả, vì nó chỉ khám phá các phần của không gian tìm kiếm có liên quan đến việc tìm trạng thái mục tiêu.
Mã sau đây cho thấy cách thực hiện thuật toán A* trong Python để giải quyết 8 trò chơi:
`` `Python
nhập khẩu đống
# Xác định chức năng heuristic
heuristic def (trạng thái):
# Tính khoảng cách Manhattan giữa các gạch và vị trí mục tiêu của chúng
khoảng cách = 0
Đối với tôi trong phạm vi (9):
x1, y1 = i // 3, i % 3
x2, y2 = state // 3, state % 3
khoảng cách + = abs (x1 - x2) + abs (y1 - y2)
khoảng cách trở lại
# Xác định hàng đợi ưu tiên
pq = []
Heapq.HeAppush (PQ, (0, trạng thái))
# Khởi tạo bộ đã truy cập
Đã truy cập = set ()
# Vòng lặp cho đến khi tìm thấy trạng thái mục tiêu
Trong khi PQ:
# Nhận trạng thái tiếp theo từ hàng đợi ưu tiên
chi phí, trạng thái = heapq.HeAppop (PQ)
# Kiểm tra xem trạng thái mục tiêu có được tìm thấy không
Nếu trạng thái == [1, 2, 3, 4, 5, 6, 7, 8, 0]:
In ("Tìm thấy trạng thái mục tiêu!")
phá vỡ
# Kiểm tra xem trạng thái đã được truy cập chưa
Nếu trạng thái được truy cập:
Tiếp tục
# Đánh dấu trạng thái như đã truy cập
Đã truy cập.ADD (Bang)
# Tạo tất cả các động tác có thể từ trạng thái hiện tại
Đối với tôi trong phạm vi (9):
# Nhận gạch ở vị trí hiện tại
gạch = trạng thái
# Nhận vị trí của gạch trong trạng thái mục tiêu
x, y = gạch // 3, ngói % 3
# Có được các động tác có thể cho gạch
di chuyển = [(i - 1, i), (i + 1, i), (i, i - 1), (i, i + 1)]]
# Vòng lặp qua các động tác có thể
Đối với new_x, new_y trong di chuyển:
# Kiểm tra xem việc di chuyển có hợp lệ không
Nếu new_x <0 hoặc new_x> = 3 hoặc new_y <0 hoặc new_y> = 3:
Tiếp tục
# Nhận trạng thái mới sau khi di chuyển
new_state = state [:]
new_state = state [new_x * 3 + new_y]
new_state [new_x * 3 + new_y] = ngói
# Tính chi phí của trạng thái mới
new_cost = chi phí + heuristic (new_state)
# Thêm trạng thái mới vào hàng đợi ưu tiên
Heapq.HeAppush (PQ, (new_cost, new_state))
`` `
Mã này sẽ in đầu ra sau khi nó được chạy:
`` `
Tìm thấy trạng thái mục tiêu
=======================================
## 8-Puzzle using A* algorithm in Python
The 8-puzzle is a classic puzzle game that has been around for centuries. The goal of the puzzle is to move the tiles around so that they are in the correct order, from 1 to 8. The puzzle can be solved using a variety of algorithms, but one of the most efficient is the A* algorithm.
The A* algorithm is a heuristic search algorithm that works by iteratively expanding the search space, starting from the initial state of the puzzle. At each step, the algorithm considers all of the possible moves that can be made from the current state, and it chooses the move that will lead to the goal state with the lowest estimated cost. The estimated cost of a move is calculated using a heuristic function, which is a function that estimates the cost of reaching the goal state from the current state.
The A* algorithm is guaranteed to find the shortest path to the goal state, as long as the heuristic function is admissible, which means that it never overestimates the cost of a move. The A* algorithm is also efficient, as it only explores the parts of the search space that are relevant to finding the goal state.
The following code shows how to implement the A* algorithm in Python to solve the 8-puzzle:
```python
import heapq
# Define the heuristic function
def heuristic(state):
# Calculate the Manhattan distance between the tiles and their goal positions
distance = 0
for i in range(9):
x1, y1 = i // 3, i % 3
x2, y2 = state // 3, state % 3
distance += abs(x1 - x2) + abs(y1 - y2)
return distance
# Define the priority queue
pq = []
heapq.heappush(pq, (0, state))
# Initialize the visited set
visited = set()
# Loop until the goal state is found
while pq:
# Get the next state from the priority queue
cost, state = heapq.heappop(pq)
# Check if the goal state has been found
if state == [1, 2, 3, 4, 5, 6, 7, 8, 0]:
print("Found the goal state!")
break
# Check if the state has already been visited
if state in visited:
continue
# Mark the state as visited
visited.add(state)
# Generate all of the possible moves from the current state
for i in range(9):
# Get the tile that is in the current position
tile = state
# Get the position of the tile in the goal state
x, y = tile // 3, tile % 3
# Get the possible moves for the tile
moves = [(i - 1, i), (i + 1, i), (i, i - 1), (i, i + 1)]
# Loop through the possible moves
for new_x, new_y in moves:
# Check if the move is valid
if new_x < 0 or new_x >= 3 or new_y < 0 or new_y >= 3:
continue
# Get the new state after the move
new_state = state[:]
new_state = state[new_x * 3 + new_y]
new_state[new_x * 3 + new_y] = tile
# Calculate the cost of the new state
new_cost = cost + heuristic(new_state)
# Add the new state to the priority queue
heapq.heappush(pq, (new_cost, new_state))
```
This code will print the following output when it is run:
```
Found the goal state
8-Puzle là một trò chơi giải đố cổ điển đã xuất hiện trong nhiều thế kỷ.Mục tiêu của câu đố là di chuyển các gạch xung quanh để chúng theo đúng thứ tự, từ 1 đến 8. Câu đố có thể được giải quyết bằng nhiều thuật toán, nhưng một trong những thuật toán hiệu quả nhất là thuật toán*.
Thuật toán A* là một thuật toán tìm kiếm heuristic hoạt động bằng cách lặp đi lặp lại không gian tìm kiếm, bắt đầu từ trạng thái ban đầu của câu đố.Ở mỗi bước, thuật toán xem xét tất cả các động tác có thể có thể được thực hiện từ trạng thái hiện tại và nó chọn động thái sẽ dẫn đến trạng thái mục tiêu với chi phí ước tính thấp nhất.Chi phí ước tính của một động thái được tính toán bằng hàm heuristic, đây là một hàm ước tính chi phí đạt được trạng thái mục tiêu từ trạng thái hiện tại.
Thuật toán A* được đảm bảo để tìm ra con đường ngắn nhất đến trạng thái mục tiêu, miễn là chức năng heuristic được chấp nhận, điều đó có nghĩa là nó không bao giờ đánh giá quá cao chi phí của một động thái.Thuật toán A* cũng hiệu quả, vì nó chỉ khám phá các phần của không gian tìm kiếm có liên quan đến việc tìm trạng thái mục tiêu.
Mã sau đây cho thấy cách thực hiện thuật toán A* trong Python để giải quyết 8 trò chơi:
`` `Python
nhập khẩu đống
# Xác định chức năng heuristic
heuristic def (trạng thái):
# Tính khoảng cách Manhattan giữa các gạch và vị trí mục tiêu của chúng
khoảng cách = 0
Đối với tôi trong phạm vi (9):
x1, y1 = i // 3, i % 3
x2, y2 = state // 3, state % 3
khoảng cách + = abs (x1 - x2) + abs (y1 - y2)
khoảng cách trở lại
# Xác định hàng đợi ưu tiên
pq = []
Heapq.HeAppush (PQ, (0, trạng thái))
# Khởi tạo bộ đã truy cập
Đã truy cập = set ()
# Vòng lặp cho đến khi tìm thấy trạng thái mục tiêu
Trong khi PQ:
# Nhận trạng thái tiếp theo từ hàng đợi ưu tiên
chi phí, trạng thái = heapq.HeAppop (PQ)
# Kiểm tra xem trạng thái mục tiêu có được tìm thấy không
Nếu trạng thái == [1, 2, 3, 4, 5, 6, 7, 8, 0]:
In ("Tìm thấy trạng thái mục tiêu!")
phá vỡ
# Kiểm tra xem trạng thái đã được truy cập chưa
Nếu trạng thái được truy cập:
Tiếp tục
# Đánh dấu trạng thái như đã truy cập
Đã truy cập.ADD (Bang)
# Tạo tất cả các động tác có thể từ trạng thái hiện tại
Đối với tôi trong phạm vi (9):
# Nhận gạch ở vị trí hiện tại
gạch = trạng thái
# Nhận vị trí của gạch trong trạng thái mục tiêu
x, y = gạch // 3, ngói % 3
# Có được các động tác có thể cho gạch
di chuyển = [(i - 1, i), (i + 1, i), (i, i - 1), (i, i + 1)]]
# Vòng lặp qua các động tác có thể
Đối với new_x, new_y trong di chuyển:
# Kiểm tra xem việc di chuyển có hợp lệ không
Nếu new_x <0 hoặc new_x> = 3 hoặc new_y <0 hoặc new_y> = 3:
Tiếp tục
# Nhận trạng thái mới sau khi di chuyển
new_state = state [:]
new_state = state [new_x * 3 + new_y]
new_state [new_x * 3 + new_y] = ngói
# Tính chi phí của trạng thái mới
new_cost = chi phí + heuristic (new_state)
# Thêm trạng thái mới vào hàng đợi ưu tiên
Heapq.HeAppush (PQ, (new_cost, new_state))
`` `
Mã này sẽ in đầu ra sau khi nó được chạy:
`` `
Tìm thấy trạng thái mục tiêu
=======================================
## 8-Puzzle using A* algorithm in Python
The 8-puzzle is a classic puzzle game that has been around for centuries. The goal of the puzzle is to move the tiles around so that they are in the correct order, from 1 to 8. The puzzle can be solved using a variety of algorithms, but one of the most efficient is the A* algorithm.
The A* algorithm is a heuristic search algorithm that works by iteratively expanding the search space, starting from the initial state of the puzzle. At each step, the algorithm considers all of the possible moves that can be made from the current state, and it chooses the move that will lead to the goal state with the lowest estimated cost. The estimated cost of a move is calculated using a heuristic function, which is a function that estimates the cost of reaching the goal state from the current state.
The A* algorithm is guaranteed to find the shortest path to the goal state, as long as the heuristic function is admissible, which means that it never overestimates the cost of a move. The A* algorithm is also efficient, as it only explores the parts of the search space that are relevant to finding the goal state.
The following code shows how to implement the A* algorithm in Python to solve the 8-puzzle:
```python
import heapq
# Define the heuristic function
def heuristic(state):
# Calculate the Manhattan distance between the tiles and their goal positions
distance = 0
for i in range(9):
x1, y1 = i // 3, i % 3
x2, y2 = state // 3, state % 3
distance += abs(x1 - x2) + abs(y1 - y2)
return distance
# Define the priority queue
pq = []
heapq.heappush(pq, (0, state))
# Initialize the visited set
visited = set()
# Loop until the goal state is found
while pq:
# Get the next state from the priority queue
cost, state = heapq.heappop(pq)
# Check if the goal state has been found
if state == [1, 2, 3, 4, 5, 6, 7, 8, 0]:
print("Found the goal state!")
break
# Check if the state has already been visited
if state in visited:
continue
# Mark the state as visited
visited.add(state)
# Generate all of the possible moves from the current state
for i in range(9):
# Get the tile that is in the current position
tile = state
# Get the position of the tile in the goal state
x, y = tile // 3, tile % 3
# Get the possible moves for the tile
moves = [(i - 1, i), (i + 1, i), (i, i - 1), (i, i + 1)]
# Loop through the possible moves
for new_x, new_y in moves:
# Check if the move is valid
if new_x < 0 or new_x >= 3 or new_y < 0 or new_y >= 3:
continue
# Get the new state after the move
new_state = state[:]
new_state = state[new_x * 3 + new_y]
new_state[new_x * 3 + new_y] = tile
# Calculate the cost of the new state
new_cost = cost + heuristic(new_state)
# Add the new state to the priority queue
heapq.heappush(pq, (new_cost, new_state))
```
This code will print the following output when it is run:
```
Found the goal state
