LeetCode051 N-Queens

最新推荐文章于 2025-08-10 20:50:18 发布
最新推荐文章于 2025-08-10 20:50:18 发布
阅读量296 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zxwtry/article/details/69831497
本文提供了一种解决N皇后问题的有效方法，通过回溯算法在Java、C和Python中实现，实现了在N×N的棋盘上放置N个皇后，使得任意两个皇后都不会互相攻击。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

详细见：leetcode.com/problems/n-queens


Java Solution: github

package leetcode;

import java.util.LinkedList;
import java.util.List;

public class P051_NQueens {
	public static void main(String[] args) {
//		Queen queen = new Queen();
//		queen.backtrack(1);
		System.out.println(new Solution2().solveNQueens(8).size());
	}
	/*
	 * 	4 ms
	 * 	91.55% 
	 */
	static class Solution1 {
		List<List<String>> ans = new LinkedList<List<String>>();
		int[] col = null, rup = null, lup = null, row = null;
		public List<List<String>> solveNQueens(int n) {
			if (n < 1)
				return ans;
			col = new int[n];
			row = new int[n];
			rup = new int[(n << 1) - 1];
			lup = new int[rup.length];
			search(0);
			return ans;
		}
		private void search(int index) {
			if (index == col.length) {
				List<String> answer = new LinkedList<String>();
				char[] cs = new char[index];
				for (int i = 0; i != index; i ++) {
					for (int j = 0; j != index; j ++)
						cs[j] = j == row[i] ? 'Q' : '.';
					answer.add(new String(cs));
				}
				ans.add(answer);
				return;
			}
			for (int i = 0; i != col.length; i ++) {
				if (col[i] == 0 && lup[index + i] == 0 && rup[col.length - 1 + index - i] == 0) {
					col[i] = lup[index + i] = rup[col.length - 1 + index - i] = 1;
					row[index] = i;
					search(index + 1);
					col[i] = lup[index + i] = rup[col.length - 1 + index - i] = 0;
				}
			}
		}
	}
	/*
	 * 	3 ms
	 * 	97.29%
	 */
	static class Solution2 {
		List<List<String>> ans = new LinkedList<List<String>>();
		boolean[] col = null, rup = null, lup = null;
		int[] row = null;
		public List<List<String>> solveNQueens(int n) {
			if (n < 1)
				return ans;
			col = new boolean[n];
			row = new int[n];
			rup = new boolean[(n << 1) - 1];
			lup = new boolean[rup.length];
			search(0);
			return ans;
		}
		private void search(int index) {
			if (index == col.length) {
				List<String> answer = new LinkedList<String>();
				char[] cs = new char[index];
				for (int i = 0; i != index; i ++) {
					for (int j = 0; j != index; j ++)
						cs[j] = j == row[i] ? 'Q' : '.';
					answer.add(new String(cs));
				}
				ans.add(answer);
				return;
			}
			for (int i = 0; i != col.length; i ++) {
				if (! col[i] && ! lup[index + i] && ! rup[col.length - 1 + index - i]) {
					col[i] = lup[index + i] = rup[col.length - 1 + index - i] = true;
					row[index] = i;
					search(index + 1);
					col[i] = lup[index + i] = rup[col.length - 1 + index - i] = false;
				}
			}
		}
	}
}


C Solution: github

/*
    url: leetcode.com/problems/n-queens/
    AC 6ms 16.67%
    AC 3ms 50.00%
*/

#include <stdio.h>
#include <stdlib.h>

//array list start

typedef char** T;
typedef struct al sal;
typedef struct al * pal;

struct al {
    int capacity;
    int size;
    T* arr;
};

void al_expand_capacity(pal l) {
    T* new_arr = (T*) malloc(sizeof(T) * (l->capacity * 2 + 1));
    int i = 0;
    for (i = 0; i < l->capacity; i ++)
        new_arr[i] = l->arr[i];
    free(l->arr);
    l->arr = new_arr;
    l->capacity = l->capacity * 2 + 1;
}

void al_add_last(pal l, T v) {
    if (l->capacity == l->size) al_expand_capacity(l);
    l->arr[l->size] = v;
    l->size ++;
}

void al_add_to_index(pal l, T v, int index) {
    int i = 0;
    if (index > l->size) return;
    if (l->capacity == l->size) al_expand_capacity(l);
    for (i = l->size - 1; i >= index; i --) {
        l->arr[i+1] = l->arr[i];
    }
    l->arr[index] = v;
    l->size ++;
}

T* al_convert_to_array_free_l(pal l) {
    T* arr = l->arr;
    free(l);
    return arr;
}

T al_access_by_index(pal l, int index) {
    if (index >= l->size || index < 0) return 0;
    return l->arr[index];
}

//array list end


int valid(char** save, int i, int j, int n) {
    int k = 0, ii = 0, jj = 0;
    for (k = 0; k < n; k ++) {
        if (k != i && save[k][j] == 'Q') return 0;
        if (k != j && save[i][k] == 'Q') return 0;
    }
    ii = i + 1;
    jj = j + 1;
    while (ii < n && jj < n) {
        if (save[ii][jj] != 'Q') {
            ii ++;
            jj ++;
        } else return 0;
    }
    ii = i - 1;
    jj = j - 1;
    while (ii > -1 && jj > -1) {
        if (save[ii][jj] != 'Q') {
            ii --;
            jj --;
        } else return 0;
    }
    ii = i + 1;
    jj = j - 1;
    while (ii < n && jj > -1) {
        if (save[ii][jj] != 'Q') {
            ii ++;
            jj --;
        } else return 0;
    }
    ii = i - 1;
    jj = j + 1;
    while (ii > -1 && jj < n) {
        if (save[ii][jj] != 'Q') {
            ii --;
            jj ++;
        } else return 0;
    }
    return 1;
}

void solve(pal l, char** save, int row, int n) {
    char** temp = NULL, *temp_row = NULL;
    int i = 0, j = 0, col = 0;
    if (row == n) {
        temp = (char**) malloc(sizeof(char*) * n);;
        for (i = 0; i < n; i ++) {
            temp_row = (char*) malloc(sizeof(char) * (n+1));
            for (j = 0; j < n; j ++) temp_row[j] = save[i][j];
            temp_row[n] = '\0';
            temp[i] = temp_row;
        }
        al_add_last(l, temp);
        return;
    }
    for (col = 0; col < n; col ++) {
        if (valid(save, row, col, n)) {
            save[row][col] = 'Q';
            solve(l, save, row+1, n);
            save[row][col] = '.';
        }
    }
}

char*** solveNQueens(int n, int* r) {
    char** save = (char**) malloc(sizeof(char*) * n);
    char* save_row = NULL;
    int i = 0, j = 0;
    pal l = (pal) malloc(sizeof(sal));
    l->size = 0;
    l->capacity = 16;
    l->arr = (T*) malloc(sizeof(T) * l->capacity);
    for (i = 0; i < n; i ++) {
        save_row = (char*) malloc(sizeof(char) * (n+1));
        for (j = 0; j < n; j ++) save_row[j] = '.';
        save_row[n] = '\0';
        save[i] = save_row;
    }
    solve(l, save, 0, n);
    *r = l->size;
    return al_convert_to_array_free_l(l);
}


void solve2(pal l, char** save, int row, int n, int* col_sign, int* lup_sign, int* rup_sign) {
    char** temp = NULL, *temp_row = NULL;
    int i = 0, j = 0, col = 0;
    if (row == n) {
        temp = (char**) malloc(sizeof(char*) * n);;
        for (i = 0; i < n; i ++) {
            temp_row = (char*) malloc(sizeof(char) * (n+1));
            for (j = 0; j < n; j ++) temp_row[j] = save[i][j];
            temp_row[n] = '\0';
            temp[i] = temp_row;
        }
        al_add_last(l, temp);
        return;
    }
    for (col = 0; col < n; col ++) {
        if (!col_sign[col] && !lup_sign[col - row + n - 1] && !rup_sign[row + col]) {
            col_sign[col] = lup_sign[col - row + n - 1] = rup_sign[row + col] = 1;
            save[row][col] = 'Q';
            solve2(l, save, row+1, n, col_sign, lup_sign, rup_sign);
            save[row][col] = '.';
            col_sign[col] = lup_sign[col - row + n - 1] = rup_sign[row + col] = 0;
        }
    }
}

char*** solveNQueens2(int n, int* r) {
    char** save = (char**) malloc(sizeof(char*) * n);
    char* save_row = NULL;
    int i = 0, j = 0;
    pal l = (pal) malloc(sizeof(sal));
    int *col_sign = NULL, *lup_sign = NULL, *rup_sign = NULL; 
    l->size = 0;
    l->capacity = 16;
    l->arr = (T*) malloc(sizeof(T) * l->capacity);
    col_sign = (int*) malloc(sizeof(int) * n);
    lup_sign = (int*) malloc(sizeof(int) * (2 * n - 1));
    rup_sign = (int*) malloc(sizeof(int) * (2 * n - 1));
    for (i = 0; i < n; i ++) col_sign[i] = 0;
    for (i = 0; i < 2 * n - 1; i ++) lup_sign[i] = 0;
    for (i = 0; i < 2 * n - 1; i ++) rup_sign[i] = 0;
    for (i = 0; i < n; i ++) {
        save_row = (char*) malloc(sizeof(char) * (n+1));
        for (j = 0; j < n; j ++) save_row[j] = '.';
        save_row[n] = '\0';
        save[i] = save_row;
    }
    solve2(l, save, 0, n, col_sign, lup_sign, rup_sign);
    *r = l->size;
    free(col_sign);
    free(lup_sign);
    free(rup_sign);
    return al_convert_to_array_free_l(l);
}

int main() {
    int r = 0;
    int n = 13;
    int i = 0;
    int j = 0;
    char*** ans = NULL;
    for (n = 1; n < 7; n ++) {
        ans = solveNQueens2(n, &r);            
        printf("n is %d  r is %d\r\n", n, r);
        for (i = 0; i < r; i ++) {
            for (j = 0; j < n; j ++) {
                printf("%s\r\n", ans[i][j]);
                free(ans[i][j]);
            }
            printf("=======================\r\n");
        }
        free(ans);
    }
}


Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/n-queens
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年4月9日
    @details:    Solution: 92ms 83.33%
'''

class Solution(object):
    def search(self, a, c, l, r, i, n, rec):
        if i == n:
            a_t,a_j=[],['.']*8
            for j in range(n):
                for j in range(n):
                    a_j[j]=(rec[j][j])
                a_t.append("".join(a_j))
            a.append(a_t)
            return
        for j in range(n):
            if not c[j] and not l[j+i] and not r[j-i+n-1]:
                c[j]=l[j+i]=r[j-i+n-1]=True
                rec[i][j]='Q'
                self.search(a, c, l, r, i+1, n, rec)
                c[j]=l[j+i]=r[j-i+n-1]=False
                rec[i][j]='.'
                
    def solveNQueens(self, n):
        """
        :type n: int
        :rtype: List[List[str]]
        """
        a,c,l,r=[],[False]*n,[False]*(2*n-1),[False]*(2*n-1)
        rec=[['.' for i in range(n)] for j in range(n)]
        self.search(a, c, l, r, 0, n, rec)
        return a

if __name__ == "__main__":
    print(Solution().solveNQueens(5))


js-leetcode题解之52-n-queens-II.js
10-25
对于"52-n-queens-II.js"这一特定的实现，我们主要关注的是52题的变体，即如何计算出所有可能的解，而不仅仅是返回任意一个解。 在实现这个问题的解决方案时，通常会用到回溯算法。回溯算法是一种通过递归来穷举...
js-leetcode题解之51-n-queens.js
10-25
8. JavaScript语言特性：在编写js-leetcode题解之51-n-queens.js时，需要利用JavaScript语言的数组、循环、条件判断以及递归等特性。 9. 功能测试：在算法实现完成后，需要编写测试用例来验证算法的正确性。测试时...
《leetCode》：N-Queens（奇葩的测试平台，居然不能AC）
wojiushimogui的博客
11-16 623
题目The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other. Given an integer n, return all distinct solutions to the n-queens puzzle.Each s
51.N皇后
weixin_31301271的博客
05-19 131
n皇后问题 研究的是如何将 n个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 给你一个整数 n ，返回所有不同的n皇后问题 的解决方案。 每一种解法包含一个不同的n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。 来源：力扣（LeetCode） 链接：https://leetcode.cn/problems/n-queens 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 /** * Return an array...
回溯算法
fantastikman的博客
10-15 223
文章目录回溯算法定义举例       n皇后（LeeCode 51题） 回溯算法定义        回溯法是一种系统搜索问题解空间的方法。为了实现回溯，需要给问题定义一个解空间。说到底它是一种搜索算法。只是这里的搜索是在一个叫做解空间的地方搜索。要实现回溯，需要两点1搜索，2解空间。     &nb...
【C语言】N皇后问题
lichangtian07的专栏
09-22 1593
LeetCode上的51题-N皇后问题 提纲： 题目 引用算法研究 编写题目答案 1 题目 如图所示 2 引用算法研究 《零基础学算法》一书中有八皇后问题的解决方案： 1 递归方式： #include <stdio.h> #include <string.h> #include <stdlib.h> int iCount =...
leetcode 51 N皇后 C语言实现
qq_42007287的博客
02-14 349
测评 题目 示例: 输入: 4 输出: [ [".Q…", // 解法 1 “…Q”, “Q…”, “…Q.”], ["…Q.", // 解法 2 “Q…”, “…Q”, “.Q…”] ] 解释: 4 皇后问题存在两个不同的解法。 代码 //检查行、列、左斜、右斜是否已有皇后 int isExist(int row[], int col[], int lbevel[], int rbeve...
LeetCode 051 N-Queens
zhujf553的博客
06-01 393
题目是经典的n皇后问题。即在n乘n的国际象棋棋盘上放置n个皇后，让这些皇后互相不攻击到对方。
LeetCode-n-queens
六月二十七的博客
04-09 242
Then-queens puzzle is the problem of placingnqueens on ann×nchessboard such that no two queens attack each other. Given an integern, return all distinct solutions to then-queens puzzle. Eac...
Leetcode051 n-queens
Peter-Haoran的博客
04-19 169
N皇后 题目描述： n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 上图为 8 皇后问题的一种解法。 给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。 每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。 示例 输入: 4 输出: [ [".Q..", // 解法 1 "...
LeetCode-n-queens-ii
六月二十七的博客
04-09 221
public class Solution { public int totalNQueens(int n) { switch (n){ case 0:return 1; case 1:return 1; case 2:return 0; case 3:return 0; ...
leetcode71python-leetcode:leetcode
06-30
leetcode 71 Python用 Python 编写 Leetcode （数据科学家的解决方案） - 易于理解的最佳解决方案，可以通过所有 Leetcode 测试用例，对于非 ...leetcode ...leetcode ...N-Queens (HARD) Leetcode 52. N-
leetcode答案-LeetCode-and-At-Offer:LeetCode即买即卖
06-30
leetcode ...NQueens * 回溯法- 网易2017算法工程师笔试题3 * 贪心法- Dijkstra算法 ShortestDistanceAlgorithm * 动态规划- Floyd最短路径算法 ShortestDistanceAlgorithm * 动态规划- 最长公共子序列 ...
Swift 实战：高效设计 Tic-Tac-Toe 游戏逻辑（LeetCode 348）
网罗天下方法，方便你我开发！！！
08-07 1009
如果让你实现一个两人对战的井字棋（Tic-Tac-Toe）游戏逻辑，你会怎么做？是不是会直接用二维数组存每个格子的状态，然后在每次落子后从头到尾检查是否赢了？ 这种方式虽然直观，但效率并不高，特别是当棋盘扩大到 n×n 的时候。LeetCode 348 这个题目就挑战我们去优化这个过程：每次落子之后都要快速判断胜负，尽可能降低计算开销。
leetcode 11. 盛最多水的容器 -java
weixin_41624462的博客
08-09 104
这是因为木桶底部长度在指针在两头时是最大的，指针内移x轴长度一定会减小，这时如果想要获取更大面积，需要获取两个height里较小的那个，让他增大，面积才会增大，所以较小的元素的指针向内循环，寻找更大的值，一直到左右两个指针重合，结束循环。改进：接水 - 接多少水取决于短版的长度，所以可以使用双指针法，每次比较，保留较大元素的指针不动，较小元素的指针平移寻找更大的指针，直到两个指针相遇。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。说明：你不能倾斜容器。
leetcode2461：长度为K子数组中的最大和（定长滑动窗口+哈希去重）
lyh2004_08的博客
08-10 180
这道LeetCode题目要求找到长度为k的子数组，其所有元素必须唯一，且和最大。核心解法结合滑动窗口和哈希表：滑动窗口维护固定长度的子数组和，哈希表确保元素唯一性。当哈希表大小等于k时，说明当前窗口满足条件，更新最大和即可。时间复杂度O(N)，空间复杂度O(k)。关键点在于正确维护哈希表的元素计数，并在和超过整数范围时使用long类型存储。该解法高效地解决了固定长度窗口与元素唯一性的双重约束问题。
力扣559:N叉树的最大深度
最新发布
weixin_74285822的博客
08-10 112
摘要： 本文探讨了力扣559题"N叉树的最大深度"的两种解法。**深度优先搜索（DFS）**通过递归计算子树的最大深度并加1；**广度优先搜索（BFS）**通过层序遍历统计树的层数。两种方法均能高效解决问题，DFS时间复杂度为O(N)，BFS需借助队列实现。代码提供了C++实现示例，展示了树遍历在图论和算法中的经典应用场景。
LeetCode有效三角形的个数
Chihiro_wyj的博客
08-08 365
文章摘要： 题目要求统计数组中能构成三角形的三元组个数。解题关键在于排序后利用双指针技巧：固定最长边nums[third]，用双指针first和second在左侧寻找满足nums[first]+nums[second]>nums[third]的组合。当条件满足时，first到second之间的所有数对都有效，可直接累加结果。时间复杂度因排序和双指针优化降至O(n^2)。代码实现先排序数组，外层循环固定third，内层用双指针搜索有效组合，通过移动指针动态统计满足条件的数对数量。
Leetcode 3645. Maximum Total from Optimal Activation Order
codename_cys的博客
08-10 251
Leetcode 3645. Maximum Total from Optimal Activation Order
分治-快排-215.数组中的第k个最大元素-力扣(LeetCode)
black_bear_white的博客
08-08 256
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值