给出八皇后问题的描述，以及给出所有解的棋盘可视化展示，可以翻页看解 基于kotlin语言和compose框架 给出代码

已于 2025-03-10 14:19:58 修改
阅读量772 收藏 15
点赞数 10
CC 4.0 BY-SA版权
文章标签： 算法 kotlin
于 2025-03-10 11:04:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/AnalogElectronic/article/details/146147876

我会基于Kotlin和Jetpack Compose框架，结合回溯算法实现八皇后问题的可视化解决方案。以下是分步骤实现：

一、八皇后问题描述
在国际象棋8x8的棋盘上放置8个皇后，要求任意两个皇后不能处于同一行、同一列或同一对角线上。该问题共有92种有效解法。

二、完整代码实现

// 解决方案数据类
data class QueenSolution(val positions: List<Pair<Int, Int>>)
 
// 主界面 
@Composable 
fun EightQueensScreen() {
    val solutions = remember { generateSolutions() }
    var currentPage by remember { mutableIntStateOf(0) }
    
    Column(
        modifier = Modifier.fillMaxSize(), 
        horizontalAlignment = Alignment.CenterHorizontally 
    ) {
        // 棋盘可视化 
        ChessBoard(solution = solutions.getOrNull(currentPage)) 
        
        // 翻页控制 
        Row(verticalAlignment = Alignment.CenterVertically) {
            Button(
                onClick = { currentPage = (currentPage - 1 + solutions.size)  % solutions.size  },
                modifier = Modifier.padding(8.dp) 
            ) { Text("Previous") }
            
            Text("Solution ${currentPage + 1}/${solutions.size}") 
            
            Button(
                onClick { currentPage = (currentPage + 1) % solutions.size  },
                Modifier.padding(8.dp) 
            ) { Text("Next") }
        }
    }
}
 
// 生成所有解的算法 
private fun generateSolutions(): List<QueenSolution> {
    val solutions = mutableListOf<QueenSolution>()
    val cols = IntArray(8)
    
    fun isSafe(row: Int, col: Int): Boolean {
        for (i in 0 until row) {
            if (cols[i] == col || 
                abs(cols[i] - col) == row - i) return false 
        }
        return true 
    }
    
    fun backtrack(row: Int) {
        if (row == 8) {
            solutions.add(QueenSolution((0  until 8).map { it to cols[it] }))
            return 
        }
        for (col in 0 until 8) {
            if (isSafe(row, col)) {
                cols[row] = col 
                backtrack(row + 1)
            }
        }
    }
    
    backtrack(0)
    return solutions 
}
 
// 棋盘可视化组件 
@Composable 
private fun ChessBoard(solution: QueenSolution?) {
    val cellSize = 40.dp 
    
    LazyVerticalGrid(
        columns = GridCells.Fixed(8),
        modifier = Modifier 
            .size(cellSize * 8)
            .padding(16.dp) 
    ) {
        items(64) { index ->
            val row = index / 8 
            val col = index % 8 
            val hasQueen = solution?.positions?.any { it.first  == row && it.second  == col } == true 
            
            Box(
                modifier = Modifier 
                    .size(cellSize)
                    .background(
                        color = if ((row + col) % 2 == 0) Color.LightGray else Color.DarkGray 
                    )
                    .border(1.dp,  Color.Black)
            ) {
                if (hasQueen) {
                    Text("♛", 
                        modifier = Modifier.align(Alignment.Center), 
                        fontSize = 24.sp, 
                        color = Color.Red 
                    )
                }
            }
        }
    }
}

三、功能特性说明
算法核心
使用回溯算法生成所有92种有效解
通过isSafe函数检测列冲突和对角线冲突
递归实现深度优先搜索
可视化实现
棋盘使用LazyVerticalGrid实现8x8网格
交替颜色显示棋盘格（深浅交替）
红色皇后符号标识位置
交互功能
翻页按钮查看不同解法
显示当前解法的序号（1/92 ~ 92/92）
自动循环翻页（到达末尾后回到第一个解）
四、运行效果
八皇后问题可视化示例
（示意图：交替颜色的棋盘，红色皇后符号位于非冲突位置）

五、扩展建议
添加动画效果：使用AnimatedVisibility实现棋盘切换过渡动画
增加冲突检测提示：高亮显示被攻击的格子
支持N皇后扩展：将固定值8改为变量参数
完整项目源码可参考优快云相关实现，此代码基于Jetpack Compose最新稳定版本编写，兼容Android 5.0+设备。

八皇后问题描述

八皇后问题是一个经典的回溯算法问题，在 8x8 的国际象棋棋盘上放置 8 个皇后，使得它们互不攻击。具体要求如下：

  • 任何两个皇后都不能在同一行
  • 任何两个皇后都不能在同一列
  • 任何两个皇后都不能在同一对角线

目标是找到所有满足条件的皇后布局方案。

Kotlin Compose 实现八皇后问题可视化（含翻页功能）

下面是一个优化后的 Kotlin Compose 实现，能够展示所有解，并支持翻页查看不同解：

import androidx.compose.animation.animateContentSize
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material.icons.filled.ArrowForward
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

@Composable
fun EightQueensVisualizer() {
    var boardSize by remember { mutableStateOf(8) }
    var isSolving by remember { mutableStateOf(false) }
    var solutionIndex by remember { mutableStateOf(0) }
    val solutions = remember { mutableStateListOf<List<Int>>() }
    val currentBoard = remember { mutableStateListOf<Int?>() }
    var showDescription by remember { mutableStateOf(true) }

    val coroutineScope = CoroutineScope(Dispatchers.Default)

    MaterialTheme {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(16.dp)
        ) {
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween,
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(text = "八皇后问题可视化", style = MaterialTheme.typography.titleLarge)
                Button(
                    onClick = {
                        if (!isSolving) {
                            currentBoard.clear()
                            solutions.clear()
                            solutionIndex = 0
                            coroutineScope.launch {
                                solveEightQueens(boardSize, solutions)
                            }
                            isSolving = true
                        }
                    },
                    enabled = !isSolving
                ) {
                    Text(text = "开始求解")
                }
            }

            Spacer(modifier = Modifier.height(16.dp))

            if (showDescription) {
                Card(
                    modifier = Modifier
                        .fillMaxWidth()
                        .animateContentSize(),
                    elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
                ) {
                    Column(
                        modifier = Modifier.padding(1.dp6),
                        verticalArrangement = Arrangement.spacedBy(8.dp)
                    ) {
                        Text(
                            text = "八皇后问题描述:",
                            style = MaterialTheme.typography.titleMedium
                        )
                        Text(
                            text = "在 8x8 的国际象棋棋盘上放置 8 个皇后，使得它们互不攻击。具体要求如下:"
                        )
                        Text(
                            text = "- 任何两个皇后都不能在同一行"
                        )
                        Text(
                            text = "- 任何两个皇后都不能在同一列"
                        )
                        Text(
                            text = "- 任何两个皇后都不能在同一对角线"
                        )
                        Spacer(modifier = Modifier.height(8.dp))
                        Text(
                            text = "目标是找到所有满足条件的皇后布局方案。共有 ${solutions.size} 种解法。",
                            style = MaterialTheme.typography.bodyMedium
                        )
                        Spacer(modifier = Modifier.height(16.dp))
                        Button(
                            onClick = { showDescription = false },
                            modifier = Modifier.align(Alignment.End)
                        ) {
                            Text(text = "开始查看解法")
                        }
                    }
                }
            } else {
                Column(
                    modifier = Modifier.fillMaxWidth(),
                    verticalArrangement = Arrangement.spacedBy(8.dp)
                ) {
                    Row(
                        modifier = Modifier.fillMaxWidth(),
                        horizontalArrangement = Arrangement.SpaceBetween
                    ) {
                        Column {
                            Text(text = "棋盘大小:")
                            Text(text = "$boardSize x $boardSize")
                        }

                        Column {
                            Text(text = "解的数量:")
                            Text(text = solutions.size.toString())
                        }

                        Column {
                            Text(text = "当前解:")
                            Text(text = "${solutionIndex + 1}/${solutions.size}")
                        }
                    }

                    Spacer(modifier = Modifier.height(16.dp))

                    Box(
                        modifier = Modifier
                            .fillMaxWidth()
                            .aspectRatio(1f)
                            .border(2.dp, Color.Black)
                    ) {
                        // 绘制棋盘
                        for (row in 0 until boardSize) {
                            for (col in 0 until boardSize) {
                                val isLightSquare = (row + col) % 2 == 0
                                Box(
                                    modifier = Modifier
                                        .size(
                                            with(LocalDensity.current) {
                                                (this@Box.size.toDpSize().width / boardSize).toPx()
                                            }.dp
                                        )
                                        .offset(
                                            x = with(LocalDensity.current) {
                                                (col * (this@Box.size.toDpSize().width / boardSize).px).dp
                                            },
                                            y = with(LocalDensity.current) {
                                                (row * (this@Box.size.toDpSize().height / boardSize).px).dp
                                            }
                                        )
                                        .background(
                                            color = if (isLightSquare) Color(0xFFf0d9b5) else Color(0xFFb58863)
                                        )
                                )
                            }
                        }

                        // 绘制皇后
                        currentBoard.forEachIndexed { rowIndex, col ->
                            col?.let {
                                val queenSize = with(LocalDensity.current) {
                                    (this@Box.size.toDpSize().width / boardSize * 0.7).toPx()
                                }.dp
                                Box(
                                    modifier = Modifier
                                        .size(queenSize)
                                        .offset(
                                            x = with(LocalDensity.current) {
                                                (col * (this@Box.size.toDpSize().width / boardSize).px + (this@Box.size.toDpSize().width / boardSize * 0.15).px).dp
                                            },
                                            y = with(LocalDensity.current) {
                                                (rowIndex * (this@Box.size.toDpSize().height / boardSize).px + (@thisBox.size.toDpSize().height / boardSize * 0.15).px).dp
                                            }
                                        )
                                        .clip(CircleShape)
                                        .background(Color.Black)
                                )
                            }
                        }
                    }

                    Spacer(modifier = Modifier.height(16.dp))

                    Row(
                        modifier = Modifier.fillMaxWidth(),
                        horizontalArrangement = Arrangement.Center,
                        verticalAlignment = Alignment.CenterVertically
                    ) {
                        Button(
                            onClick = {
                                if (solutionIndex > 0) {
                                    solutionIndex--
                                    updateCurrentBoard(solutions, currentBoard, solutionIndex)
                                }
                            },
                            enabled = solutionIndex > 0
                        ) {
                            Icon(
                                imageVector = Icons.Filled.ArrowBack,
                                contentDescription = "上一个解"
                            )
                            Text(text = "上一个解")
                        }

                        Spacer(modifier = Modifier.width(16.dp))

                        Button(
                            onClick = {
                                if (solutionIndex < solutions.size - 1) {
                                    solutionIndex++
                                    updateCurrentBoard(solutions, currentBoard, solutionIndex)
                                }
                            },
                            enabled = solutionIndex < solutions.size - 1
                        ) {
                            Text(text = "下一个解")
                            Icon(
                                imageVector = Icons.Filled.ArrowForward,
                                contentDescription = "下一个解"
                            )
                        }
                    }
                }
            }
        }
    }
}

private fun updateCurrentBoard(
    solutions: List<List<Int>>,
    currentBoard: MutableList<Int?>,
    solutionIndex: Int
) {
    currentBoard.clear()
    if (solutionIndex >= 0 && solutionIndex < solutions.size) {
        currentBoard.addAll(solutions[solutionIndex].map { it })
    }
}

private fun solveEightQueens(n: Int, solutions: MutableList<List<Int>>) {
    val board = Array(n) { -1 }
    backtrack(0, n, board, solutions)
}

private fun backtrack(row: Int, n: Int, board: Array<Int>, solutions: MutableList<List<Int>>) {
    if (row == n) {
        solutions.add(board.toList())
        return
    }

    for (col in 0 until n) {
        if (isValid(board, row, col)) {
            board[row] = col
            backtrack(row + 1, n, board, solutions)
            board[row] = -1
        }
    }
}

private fun isValid(board: Array<Int>, row: Int, col: Int): Boolean {
    for (i in 0 until row) {
        if (board[i] == col || Math.abs(board[i] - col) == Math.abs(i - row)) {
            return false
        }
    }
    return true
}

@Composable
fun rememberBoardState(initialSize: Int = 8): MutableState<Int> {
    return remember { mutableStateOf(initialSize) }
}

fun main() {
    // 在实际项目中，您需要使用 Compose 的桌面应用模板来运行此代码
}

功能说明

  1. 问题描述:

    • 程序启动时会显示八皇后问题的详细描述
    • 点击 “开始查看解法” 按钮进入解法查看模式

  2. 解法展示:

    • 显示当前棋盘大小、解的总数和当前解的索引
    • 棋盘以可视化形式展示，皇后用黑色圆形表示
    • 使用翻页按钮可以在不同解之间切换

  3. 交互功能:

    • 点击 “开始求解” 按钮计算所有解
    • 使用 “上一个解” 和 “下一个解” 按钮浏览不同解

使用方法

  1. 创建一个新的 Kotlin Compose 项目
  2. 将上述代码复制到主文件中
  3. 运行应用程序
  4. 阅读问题描述后点击 “开始查看解法”
  5. 点击 “开始求解” 按钮计算解
  6. 使用翻页按钮查看不同解

这个实现提供了完整的八皇后问题描述和可视化解法展示，并支持翻页查看所有解。

// 新增：带求解步骤的数据结构 
data class SolveStep(
    val row: Int,
    val col: Int,
    val result: String, // "尝试"、"成功"、"冲突"
    val conflictType: String = "" // 冲突类型说明 
)
 
// 修改生成解法的函数 
private fun generateSolutions(): Pair<List<QueenSolution>, List<List<SolveStep>>> {
    val solutions = mutableListOf<QueenSolution>()
    val stepsLog = mutableListOf<List<SolveStep>>()
    val cols = IntArray(8)
    var currentSteps = mutableListOf<SolveStep>()
 
    fun logStep(row: Int, col: Int, result: String, conflict: String = "") {
        currentSteps.add(SolveStep(row,  col, result, conflict))
        // 实时打印到控制台（实际开发可替换为Logcat）
        println("行$row 列$col: $result ${if(conflict.isNotEmpty())  "原因:$conflict" else ""}")
    }
 
    fun backtrack(row: Int) {
        if (row == 8) {
            solutions.add(QueenSolution((0  until 8).map { it to cols[it] }))
            stepsLog.add(currentSteps.toList()) 
            currentSteps.clear() 
            return 
        }
        
        for (col in 0 until 8) {
            logStep(row, col, "尝试")
            var safe = true 
            var conflict = ""
            
            // 冲突检测 
            for (i in 0 until row) {
                when {
                    cols[i] == col -> {
                        conflict = "列冲突"
                        safe = false 
                    }
                    row - i == abs(cols[i] - col) -> {
                        conflict = "对角线冲突"
                        safe = false 
                    }
                }
                if (!safe) break 
            }
            
            if (safe) {
                cols[row] = col 
                logStep(row, col, "成功")
                backtrack(row + 1)
            } else {
                logStep(row, col, "冲突", conflict)
            }
        }
    }
    
    backtrack(0)
    return solutions to stepsLog 
}
 
// 新增解法菜单界面 
@Composable 
fun SolutionMenu(
    solutions: List<QueenSolution>,
    stepsLog: List<List<SolveStep>>,
    onSelect: (Int) -> Unit 
) {
    LazyColumn {
        itemsIndexed(solutions) { index, _ ->
            Button(
                onClick = { onSelect(index) },
                modifier = Modifier.fillMaxWidth() 
            ) {
                Text("解法 ${index + 1} - 共${stepsLog[index].size}步")
            }
        }
    }
}
 
// 修改主界面 
@Composable 
fun EightQueensScreen() {
    var showMenu by remember { mutableStateOf(false) }
    val (solutions, stepsLog) = remember { generateSolutions() }
    var currentPage by remember { mutableIntStateOf(0) }
 
    if (showMenu) {
        SolutionMenu(solutions, stepsLog) { index ->
            currentPage = index 
            showMenu = false 
        }
    } else {
        Column(Modifier.fillMaxSize())  {
            ChessBoardWithLogs(
                solution = solutions[currentPage],
                steps = stepsLog[currentPage]
            )
            
            Row {
                Button({ showMenu = true }) {
                    Text("解法菜单 (${solutions.size} 种)")
                }
                // 保留原有翻页按钮...
            }
        }
    }
}
 
// 新增带日志显示的棋盘 
@Composable 
fun ChessBoardWithLogs(solution: QueenSolution, steps: List<SolveStep>) {
    Column {
        // 棋盘组件（沿用历史代码）
        ChessBoard(solution)
        
        // 分步日志显示 
        LazyColumn(Modifier.height(200.dp))  {
            itemsIndexed(steps) { i, step ->
                Text(
                    text = when(step.result)  {
                        "尝试" -> "尝试在(${step.row},${step.col}) 放置"
                        "成功" -> "√ 成功放置于(${step.row},${step.col})" 
                        else -> "× 冲突在(${step.row},${step.col}):  ${step.conflictType}" 
                    },
                    color = when(step.result)  {
                        "成功" -> Color.Green 
                        "冲突" -> Color.Red 
                        else -> Color.Gray 
                    }
                )
            }
        }
    }
}

主要优化点说明：3 5 7

分步日志系统
实时记录每个位置的尝试结果（成功/冲突）
冲突类型细化显示（列冲突/对角线冲突）
使用不同颜色区分状态（成功绿色、冲突红色、尝试灰色）
导航系统增强
新增解法菜单显示所有解法的步数统计
保留原有翻页按钮的同时增加菜单跳转
支持直接查看任一解法的详细步骤
可视化增强
棋盘与步骤日志同屏显示
日志区域支持滚动查看完整过程
保留原有棋盘颜色交替方案和皇后标识
性能优化
使用记忆化存储解决日志
分离解法生成和界面渲染
懒加载日志列表保证滚动性能
使用建议：

在ChessBoard组件中添加动画效果（如AnimatedVisibility）3
对于复杂日志可添加过滤功能（只显示成功步骤等）
使用WindowInsets适配不同屏幕尺寸
重要冲突步骤可添加音效反馈
此版本完整保留了原有回溯算法的高效性（时间复杂度O(N!)），同时通过分步日志实现了算法过程的透明化展示，适合用于教学演示或算法调试场景。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值