递归之N皇后问题

递归---n皇后问题 【问题描述】 在nxn的方格棋盘上放置n个皇后,要求每个皇后不同行、不同列、不同左右对角线。 【问题求解】 采用整数数组q[N]存放n皇后问题的求解结果,因为每行只能放一个皇后,q[i](1<=i<=n)的值表示第i个皇后所在的列号,即该皇后放在(i,q[i])的位置上。 对于(i,j)位置上的皇后,是否与已放好的皇后(k,q[k])(1<=k<=i-1)有冲突,有以下判断条件。 若同列则有q[k]==j; 2.不同左右对角线则冲突则满足(abs(q[k])-i)= =abs(. 阅读详情
问题描述:

N皇后问题是指在N*N的棋盘上要摆N个皇后,
要求:任何两个皇后不同行,不同列也不再同一条斜线上,
求给一个整数N
,返回N皇后的摆法数。

N皇后问题涉及到回溯的思想。我们通常用递归解决,代码实现会比较简单。递归其实可以看作底层帮我们维护了一个自动push、pop的堆栈。网上也有很多N皇后的相关题解,这篇文章经过我的整理,保证你能看懂。

理解DFS的关键在于解决“当下该如何做”。至于“下一步如何做”则与当下是一样的。

因此,我们在递归的时候,只要关心第一步应该如何开始,以及最后一步何时结束,就能够写出DFS的基本模型。

初步认识DFS

为了方便无基础的读者阅读,顺带写上用DFS求1~n全排列的解法。

如果想直接看N皇后问题,可直接跳转

算法分析:

这里我们可以将全排列模拟成对n个纸条标上数字,所以需要一个长度为n的数组a[n],再用一个数组book记录数字是否已经被使用。当某纸条标上数字i后,则book[i]=1。由于求全排列还需要取出数字重新组合,要重新赋值为0。

第一步:

我们关注的问题是:如何找出一种排列方式?

void dfs(int k)
{
    if (k > n) //n个字条都被标记了
    {
        return; //找完第一种,结束尝试
    }
    for (int i = 1; i <= n; i++) //遍历1~n数字,为纸条标记数字
    {
        if (!book[i]) //如果数字未使用
        {
            a[k] = i; //标上i
            book[i] = 1;
        }
    }
}
第二步:

我们将第一步的处理方法递推到后面的每一步。很容易想到,我们在一个函数中实现第一步,然后通过递归调用这个函数实现解决思路相同的下一步,直到应有的处理方案都试完,就可以结束。这就是DFS。

完整代码
#include <bits/stdc++.h>
using namespace std;
const int n = 3;
int a[n], book[n + 1];
void dfs(int k)
{
    if (k > n) //n个字条都被标记了
    {
        for (int i = 1; i <= n; i++)
            printf("%d", a[i]);
        printf("\n");
        return; //结束第一次尝试
    }
    for (int i = 1; i <= n; i++) //遍历1~n数字,为纸条标记数字
    {
        if (!book[i]) //如果数字未使用
        {
            a[k] = i; //标上i
            book[i] = 1;
            dfs(k + 1); //函数的递归调用(自己调用自己),继续标记第k+1纸条,直到n张纸条都标记完
            book[i] = 0;
            /**
             * 这里之所以要置0,是因为在进入这个代码时,
             * dfs一次调用完成,已经能得到了第一组排列方式
             * 接下来会往前回退求新的排列方式
             * 必须收回原有的标记才能继续做新的尝试
             **/
        }
    }
}

int main()
{
    dfs(1); //k表示现在要标记的是纸条k,从第一个开始
}

N皇后问题

下面我们依照上面的思路解决N皇后问题。首先给出DFS的基本模型,实现过程中会稍作调整。

start:
初始化数组
dfs(k){ 放置第k个皇后
    if(判断边界){ 合法则开始尝试
        for(i=1;i<=n;i++){ 
        	尝试每一种可能
    		dfs(k+1)   继续下一种尝试
    		回溯,恢复状态 		
    	}
    }
    else{ 放置位置超出棋盘
        完成第一次递归,求解数+1
        返回
    }
}
end

算法分析:
普通DFS:

我们需要一个二维数组当作棋盘。

首先:如何放置第一种摆法?

核心思路是:对走过的每一行,判断当前列的位置是否可放置,然后遍历每一列,就得到第一种摆法。

然后从第一行开始试,尝试n次。这就是N皇后的DFS解法。

要判断当前位置的列和对角线是否能放置棋子,

就要对走过的每一行都检查。因此,我们需要这样一个函数

bool check(int row, int col)
{
    /**由于要判断当前位置的列和对角线是否能放置
     * 就要对走过的每一行都检查 **/

    for (int i = 1; i <= row; i++)
    {
        if (g[i][col]) //对每一行检查当前列
            return false;
    }
    for (int i = row - 1, j = col - 1; i > 0 && j > 0; i--, j--)
    {
        if (g[i][j]) //检查左上斜线
            return false;
    }
    for (int i = row - 1, j = col + 1; i > 0 && j <= n; i--, j++)
    {
        if (g[i][j]) //检查右上斜线
            return false;
    }
    return true;
}

纯DFS完整代码为

#include <bits/stdc++.h>
using namespace std;
const int n = 8;
int ans = 0;
int g[n + 1][n + 1];
bool check(int row, int col)
{
    /**由于要判断当前位置的列和对角线是否能放置
     * 就要对走过的每一行都检查 **/

    for (int i = 1; i <= row; i++)
    {
        if (g[i][col]) //对每一行检查当前列
            return false;
    }
    for (int i = row - 1, j = col - 1; i > 0 && j > 0; i--, j--)
    {
        if (g[i][j]) //检查左上斜线
            return false;
    }
    for (int i = row - 1, j = col + 1; i > 0 && j <= n; i--, j++)
    {
        if (g[i][j]) //检查右上斜线
            return false;
    }
    return true;
}
void dfs(int k) //k表示第k行
{
    if (k > n)
    {
        ans++;
        return;
    }
    for (int col = 1; col <= n; col++)
    { //遍历k行的每一列
        if (check(k, col)) //如果该位置可放置
        {
            g[k][col] = 1;
            dfs(k + 1);
            g[k][col] = 0;
        }
    }
}

int main()
{

    dfs(1);
    cout << ans;
}

时间复杂度O(N!),空间复杂度(N^2),下面我们将开始优化。由于我这里只介绍N皇后的递归解法,下面提供的解法主要是在思路上有所改进。

重述一遍思路:对走过的每一行,判断当前列的位置是否可放置,然后遍历每一列,就得到第一种摆法。

由于在N皇后规则中,同行同列且同一斜线仅存在1个皇后,那我们能否不用二维数组模拟棋盘呢?

优化1.0:

其实,我们可以用一维数组分别表示列和对角线上的棋子状态,通过直线斜率判断两个棋子是否在同一斜线上。

由于在这个棋盘中,放置棋子处于同一斜线上的斜率k仅可取1和-1。我们以图上A(x1,y1)和B(x2,y2)两点为例
由直线方程两点式:

x−x1x2−x1\frac{x-x1}{x2-x1}x2−x1x−x1​=y−y1y2−y1\frac{y-y1}{y2-y1}y2−y1y−y1​

化简一般式:y = y2−y1x2−x1\frac{y2-y1}{x2-x1}x2−x1y2−y1​*(x-x1) ,其中,k= y2−y1x2−x1\frac{y2-y1}{x2-x1}x2−x1y2−y1​ 。显然,当且仅当∣y2−y1∣| y2-y1 |∣y2−y1∣=∣x2−x1∣|x2-x1|∣x2−x1∣时,两个棋子位于同一斜线上。在对遍历每列时,当前行就是y2,当前列就是x2。

首先,我们将列的值存入以行为下标的数组里,就可以同时表达行与列的关系。核心代码为:

 for (int x2 = 1; x2 <= n; x2++) //对当前行的每列遍历
    {
        g[y2] = x2;
     	if(check(y2))dfs(...)   //列的值已经存在g[]里面,找到当前行能够放置的x2
    }

注意:g[]不再表示位置是否已放置,而是表示y2行在哪一列放置了皇后。

这样,我们压缩了棋盘数组的空间。只要对每列遍历,找到当前行能够放置的x2就可以了。

然后加上判断位置是否可放置皇后的函数,就能完成啦。

完整代码如下:

#include <bits/stdc++.h>
using namespace std;
const int n = 8;
int ans = 0;
int g[n + 1]; 
//注意:g[]不再表示某位置是否已放置,而是表示某行在哪一列放置了皇后,简单的说就是下标为行y,值为x的数组
bool check(int y2)
{
    for (int y1 = 1; y1 < y2; y1++)
    {
        if (g[y2] == g[y1] || y2 - y1 == abs(g[y2] - g[y1])) //y2-y1==|x2-x1| (y1<y2)
        /**
         * 1. 检查走过的行中有无同一列放置的皇后
           2. 检查走过的行中有无同一斜线放置的皇后(通过斜率判断)
        */
           return false;
    }
    return true;
}
void dfs(int y2) //y2表示纵坐标为y2,即y2行
{
    if (y2 > n)
    {
        ans++;
        return;
    }
    for (int x2 = 1; x2 <= n; x2++) //对每列遍历,找到当前能够放置的x2
    {
        g[y2] = x2;
        if (check(y2))
        {
            dfs(y2 + 1); //由于一直在对列遍历,无需一次dfs调用完成后恢复数组
        }
    }
}

int main()
{

    dfs(1);
    cout << ans;
}
优化1.1:

我们可以发现,只要知道行和列,对应的斜线位置也知道了。

于是,对前k行的每一列遍历时,只要判断该位置列和主对角线、副对角线能否放置就可以了。

主对角线
副对角线

由上图(转自leetcode),我们将得出两个结论:

  1. 主对角线上,每个位置满足行下标与列下标之差相等
  2. 副对角线上,每个位置满足行下标与列下标之和相等

那么现在,我们y也可以用3个一维数组去维护棋盘的状态。它们分别表示列和主、副对角线。

这就是N皇后问题的常规DFS解法,我们的判断条件可以改为:

 if (!(col[y] || line1[k + y] || line2[n-(k-y)])) //如果该位置可放置

只需要对每列遍历一次,就可以判断该位置是否可放。

注意:由于对主对角线判断时会出现下标之差为负数,又因为对称性,同一棋盘会有两条主对角线行下标与列下标之差的绝对值相等。因此,这里判断的下标应该为n-(k-y) (有点像使数组下标溢出并作不进位处理)

核心代码如下:

void dfs(int k) //k表示第k行
{
    if (k > n)
    {
        ans++;
        return;
    }
    for (int y = 1; y <= n; y++)
    {                                                     
        if (!(col[y] || line1[k + y] || line2[n - (k-y)])) 
        {
            col[y] = line1[k + y] = line2[n - (k-y)] = 1;
            dfs(k + 1);
            col[y] = line1[k + y] = line2[n - (k-y)] = 0;
        }
    }
}
优化2:

完整代码如下

return [1,0,0,2,10,4,40,92,352,724,2680,14200,73712,365596][n-1]

再见(逃

算法典型例题:N皇后问题,五种解法,逐步优化(递归版) 本文将介绍N皇后问题的五种解法,包括朴素回溯法、对称优化、标记优化、可用优化、位运算优化,对于每种解题思路,提供相应的递归版代码实现。 阅读详情

相关推荐

N皇后问题的递归与非递归解法

题目  N皇后问题 n皇后问题是将n个皇后放置在n*n的棋盘上,皇后彼此之间不能相互攻击。 给定一个整数n,返回所有不同的n皇后问题的解决方案。 每个解决方案包含一个明确的n皇后放置布局,其中“Q”和“.”分别表示一个女王和一个空位置。 样例 对于4皇后问题存在两种解决的方案: [     [".Q..", // Soluti

指尖飞舞 8207

【数据结构】N皇后(递归经典算法)

一、N皇后 1、题目 将n个皇后摆放在N*N的棋盘中,互相不可攻击,有多少种摆放方式,每种摆放方式具体是怎样的? 2、解题思路 解题思路: 1、将棋盘放在一个二维数组中,同时设置方向数组: static const int dx[] = {-1,1,0,0,-1,-1,1,1,}; static const int dy[] = {-1,0,-1,...

dai_wen的博客 1万+

回溯法求n皇后问题(递归、非递归及优化)

n皇后问题是一个以国际象棋为背景的问题:在n×n的国际象棋棋盘上放置n个皇后,使得任何一个皇后都无法直接吃掉其他的皇后,即任意两个皇后都不能处于同一条横行、纵行或斜线上。 蛮力法思想:     解决n皇后问题的思想本质上就是蛮力法,生成所有可能的摆放情况,并判断该情况是否满足要求,我们以树结构来表示解决问题的方法。以4*4的棋盘为例,第0层的根节点为空白的棋盘,第1层为只在棋盘的第一行摆放的四

chenxianqin2的博客 1万+

递归算法——n皇后

** 递归算法——n皇后 ** n皇后问题: 输入整数n,要求n个国际象棋的皇后,摆在n*n的棋盘上,互相不能攻击,输出全部方案。 输入: 输入一个正整数N。 输出: 程序输出N皇后问题的全部摆法。 行里的第i个数字如果是n,就代表第i行的皇后应该放在第n列。 皇后的行、列编号都是从1开始算起。 输入样例: 4 输出样例: 2 4 1 3 3 1 4 2 解题思路: 国际象棋皇后的走法是横、直、斜均可走,但每次只能走一格。 ## 标题 以4皇后为例 ...

努力努力在努力的博客 4180

N皇后问题-回溯与递归-C++实现

问题描述:N皇后问题是一个古老而著名的问题,是回溯算法的典型案例。该问题由西洋棋棋手马克斯·贝瑟尔于1848年提出。在国际象棋上,N皇后问题变成了8皇后问题,著名的数学家高斯认为有76种方案,后来有人用图论的知识解出92种结果,计算机发明后,可以通过算法实现问题的求解。显然,大数学家有时候也会败在计算机面前。8皇后问题是指在8*8的棋盘上摆放8个皇后,使得任意两个皇后都不在同一行、同一列或者同一斜...

qq_38063665的博客 7767

递归求解N皇后问题(c语言)

/**//*=====N皇后问题*/#include stdio.h>#include conio.h>#include "../include/type.h"/**//*包含枚举变量bool的typedef*/#define N 4/*问题规模*/void Trial(int i,int j,int (*arr)[N]);/**//*递归法求解N皇后问题*/static void Mak

hichi的专栏 5265

递归求解n皇后问题

2、递归求解:将大问题转化为小问题,设queen(i,n)是在1~i-1行已经放置了i-1个皇后,用于在i~n行放置剩下的n-i+1个皇后,则queen(i+1,n)表示已经在1~i行上已经放好了i个皇后,用于在i+1~n行放置剩下的n-i个皇后,故queen(i,n)是大问题,queen(i+1,n)是小问题。采用整数q[N]来存放每一个皇后所在的列号,即第i个皇后在(i,q[i])位置上,count_1表示n皇后解的个数。queen(i,n):n个皇后放置完毕,输出一个解 若i>n;

m0_64850266的博客 1772

递归实现N皇后问题

1. 存储 因为每行只能放置一个皇后,故可用一维数组a[]存储 第i行皇后的列数,即 a[i]=j 表示第i行的皇后位于第j列。为方便起见,下标全部从1开始。它可以实时表示摆放的状态。 2. 递归算法 递归函数 queen(i) 可理解为:我们已经无冲突的摆放好了前(i-1)行的皇后并在数组a中存储,现在开始摆放第i行的皇后。对于第i行的摆法,我们遍历这一行的每一列j,如果位置(i,j)与前...

qq_41794508的博客 582

N皇后问题递归求解(内附详细代码)

N皇后问题递归求解(内附详细代码) 内容描述 二级标题 三级标题 四级标题 五级标题 六级标题 详细代码如下: #include <iostream> #include<math.h> using namespace std; #define N 20 //最多皇后的个数 int q[N];//存放皇后所在列号 int count = 0; void dispasolution(int n)//输出n皇后的一个解 { printf(" 第%d个解:",++count);

corleoen的博客 1万+

【N皇后问题】递归+回溯算法求解N皇后问题

同一行上面,只能存在一个皇后。同一列上面,只能存在一个皇后。同一斜线上面,只能存在一个皇后。满足上面三个规则的一个放置方法,我们把他叫做N皇后的一个解,常见的N皇后问题有:四皇后、八皇后。对于四皇后问题,可以有下面两种摆放方法:在这里为了程序方便,我们规定:将整个棋盘看作是一个【nxn】的二维矩阵,其中矩阵中每一个单元格位置存放的元素,如果是【.】点号,则表示当前位置没有放置皇后;如果是【Q】符号,则表示当前位置放置了一个皇后。下面具体介绍一下,如何通过程序求解N皇后的问题。

✅ Java 开发工程师 1264

BEVFormer详解

BEVFormer 是将Transformer架构的自注意机制与BEV视图中3D检测结合起来的一种纯视觉目标检测方案。对于纯视觉的BEV检测方案,其中的重中之重就是如何将2D的图像特征映射到3D空间的BEV栅格,既然是映射关系,那就有前行投影和反向查询两种机制。前向投影是基于深度估计的方法,参考基于深度估计的BEV视图转换方法,典型代表为LSS。反向查询方法思路为先将BEV栅格在Z方向上进行lift提升,然后再映射到图像特征图上进行特征查询。BEVFormer 就是基于这种机制进行2D图像特征到3D空间的B

MAX的专栏 4755

N皇后问题——递归与非递归

输入一个N,找出所有在N行N列的棋盘摆放N个皇后的方法。

软件程序媛的博客 1140

【强化学习】11 —— Double DQN算法与Dueling DQN算法

可以看到由于数据点的分布,使得拟合出的价值函数无法与真实的价值函数吻合,甚至在部分区域产生了明显的偏差。Dueling DQN 是 DQN 另一种的改进算法,它在传统 DQN 的基础上只进行了微小的改动,但却能大幅提升 DQN 的表现。这样,即使其中一套神经网络的某个动作存在比较严重的过高估计问题,由于另一套神经网络的存在,这个动作最终使用的值不会存在很大的过高估计问题。.在同一个状态下,所有动作的优势值之和为 0,因为所有动作的动作价值的期望就是这个状态的状态价值。环境的状态包括倒立摆角度的正弦值。

sinat_52032317的博客 1万+

【第0003页 · 递归】N皇后问题

今天我们来看一个著名的问题:N皇后问题。在此之前,我们先温习一下递归的思想。当然,温习的方式是看一道题目——全排列。 复习完递归的知识后,我们来看一下 N 皇后问题。这里我们采用暴力枚举和回溯优化两种做法来实现这个问题。但注意,暴力枚举不能完成 n = 12及以上的情况,这时我们必须要使用回溯优化的解法。(蓝色为OJ平台的链接) 但是,经过实验,上面的方法最多只能算到 11,算到 12 的时候就已经爆炸了,所以我们不得不寻找一个更为优化的解法。

HXR_plume的博客 1189

人大金仓数据库Kingbase FlySync同步程序安装

Kingbase FlySync同步程序(以下简称 KFS)是面向异地容灾、数据集中共享的场景推出的具备在异构数据平台间实现实时、增量数据同步的工具类产品,主要采用了物理日志解析技术,帮助用户解决不同数据平台的数据间可实现任意方向实时移动流转的问题,并保证此过程中数据不丢失,状态可监控,流转数据量可统计。KFS 需要安装的主要组件有 2 个,分别是后端同步程序和管理控制平台,另外KFS的部署方式也有2种,为分离部署何集中部署•集中部署:KFS与数据库部署在同一机器上。

weixin_44312518的博客 1185

从MRF8P9040N数据手册到ADS仿真:手把手教你搞定LDMOS功放设计(附完整模型下载)

本文详细解析了MRF8P9040N LDMOS功率放大器的数据手册关键参数,并提供了在ADS中进行仿真的完整指南。从模型导入、直流工作点验证到负载牵引与阻抗匹配设计,逐步指导工程师完成高效功放设计。文章还包含调试技巧和常见问题解决方案,帮助优化射频功放性能。

weixin_27015733的博客 494

递归算法:N皇后问题

问题描述: 输入一正整数n,要求n个国际象棋皇后,摆在n*n的棋盘上,互相不能攻击,即每个皇后的上下左右和对角线上仅有皇后自身。输出全部方案。 输入: 正整数N 输出: N皇后问题的全部摆法。输出的结果里的每一行代表一种摆法。行里的第i个数字如果是n,就代表第i行的皇后应该放在第n列。皇后的行列号都是从1开始算。 样例输入: 4 样例输出: 2 4 1 3 3 1 4 2 ...

CrazyTony的博客 1768

不只是驱动:拆解AIC8800 WiFi模组在RK Android系统的完整启动链(从DTS到HAL)

本文深入解析了AIC8800 WiFi模组在RK Android系统中的完整启动链,从设备树(DTS)配置到HAL层适配,涵盖驱动移植、固件加载及用户空间服务协同等关键环节。通过详细的技术分析和调试技巧,帮助开发者解决RK平台与AIC8800模组的兼容性问题,优化WiFi子系统性能。

weixin_30439067的博客 493

N皇后问题的递归回溯实现

N皇后问题的递归回溯实现

《致青春》——云梦泽 1988

k8s篇之underlay网络和overlay区别

underlay和overlay

小橙子的笔记屋 2144

ATS Request中的PASID的作用是什么

摘要: PASID(进程地址空间标识符)是PCIe ATS(地址转换服务)中的关键组件,用于标识不同进程或虚拟机的地址空间。其主要作用包括:1)支持多进程共享设备时隔离地址空间;2)实现共享虚拟地址(SVA),允许用户态程序直接访问设备;3)提升虚拟化性能(如SIOV),通过PASID区分虚拟机请求;4)增强安全性,基于PASID限制设备内存访问权限。PASID通过20位标识符在TLP前缀中传递,与IOMMU协作完成地址转换与缓存,适用于高性能计算、AI及虚拟化场景,但依赖硬件支持和软件适配。

元直的博客 1565

递归解决n皇后问题

递归描述: 递归是最简单的算法了,就是函数重复调用本身。当然我不可能这么敷衍了事,下面先看一下数据在内存中的存放。 栈区(stack):由编译器自动分配并释放,该区域一般存放函数的参数值,局部变量的值等。 堆区(heap):由程序员分配并释放,若程序员不释放,程序运行结束时由操作系统回收。(内存泄漏的事情还是挺可怕的) 寄存器区:用来保存栈顶指针和指令指针。 全局区,...

hehehahaxixi_的博客 1066

端侧 AI 落地避坑指南(中):为什么 QAT 救不了精度?——对齐“融合后算子“的硬件物理约束

在上一篇文章中,我们深入探讨了量化的本质,并得出结论:QAT(量化感知训练)是保持精度的关键。明明做了 QAT,精度还是崩塌了!让我们看一个真实的案例:✅ 使用了✅ 配置了量化✅ 训练了 50 个 epoch,学习率降为原来的 1/10✅ 冻结了 BN 统计量FP32 模型:mAP = 0.85QAT 后 FP32:mAP = 0.84(正常)工具量化后:mAP = 0.68(崩塌!问题出在哪里?层融合(Layer Fusion)机制。

weixin_51988935的博客 57

用递归思想与非递归思想实现n皇后问题

递归与非递归方法实现n皇后问题

lgx125130的博客 983

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

vb 6.0并口开发操作实例

vb6并口开发,简体中文,试例内有inpout32.dll动态链接库

N皇后问题(递归、非递归回溯法;位运算求解N皇后)

N皇后问题 n−皇后问题是指将n个皇后放在n×n的国际象棋棋盘上,使得皇后之间不能相互攻击到彼此,即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数n,请你输出所有的满足条件的棋子摆法,以及一共有多少种能够满足条件的棋子摆法。 数据范围 1<=n<=20 <iframe src="//player.bilibili.com/player.html?aid=374837176&bvid=BV1HZ4y1A7uV&cid=31450078...

PingBryant的博客 2235

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

N皇后问题(递归)

我们先来康康这个题:N皇后问题 这个题就是用递归来做啦 想要找到一个符合条件的方案,那么就需要将所有皇后放在合适的位置,那么最后一个皇后放的基础就是前N-1行的皇后都放好,那么第N-1行的皇后放的基础就是前N-2行的皇后都放好,以此类推。 那么我们的递归函数做的就是将第k行的皇后放置好。 当k>n时,计数加一,递归结束。 其他情况时则从第一列到第N列进行试探,与已排好序的前k-1个皇后进行...

Doro_的博客 1005

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

上一篇: 并发问题之网络IO模型
下一篇: Git 入门指南
funkiz
博客等级 码龄7年 12粉丝 6原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址