黑白子交换c语言思路,递归 算法思路和优化和简单实现: 黑白子交换
題目和原解法
原文用py和循環15步完成, 其實這個比較簡單, 沒啥可玩的, 重點在于思路
狀態由三個, 不能使用位運算, 但是可以使用十進制的每個位
首先用數組表示實屬有點浪費, 哪怕是字符串呢, 不過數組確實操作方便, 這個題目的搜索難度也不大所以用啥都行, 最好是封裝位運算或者字符串, 這樣判斷是否阻塞也方便
對于每一次搜索, 所有可以進行的操作就是一步, 然后深搜即可, 每進一步執行操作更新狀態, 每撤銷一步恢復狀態, 由于狀態就是數字, 不會有引用問題
由于每次操作數目有限, 目測應該是指數級
本來不想寫的... 不過實在沒啥事干就用js實現下吧...
深搜簡單實現下, 每加阻塞判斷和優化, 跑出來的結果也是15, 一共只有兩個解... 原文中給的是第二個解
[
[
2223133, 2213233, 2123233,
2321233, 2323213, 2323231,
2323132, 2313232, 1323232,
3123232, 3321232, 3323212,
3323122, 3313222, 3331222
],
[
2212333, 2232133, 2232313,
2231323, 2132323, 1232323,
3212323, 3232123, 3232321,
3232312, 3231322, 3132322,
3312322, 3332122, 3331222
]
]
const white = 2
const blank = 1
const black = 3
const moveType = {
left: 0, // 左移
leftJump: 1, // 左跳
right: 2, // 右移
rightJump: 3, // 右跳
}
// 由低位到高位 1:空格,2:白,3:黑
const show = n => {
console.log(
toList(n)
.reverse()
.join("-"),
)
}
const toList = n =>
Array(7)
.fill(0)
.map((_, i) => ((n / 10 ** i) | 0) % 10)
/*
2 2 2 1 3 3 3
index 0 1 2 3 4 5 6
value 3 3 3 1 2 2 2
*/
initState = 2221333
show(initState) // 2-2-2-1-3-3-3
// 是否滿足終止條件
const check = n => {
return n === 3331222
}
const showStop = n => {
return false
}
const get = (n, index) => ((n / 10 ** index) | 0) % 10
const set = (n, index, value) =>
n - get(n, index) * 10 ** index + value * 10 ** index
const exchange = (n, from, to) => {
const fv = get(n, from)
const tv = get(n, to)
return set(set(n, from, tv), to, fv)
}
const doMove = (n, { type, index }) => {
if (type === moveType.left) {
return exchange(n, index, index + 1)
} else if (type === moveType.leftJump) {
return exchange(n, index, index + 2)
} else if (type === moveType.right) {
return exchange(n, index, index - 1)
} else if (type === moveType.rightJump) {
return exchange(n, index, index - 2)
}
}
const indexArray = Array(7)
.fill(0)
.map((_, k) => k)
// 獲取可操作的集合
const getOpList = n => {
// 空格所在位置
const blankIndex = indexArray.find(i => get(n, i) === blank)
console.log("blankIndex", blankIndex)
const list = []
for (let i = 0; i < 7; i++) {
if (i === blankIndex) continue
if (get(n, i) === black) {
if (i + 1 < 7 && i + 1 === blankIndex) {
// 黑左移
list.push({
type: moveType.left,
index: i,
})
} else if (i + 2 < 7 && get(n, i + 1) === white && i + 2 === blankIndex) {
// 黑左跳
list.push({
type: moveType.leftJump,
index: i,
})
}
} else {
if (i >= 1 && i - 1 === blankIndex) {
// 白右移
list.push({
type: moveType.right,
index: i,
})
} else if (i >= 2 && get(n, i - 1) === black && i - 2 === blankIndex) {
// 白右跳
list.push({
type: moveType.rightJump,
index: i,
})
}
}
}
return list
}
// 是否存在阻塞
const shouldStop = () => {}
const answer = []
const dfs = (n, path = []) => {
console.log("dfs", n, path.length)
if (check(n)) {
console.log(path.length, path)
answer.push([...path])
return true
}
if (shouldStop(n)) {
// 存在阻塞
return false
}
const list = getOpList(n)
// 獲取所有可以執行的操作
for (const op of list) {
// 進行操作
console.log(op)
path.push(doMove(n, op))
const res = dfs(doMove(n, op), path)
path.pop()
if (res) {
// return true
}
}
return false
}
dfs(initState)
console.log(answer)
總結
以上是生活随笔為你收集整理的黑白子交换c语言思路,递归 算法思路和优化和简单实现: 黑白子交换的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 只读字符串的c语言命令,C语言只读空间
- 下一篇： android网络拦截,拦截所有app的