Lua实现的八皇后问题

来自《Lua程序与设计》第二节- 八皇后问题


输出所有解的解法

书中提供的源代码,加注了自己的注释。

N = 8
--[[
 N为棋盘规模
 a为一维数组,保存第i个皇后所在的列数
]]

-- 检查是否可以将第n个皇后放在第n行第c列(前n-1行的皇后已经放好)
function isplaceok(a,n,c)
 -- 检查前n-1个皇后是否与(n,c)位置冲突
    for i = 1, n - 1, 1 do
        if a[i] == c or -- 是否同一列
           a[i] - i == c - n or --是否同一对角线 (?)
           a[i] + i == c + n then --是否同一对角线 (?)
            return false
        end
    end
    return true -- 不会被攻击 位置有效
end

-- 用于在找到解后打印棋盘
function printsolution(a)
    for i = 1, N do
        for j = 1, N do
            io.write(a[i] == j and "X" or "-", " ")
        end
        io.write("\n")
    end
    io.write("\n")
end

-- 已经找到前n-1皇后的位置
-- 存放于a中
-- 寻找第n个皇后可摆放的位置
function addqueen(a,n)
    if n > N then
        printsolution(a)
        return true
    else
-- 逐列检查能否摆放第n个皇后
        for c = 1, N do
            if isplaceok(a, n, c) then
                a[n] = c
                if addqueen(a, n+1) then
                    return true
                end
            end
        end
    end
end

-- 启动方式
addqueen({}, 1)

书后练习

1. 修改八皇后问题的程序,使其在输出第一个解后即停止运行。

修改addqueen函数即可。

-- 已经找到前n-1皇后的位置
-- 存放于a中
-- 寻找第n个皇后可摆放的位置
function addqueen(a,n)
    if n > N then
        printsolution(a)
        return true
    else
-- 逐列检查能否摆放第n个皇后
        for c = 1, N do
            if isplaceok(a, n, c) then
                a[n] = c
                if addqueen(a, n+1) then
                    return true
                end
            end
        end
    end
end
2. 解决八皇后问题的另一种方式是,先生成1-8之间的所有排列,然后依次遍历这些排列,检查每一个排列是否是八皇后问题的有效解。请使用这种方法修改程序并对比性能差异。

一定是原本的方法效率更高…1-8之间的所有排列一共有8的8次幂个,检查每个排列是否合法又是O(n^2)的复杂度,效率会很低。只看isplaceok函数调用次数的话,原来的方法一共调用isplaceok函数876次,生成所有排列的方法生成了8的8次幂个排列,每个排列调用isplaceok的次数最少1次,最多8次,整体也在5千万次以上。
实际测了一下,用的在线编辑器,直接爆掉了。又重新用本地的lua跑了一下。调用isplaceok的次数为50889536次。(妈呀)

N = 8
--[[
 N为棋盘规模
 a为一维数组,保存第i个皇后所在的列数
]]
count = 0
-- 检查是否可以将第n个皇后放在第n行第c列(前n-1行的皇后已经放好)
function isplaceok(a,n,c)
 count = count + 1
 -- 检查前n-1个皇后是否与(n,c)位置冲突
 for i = 1, n - 1, 1 do
  if a[i] == c or -- 是否同一列
   a[i] - i == c - n or --是否同一对角线 (?)
   a[i] + i == c + n then --是否同一对角线 (?)
   return false
  end
 end
 return true -- 不会被攻击 位置有效
end

-- 用于在找到解后打印棋盘
function printsolution(a)
 for i = 1, N do
  for j = 1, N do
   io.write(a[i] == j and "X" or "-", " ")
  end
  io.write("\n")
 end
 io.write("\n")
end

-- 已经放置前n-1皇后
-- 存放于a中
-- 放置第n个皇后
function addqueen(arrays, a, n)
 if n > N then
  table.insert(arrays, a)
 else
  -- 逐列检查能否摆放第n个皇后
  for c = 1, N do
   local b = {}
   for k, v in pairs(a) do
    b[k] = v
   end
   b[n] = c
   addqueen(arrays, b, n+1)
  end
 end
end

function getsolution()
 local posibles = {}
 addqueen(posibles, {}, 1)
 for _, v in pairs(posibles) do
  local ok = true
  for i = 1, N do
   ok = isplaceok(v, i, v[i])
   if not ok then
    break
   end
  end
  if ok then
   printsolution(v)
  end
 end
end

-- 启动方式
getsolution()
io.write("\n",count)

原文地址:https://www.cnblogs.com/zoey-liao/p/12271166.html

时间: 2024-11-02 21:39:51

Lua实现的八皇后问题的相关文章

【算法】用Lua解决八皇后的问题

最近在学习Lua脚本,经过了不到十天的学习,也算是对语法有所了解吧,另外正好也看到了八皇后问题,感觉挺有意思的 就试了试用算法解出来. 八皇后问题的原题是:八皇后问题是一个以国际象棋为背景的问题:如何能够在 8×8 的国际象棋棋盘上放置八个皇后,使得任何一个皇后都无法直接吃掉其他的皇后?为了达到此目的,任两个皇后都不能处于同一条横行.纵行或斜线上. 以下是lua的算法代码: local eightQueen = { 0,0,0,0,0,0,0,0,} local count = 0 functi

[OpenJudge] 百练2754 八皇后

八皇后 Description 会下国际象棋的人都很清楚:皇后可以在横.竖.斜线上不限步数地吃掉其他棋子.如何将8个皇后放在棋盘上(有8 * 8个方格),使它们谁也不能被吃掉!这就是著名的八皇后问题. 对于某个满足要求的8皇后的摆放方法,定义一个皇后串a与之对应,即a=b1b2...b8,其中bi为相应摆法中第i行皇后所处的列数.已经知道8皇后问题一共有92组解(即92个不同的皇后串).给出一个数b,要求输出第b个串.串的比较是这样的:皇后串x置于皇后串y之前,当且仅当将x视为整数时比y小. I

python解决八皇后问题

经典回溯算法:八皇后问题 算法要求: 在国际象棋棋盘上(8*8)放置八个皇后,使得任意两个皇后之间不能在同一行,同一列,也不能位于同于对角线上. 国际象棋的棋盘如下图所示: 问共有多少种不同的方法,并且指出各种不同的放法. # -*- coding:utf-8 -*- __author__ = "tyomcat" print("******八皇后问题的解决方法******") def next_col(current, n=8): length = len(curr

用遗传算法解八皇后问题

此算法收敛速度还可以,基本在1万代之内就能找到解 主程序 clear; clc; %% %八皇后问题,8X8的棋盘上,放置8个皇后,使之两两都不能攻击 %初始的状态,随机在棋盘上放置8个皇后,每列放一个 n = 8; %8皇后 %% %用遗传算法计算 %先随机获得几个个体,形成一个种群 %这个种群有10个个体 No_of_people = 10; people = randi(n,[No_of_people,n]); %计算每个初始种群的h值 people_h = ones(No_of_peop

回溯算法解八皇后问题(java版)

八皇后问题是学习回溯算法时不得不提的一个问题,用回溯算法解决该问题逻辑比较简单. 下面用java版的回溯算法来解决八皇后问题. 八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同一列或同一斜线上,问有多少种摆法. 思路是按行来规定皇后,第一行放第一个皇后,第二行放第二个,然后通过遍历所有列,来判断下一个皇后能否放在该列.直到所有皇后都放完,或者放哪

关于八皇后问题

八皇后问题主要是关于实现递归程序方面的知识. 问题描述: 会下象棋的人都知道:皇后可以在横竖,斜线上不限步数的吃掉其他棋子,如何将八个皇后放在棋盘上,使他们谁都不被吃掉,这就是著名的八皇后问题.对于某个满足要求的8皇后的摆放方法,定义一个皇后串a与之对应,即a=b1b2....b8,其中bi为相应摆法中第i行皇后所处的列数.已经知道8皇后问题有92组解.求出八皇后问题的所有解. 解题思路: 使用8*8矩阵作为模拟棋盘,以每一行为单位进行选择放置皇后,在放置皇后的同时将放置的皇后的控制范围画出,在

八皇后

八皇后(可以扩展为N皇后问题) 每行每列每个对角线都不允许有两个或两个以上的皇后 回溯,递归求解 #include<iostream>/// 八皇后 #include<cstdio> using namespace std; int c[10]; /// 第i行 列为a[i] int total; int n; /// 在一条主对角线上 则它们的 x-y相同 y=x+b /// 在一条负对角线上 则它们的 x+y相同 y=-x+b int v[3][100]; /// v[0]列

八皇后回溯递归 40行不到

个人感觉代码还算精简,比较容易混淆的一点是,board[] 数组,数组下表指的是八皇后棋盘的行,数组下标对应的值指的是八皇后棋盘的列,至于abs()可以去百度,是一个求绝对值的函数 #include <iostream> using namespace std ; #define N 8 static int sum = 0 ; const int max = N ; void print (int board []) { for(int i = 0 ;i < max ;i++) { c

【八皇后问题】 回溯算法

回溯算法:回溯算法实际上是一个类似枚举的搜索尝试方法,它的思想是在搜索尝试中寻找问题的解,当发现不满足求解条件时,就“回溯”返回,尝试别的路径.之前介绍的基础算法中的贪婪算法,动态规划等都具有“无后效性”,也就是在分段处理问题时,某状态一旦确定,将不再改变.而多数问题很难找到"无后效性”的阶段划分和相应决策,而是通过深入搜索尝试和回溯操作完成的. 八皇后问题:8*8的国际象棋棋盘中放八个皇后,是任意两个皇后不能互相吃掉.规则:皇后能吃掉同一行,同一列,同一对角线的任意棋子. 模型建立:不妨设八个