89. Gray Code \ 51. N-Queens \ 52. N-Queens II

最新推荐文章于 2024-09-22 04:59:47 发布
最新推荐文章于 2024-09-22 04:59:47 发布
阅读量521 收藏
点赞数 1
分类专栏： Leetcode 文章标签： leetcode 89 51 N-Queens Gray-Code
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c602273091/article/details/54965837
版权

89. Gray Code

题目描述

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Note:
For a given n, a gray code sequence is not uniquely defined.

For example, [0,2,3,1] is also a valid gray code sequence according to the above definition.

For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.

Subscribe to see which companies asked this question.

解题思路

法一：把格雷码写出来，然后可以发现一个规律，就是第一位是0110重复，第二位是00111100，第三位是0000111111110000，第四位是00000000111111111111111100000000. 所以代码可以写成：

class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> res;
        int num = 1 << n;
        int tmp = 0;
        for(int i = 0; i < num; i++) {
            tmp = 0;
            for(int j = 1; j <= n; j++) {
                int divend = 1 << (j+1);
                int rem = i%divend;
                tmp += (rem >= (1 << (j-1)) && rem < ((1 << (j-1))*3)) << (j - 1);
                // cout << (rem >= (1 << (j-1)) && rem < ((1 << (j-1))*3)) << (j - 1) << " " << i << " rem" << rem << "div" << divend<< endl;
            }
            res.push_back(tmp);
        }
        return res;
    }
};

另外根据wiki上格雷码的定义，可以知道：

class Solution {
public:
    vector<int> grayCode(int n) {
        int num = 1 << n;
        vector<int> res;
        for (int i=0; i < num; i++) 
            res.push_back(i^(i>>1));
        return res;
    }
};

但是这样的思路让人觉得不够自动化，还需要人去总结这些东西。
在discussion部分有人提供了这个比较特别的思路。我觉得这个不能算作是回溯。普通的递归吧。

https://discuss.leetcode.com/topic/31750/backtracking-c-solution

class Solution {
    void utils(bitset<32>& bits, vector<int>& result, int k){
        if (k==0) {
            result.push_back(bits.to_ulong());
        }
        else {
            utils(bits, result, k-1);
            bits.flip(k-1);
            utils(bits, result, k-1);
        }
    }

public:
    vector<int> grayCode(int n) {
        bitset<32> bits;
        vector<int> result;
        utils(bits, result, n);
        return result;
    }
};

51. N-Queens

题目描述

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens’ placement, where ‘Q’ and ‘.’ both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

代码实现

这里我用数字0和1表示棋盘，然后再换成字母，好像没有必要这么做。

class Solution {
public:
    void putIntoAnswer(vector<vector<string> > &res, vector<vector<int> > &chess, int n) {
        vector<string> vs;
        for(int i = 0; i < n; i++) {
            string tmp;
            for(int j = 0; j < n; j++) {
                tmp += (chess[i][j]?'Q':'.');
            }
            vs.push_back(tmp);
        }
        res.push_back(vs);
    }

    bool isSatisfyRule(vector<vector<int> > chess, int n, int stt) {
        for(int i = 0; i <= stt; i++)
            for(int j = 0; j < n; j++) {
               if(chess[i][j] == 1) {
                    int row = i, col = j;
                    while((--col) >= 0 && (++row) <= stt) {
                        if(chess[row][col] == 1)
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt) {
                        if(chess[row][col] == 1)
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt && (++col) < n) {
                        if(chess[row][col] == 1)
                            return false;
                    }                    
                }     
            }

        return true;    
    }

    void nQueen(vector<vector<string> > &res, vector<vector<int> > &chess, int n, int stt) {
        if(stt == n) { // isSolution(chess, stt, n)) {
            putIntoAnswer(res, chess, n);
            return;
        }
        if(stt == n)
            return;

        // the number stt stands for the row
        // i stands for column.
        for(int i = 0; i < n; i++) {
            chess[stt][i] = 1;
            if(isSatisfyRule(chess, n, stt)) 
                nQueen(res, chess, n, stt+1);
            chess[stt][i] = 0;
        } 
    }

    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string> > res;
        vector<vector<int>> chess(n, vector<int>(n, 0));
        nQueen(res, chess, n, 0);
        return res;
    }
};

修改了一下代码，使得速度提升了一些，都是还不够快。

class Solution {
public:
    void putIntoAnswer(vector<vector<string> > &res, vector<vector<char> > &chess, int n) {
        vector<string> vs;
        for(int i = 0; i < n; i++) {
            string tmp(chess[i].begin(), chess[i].end());
            /*
            for(int j = 0; j < n; j++) {
                tmp += chess[i][j];
            }
            */
            vs.push_back(tmp);
        }
        res.push_back(vs);
    }

    bool isSatisfyRule(vector<vector<char> > chess, int n, int stt) {
        for(int i = 0; i <= stt; i++)
            for(int j = 0; j < n; j++) {
               if(chess[i][j] == 'Q') {
                    int row = i, col = j;
                    while((--col) >= 0 && (++row) <= stt) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt && (++col) < n) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }                    
                }     
            }

        return true;    
    }

    void nQueen(vector<vector<string> > &res, vector<vector<char> > &chess, int n, int stt) {
        if(stt == n) { // isSolution(chess, stt, n)) {
            putIntoAnswer(res, chess, n);
            return;
        }

        // the number stt stands for the row
        // i stands for column.
        for(int i = 0; i < n; i++) {
            chess[stt][i] = 'Q';
            if(isSatisfyRule(chess, n, stt)) 
                nQueen(res, chess, n, stt+1);
            chess[stt][i] = '.';
        } 
    }

    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string> > res;
        vector<vector<char>> chess(n, vector<char>(n, '.'));
        nQueen(res, chess, n, 0);
        return res;
    }
};

再修改：

class Solution {
public:
    void putIntoAnswer(vector<vector<string> > &res, vector<vector<char> > &chess, int n) {
        vector<string> vs;
        for(auto i:chess) {
            vs.push_back(string(i.begin(), i.end()));
        }
        res.push_back(vs);
    }

    bool isSatisfyRule(vector<vector<char> > chess, int n, int stt) {
        for(int i = 0; i <= stt; i++)
            for(int j = 0; j < n; j++) {
               if(chess[i][j] == 'Q') {
                    int row = i, col = j;
                    while((--col) >= 0 && (++row) <= stt) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }
                    row = i, col = j;
                    while((++row) <= stt && (++col) < n) {
                        if(chess[row][col] == 'Q')
                            return false;
                    }                    
                }     
            }

        return true;    
    }

    void nQueen(vector<vector<string> > &res, vector<vector<char> > &chess, int n, int stt) {
        if(stt == n) { // isSolution(chess, stt, n)) {
            putIntoAnswer(res, chess, n);
            return;
        }

        // the number stt stands for the row
        // i stands for column.
        for(int i = 0; i < n; i++) {
            chess[stt][i] = 'Q';
            if(isSatisfyRule(chess, n, stt)) 
                nQueen(res, chess, n, stt+1);
            chess[stt][i] = '.';
        } 
    }

    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string> > res;
        vector<vector<char>> chess(n, vector<char>(n, '.'));
        nQueen(res, chess, n, 0);
        return res;
    }
};

52. N-Queens II

题目描述

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

代码实现

把上面n 皇后的问题改一下就可以了。

class Solution {
public:
    bool isSatisfyWithRule(vector<vector<int>>chess, int n, int stt) {
        for(int i = 0; i <= stt; i++) {
            for(int j = 0; j < n; j++) {
                if(chess[i][j]) {
                    int row = i, col = j;
                    while((++row) <= stt && (--col) >= 0)
                        if(chess[row][col])
                            return false;
                    row = i, col = j;
                    while((++row) <= stt ) 
                        if(chess[row][col])
                            return false;
                    row = i ,col = j;        
                    while((++row) <= stt && (++col) < n)
                        if(chess[row][col])
                            return false;
                }
            }
        }
        // cout << n << " " << stt << endl;
        return true;    
    }

    void bp(int &res, vector<vector<int>>&chess, int stt, int n) {
        if(stt == n) {
            res++;
            // cout << res << endl;
            return;
        }    
        for(int i = 0; i < n; i++) {
            chess[stt][i] = 1;
            if(isSatisfyWithRule(chess, n, stt)) 
                bp(res, chess, stt+1, n);
            chess[stt][i] = 0;
        }    
    }

    int totalNQueens(int n) {
        int res = 0;
        vector<vector<int>>chess(n, vector<int>(n, 0));
        bp(res, chess, 0, n);
        return res;
    }
};
Snail_Walker
关注
专栏目录
LeetCode All in One [(持续更新中...] --到808
大树叶 技术专栏
10-06 1744
原文地址：https://www.cnblogs.com/grandyang/p/4606334.html LeetCode 　到808 808 Soup Servings 33.60% Medium 807 Max Increase to Keep City Skyline 79.60% Medium 806 Number of Lines ...
LeetCode(51-100)
LintaoD的博客
08-10 412
LeetCode(51-100) 51. N-Queens   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 ...
51-100 Leetcode 题目总结
maryhaocoolcool的博客
08-21 225
1 Array 第五十四题： Spiral Matrix 本题可以设置一个top，bottom，left,right 等通过++，--来改变边界。 注意：1 if(matrix.size()==0) return res; 2if(top>bottom) break;if(left>right) break; 3 定义：vec...
LeetCode-分类题解
ABCD8730012的博客
11-22 206
数组 Remove Duplicates from Sorted ArrayRemove Duplicates from Sorted Array IISearch in Rotated Sorted ArraySearch in Rotated Sorted Array IIMedian of Two Sorted ArraysLongest Consec...
www.leetcode.com
oPerform的专栏
04-26 1100
最近完成了www.leetcode.com的online judge中151道算法题目。除各个题目有特殊巧妙的解法以外，大部分题目都是经典的算法或者数据结构，因此做了如下小结，具体的解题思路可以搜索我的博客：LeetCode题解 题目 算法 数据结构 注意事项 Clone Graph BFS 哈希表 Word Ladder II BFS 哈希表 Surr...
LeetCode All in One题解汇总（持续更新中...）
weixin_30621711的博客
03-30 391
突然很想刷刷题，LeetCode是一个不错的选择，忽略了输入输出，更好的突出了算法，省去了不少时间。 dalao们发现了任何错误，或是代码无法通过，或是有更好的解法，或是有任何疑问和建议的话，可以在对应的随笔下面评论区留言，我会及时处理，在此谢过了。 过程或许会很漫长，也很痛苦，慢慢来吧。 编号 题名 过题率 难度 1 Two Sum 0.376 Easy 2 Add Two N...
LintCode 解题记录 17.10.5 递归
每天完成一个小目标
10-06 288
LintCode Balanced Binary Tree题目描述给定一棵树，判断其是不是平衡二叉树(Avl树)思路平衡二叉树的定义是对于一个二叉查找树来说，其每一个节点的平衡因子(左右子树高度差的绝对值)小于2。 所以思路就很明朗，对于每一个节点，先判断该节点是否满足平衡条件，如何不满足则直接返回false，如果满足就递归地判断其左子树和右子树。代码 bool isBalanced(Tre
LeetCode All in One 题目讲解汇总(持续更新中...)
weixin_30853329的博客
08-31 221
LeetCode All in One 题目讲解汇总(持续更新中...) 终于将LeetCode的大部分题刷完了，真是漫长的第一遍啊，估计很多题都忘的差不多了，这次开个题目汇总贴，并附上每道题目的解题连接，方便之后查阅吧~对应的Github 项目的同步地址如下，欢迎大家关注点赞❤️ https://github.com/grandyang/leetcode ...
【LeetCode】 高效算法刷题思路、算法题目分类 - 持续更新
|~~~热爱生活、努力学习的小伙汁~~~|
10-15 3285
刷 LeetCode 上的算法题对于掌握算法还是非常有在帮助的，但上面的题目太多太杂， 如果不做以归类，有目的性的刷题，最终肯定会有些心得，但同时也会浪费大量的时间。 但作为一个没刷多少题的 LeetCode 新手小白来说，对题目分类有点虚了。 本文是参考网上已有的 LeetCode 高手，并且结合自身的情况，进行归整， 希望归整出一份从㳀入深，适合自已的高效刷题方法。 好，我们开始吧^_^ 算法分类 1. 排序算法    2. 双指针      3. 字符串      4. 位运算   
用python解决N Queens problem，给出完整代码（用英语写注释），做成动画显示每一步怎么摆放棋子，以四个棋子为例
最新发布
09-23
Sure, let's solve the N-Queens Problem using Python with an animation to illustrate each step for a four-queens scenario. Here's a complete code snippet with English comments: ```python import numpy ...
Leetcode难度表及解题汇总
西代零零发
05-08 4251
Leetcode难度表及解题汇总参考网上一份题目难度表，以及本人的解题。 Id Question Difficulty Frequency Data Structures Algorithms Blog Comment 1 Two Sum 2 5 array+set sort+2ptr 2 Add Two Numbers
LeetCode 从零单刷个人笔记整理（持续更新）
NJU_ChopinXBP的博客
04-19 3900
更新至2019.4.19 本人博客用于个人对知识点的记录和巩固。之前刷了《剑指Offer》，基本每道题都用两种语言过了一遍，比较用心地进行原理和方法的剖析，并且用几乎所有可行的方法进行了实现和调优，大多数题目都附上了测试用例，少数题目进行了一些升级和扩充。感兴趣的话可以看这里：#程序员面试必备#《剑指Offer》从零单刷个人笔记整理（66题全） 刷完剑指Offer后下一步就是LeetCode了。下...
Python | Leetcode Python题解之第423题从英文中重建数字
Mopes__的博客
09-22 319
Python | Leetcode Python题解之第423题从英文中重建数字
Leetcode面试经典150题-173.二叉搜索树迭代器
个人专长：数据结构和算法、大数据、数据库、主流框架
09-18 1216
Leetcode面试经典150题-173.二叉搜索树迭代器，字节跳动高频面试题啊，抖音和头条都考过，务必掌握
Leetcode 93-复原 IP 地址
Helene1996的博客
09-19 611
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。
【每日一题】LeetCode 2332.坐上公交的最晚时间（数组、双指针、二分查找、排序）
Hanbuhuic的博客
09-18 933
给你一个下标从开始长度为n的整数数组buses，其中buses[i]表示第i辆公交车的出发时间。同时给你一个下标从开始长度为m的整数数组passengers，其中表示第j位乘客的到达时间。所有公交车出发的时间互不相同，所有乘客到达的时间也互不相同。给你一个整数capacity，表示每辆公交车能容纳的乘客数目。每位乘客都会搭乘下一辆有座位的公交车。如果你在y时刻到达，公交在x时刻出发，满足y
C++速通LeetCode中等第3题-盛最多水的容器
lyx的博客
09-18 327
双指针法：两个指针分别指向左右边界，记录最大面积，由于面积由短板决定，两个指针中较短的短指针向内移动一格，再次记录最大面积，直到两指针相遇，得出答案。
N-Queens问题能够进行动画演示的代码
09-20
N-Queens问题是一个经典的回溯算法问题，它涉及在一个n×n的棋盘上放置n个皇后，使得任意两个皇后都不在同一行、同一列或对角线上。要将其动画演示，你可以使用Python的pygame库来创建一个动态棋盘，并逐步添加皇后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值