学渣带你刷Leetcode0052N皇后 II 

题目描述

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回 n 皇后不同的解决方案的数量。

示例:

输入: 4
输出: 2
解释: 4 皇后问题存在如下两个不同的解法。
[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-queens-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

白话题目：
 

好多书上或者C语言教材中提及到的8皇后问题的一种扩展，输入N作为多少维的皇后问题，输出一共有多少种解，题目很明确。

小小的前提条件就是皇后之间不能互相攻击，皇后之间攻击的条件时同行、同列、同斜线都是可以互相打击的。女人何苦难为女人。

算法：

（1）输入简单的N就好

（2）我打算用回溯法处理，

就是没一行尝试能够放置的位置。

//1,边界，n个皇后放完了
//2,判定一个皇后是否能够放下的条件：行，列，正反斜线都不能有其他的皇后存在
//3,回溯标志，行数，也是皇后数量，每行肯定有一个皇后
//4,如何快速判断 行，列，正反斜线 是否有其他的皇后

先手动的以4皇后为例

关键的函数判断行列斜线是否满足

(pRet[row][i] == 'Q') || (pRet[i][col] == 'Q')

斜线：

由于是一行行的看，斜线就检查左上与右上就行

详细解释关注 B站  【C语言全代码】学渣带你刷Leetcode 不走丢 https://www.bilibili.com/video/BV1C7411y7gB

C语言完全代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

//方法一：回溯法
//1,边界，n个皇后放完了
//2,判定一个皇后是否能够放下的条件：行，列，正反斜线都不能有其他的皇后存在
//3,回溯标志，行数，也是皇后数量，每行肯定有一个皇后
//4,如何快速判断 行，列，正反斜线 是否有其他的皇后

#define     MIN(a, b)   (((a) < (b)) ? (a) : (b))
#define     MAX(a, b)   (((a) > (b)) ? (a) : (b))

//函数一：判断当前位置 row,col 是否能够放皇后
bool judgeQueenValid(char** pRet, int n, int row, int col)
{
    bool        bRet        = true;  //默认  行
    int         i           = 0;
    int         j           = 0;

    //1,行、列判断
    for (i = 0; i < n; i++)
    {
        if ((pRet[row][i] == 'Q') || (pRet[i][col] == 'Q'))
        {
            bRet = false;
            return bRet;
        }
    }
     int k=1;
    //2,正斜线判断  i = MAX(row - col, 0), j = MAX(col - row, 0)这个地方比较好玩
    for (i =row , j =col ; (i -k>= 0) && (j-k >=0);k++ )
    {
        if (pRet[i-k][j-k] == 'Q')
        {
            bRet = false;
            return bRet;
        }
    }
     k=1;
    //3,反斜线判断
    for (i =row , j =col ; (i -k>= 0) && (j+k <n);k++ )
    {
        if (pRet[i-k][j+k] == 'Q')
        {
            bRet = false;
            return bRet;
        }
    }

    return bRet;
}

//函数三：回溯处理
bool backTrackQueen(char** pRet, int n, int* returnSize, int row)
{
    int         i       = 0;
    int         j       = 0;
    bool        bValid  = false;

    //1,边界处理
    if (row == n)
    {
        // 成功找到一个答案
        *returnSize += 1;
        for (i = 0; i < n; i++)
        {

            for (j = 0; j < n; j++)
            {
                printf("%c ",pRet[i][j]);
            }
            printf("\n");
        }
        printf("--------------------\n");

        return true;
    }

    //2,回溯处理
    for (i = row; i < n; i++)
    {
        bValid = false;
        for (j = 0; j < n; j++)
        {
            //判断当前位置是否能够放皇后
            if (judgeQueenValid(pRet, n, i, j))
            {
                bValid = true;
                pRet[i][j] = 'Q';

                backTrackQueen(pRet, n, returnSize, i + 1);//一层层的近

                //3，回退处理，出来的时候，把这个的i，j变成.
                bValid = false;
                pRet[i][j] = '.';
            }
        }

        //4,任何一行如果放不下皇后，则该条路不成立，返回上一层
        if (!bValid)
        {
            return false;
        }
    }
    return false;
}

int totalNQueens(int n)
{
    int             i           = 0;
    int             j           = 0;
    char**          pRet        = NULL;  //想想成二维数组的意思，行地址空间
    int             iRetSize    = 0;

    //1,初始化  几位的空间地址
    pRet = (char**)malloc(sizeof(char*) * n);
    memset(pRet, 0x00, sizeof(char*) * n);
    //0x00,一个字节
    //0，根据编译器，默认作为int，4或者8个字节


    for (i = 0; i < n; i++)
    {
        pRet[i] = (char*)malloc(sizeof(char) * (n + 1));
        for (j = 0; j < n; j++)
        {
            pRet[i][j] = '.';
        }
        pRet[i][j] = '\0';
    }


    for (i = 0; i < n; i++)
    {

        for (j = 0; j < n; j++)
        {
            printf("%c ",pRet[i][j]);
        }
        printf("\n");
    }
    printf("--------------\n");



    //2,回溯函数,开始你的表演，从0行开始
    backTrackQueen(pRet, n, &iRetSize, 0);

    //3,返回
    return iRetSize;
}