请用python编程实现：初始化生成连连看图序列，确认可解，确认难度，广度优先搜索，消去算法以及提示算法，每一步的界面如何更新的重新开始，后悔步骤

由于这个问题比较复杂，我建议您参考以下代码：

import random
from collections import deque
import copy

# 初始化连连看图序列
def init_board(n):
    board = []
    for i in range(n):
        row = []
        for j in range(n):
            row.append(random.randint(1, 5))
        board.append(row)
    return board

# 判断连连看图是否可解
def is_solvable(board):
    n = len(board)
    visited = [[False] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if not visited[i][j]:
                if not dfs(board, visited, i, j, -1):
                    return False
    return True

# DFS搜索
def dfs(board, visited, i, j, last_val):
    n = len(board)
    if i < 0 or i >= n or j < 0 or j >= n:
        return False
    if visited[i][j]:
        return False
    if board[i][j] != last_val and last_val != -1:
        return False
    visited[i][j] = True
    if dfs(board, visited, i - 1, j, board[i][j]) or \
        dfs(board, visited, i + 1, j, board[i][j]) or \
        dfs(board, visited, i, j - 1, board[i][j]) or \
        dfs(board, visited, i, j + 1, board[i][j]):
        return True
    return False

# 确认难度
def get_difficulty(board):
    n = len(board)
    count = 0
    for i in range(n):
        for j in range(n):
            if board[i][j] != -1:
                count += 1
    return count

# 广度优先搜索
def bfs(board, i1, j1, i2, j2):
    n = len(board)
    q = deque()
    q.append((i1, j1, 0, []))
    visited = [[False] * n for _ in range(n)]
    visited[i1][j1] = True
    while q:
        i, j, dist, path = q.popleft()
        if i == i2 and j == j2:
            path.append((i, j))
            return path
        if i > 0 and not visited[i - 1][j] and board[i - 1][j] == 0:
            q.append((i - 1, j, dist + 1, path + [(i, j)]))
            visited[i - 1][j] = True
        if i < n - 1 and not visited[i + 1][j] and board[i + 1][j] == 0:
            q.append((i + 1, j, dist + 1, path + [(i, j)]))
            visited[i + 1][j] = True
        if j > 0 and not visited[i][j - 1] and board[i][j - 1] == 0:
            q.append((i, j - 1, dist + 1, path + [(i, j)]))
            visited[i][j - 1] = True
        if j < n - 1 and not visited[i][j + 1] and board[i][j + 1] == 0:
            q.append((i, j + 1, dist + 1, path + [(i, j)]))
            visited[i][j + 1] = True
    return []

# 消去算法
def eliminate(board, i1, j1, i2, j2):
    n = len(board)
    board[i1][j1] = 0
    board[i2][j2] = 0
    for i in range(n):
        for j in range(n):
            if board[i][j] == 0:
                continue
            if bfs(board, i, j, i1, j1) and bfs(board, i, j, i2, j2):
                board[i][j] = 0

# 提示算法
def get_hint(board):
    n = len(board)
    for i1 in range(n):
        for j1 in range(n):
            if board[i1][j1] == 0:
                continue
            for i2 in range(n):
                for j2 in range(n):
                    if board[i2][j2] == 0 or (i1 == i2 and j1 == j2):
                        continue
                    if board[i1][j1] == board[i2][j2]:
                        if bfs(board, i1, j1, i2, j2):
                            return (i1, j1, i2, j2)
    return None

# 更新界面
def update_board(board, i1, j1, i2, j2):
    board[i1][j1] = 0
    board[i2][j2] = 0

# 重新开始
def restart_board(board):
    n = len(board)
    for i in range(n):
        for j in range(n):
            board[i][j] = random.randint(1, 5)

# 后悔步骤
def undo(board, prev_board):
    n = len(board)
    for i in range(n):
        for j in range(n):
            board[i][j] = prev_board[i][j]

# 测试
board = init_board(6)
print(board)
print(is_solvable(board))
print(get_difficulty(board))

prev_board = copy.deepcopy(board)
eliminate(board, 0, 0, 0, 2)
print(board)

hint = get_hint(board)
print(hint)

update_board(board, hint[0], hint[1], hint[2], hint[3])
print(board)

undo(board, prev_board)
print(board)

restart_board(board)
print(board)