lintcode(13)——N皇后问题

本文介绍了N皇后问题,即在n*n棋盘上放置n个皇后,使其互不攻击。文章给出了两种不同的问题,一是展示所有解决方案,二是求解方案数量。解题策略主要涉及回溯法,通过判断行、列和对角线上的皇后位置合法性来找到答案。挑战在于不使用递归实现。

33. N皇后问题

n皇后问题是将n个皇后放置在n*n的棋盘上,皇后彼此之间不能相互攻击。

给定一个整数n,返回所有不同的n皇后问题的解决方案。

每个解决方案包含一个明确的n皇后放置布局,其中“Q”和“.”分别表示一个女王和一个空位置。

例1:

输入:1
输出:
   [["Q"]]

例2:

输入:4
输出:
[
  // Solution 1
  [".Q..",
   "...Q",
   "Q...",
   "..Q."
  ],
  // Solution 2
  ["..Q.",
   "Q...",
   "...Q",
   ".Q.."
  ]
]

挑战

你能否不使用递归完成?

解题思路:

在n*n的矩阵中,n个皇后分别在0~n-1行,也就是说,第i个皇后在第i行是固定的,但是在第多少列?用到回溯法进行解决。

对第i个皇后,依次考虑0 - n-1列的位置是否合法,若在第k列的位置合法,则再考虑下一个皇后的位置。当i==n的时候并且起位置合法,则保存路径上的各个皇后位置。

如何判断其位置是合法的?

1.暴力,定义矩阵,对新来的点看是否有和它在相同的行,列,对角线

2.定义一个保存所在列的矩阵colVals,其下标就是所在的行,colVals[i]的值就是所在的列值。

显然 不会相同了,只需再考虑列,对角线<正对角线,负对角线>

列值相同:colVals[i] = colVals[row]  ->也就是在相同的列

对角线的时候,可以发现这样的规律:|row - i| = |colVals[row] - colVals[i]| 这里要考虑绝对值,有两种情况的。

其他情况都是合法的。

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        vector<vector<string> > result;
        if( n <= 0 )
        {
            return result;
        }
        vector<int> cols;
        search(n, cols,result);
        return result;
    }
    
    void search(int n, vector<int> &cols,vector<vector<string>> &result)
    {
        if(cols.size() == n)
        {
            result.push_back(drawResult(cols, n));
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(!isValid(i,cols))
            {
                continue;
            }
            cols.push_back(i);
            search(n,cols,result);
            cols.pop_back();
        }
        
    }
    bool isValid(int col,vector<int> &cols)
    {
        int row=cols.size();
        for(int i = 0; i < row; ++i)
        {
        if(cols[i] == col)
            {
                return false;
            }
            if(i - cols[i] == row - col)
            {
                return false;
            }
            if(i + cols[i] == row + col)
            {
                return false;
            }
        }
        return true;
    }
    vector<string> drawResult(vector<int> &cols, int n)
    {
        vector<string> result;
        for(int i = 0; i < cols.size(); ++i)
        {
            string temp(n, '.');
            temp[cols[i]] = 'Q';
            result.push_back(temp);
        }
        return result;
    }   
   
};
class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        vector<vector<string>> result;
        if( n <= 0 )
        {
            return result;
        }
        vector<int> cols(n);
        search(n, 0,cols,result);
        return result;
    }
    void search(int n, int row,vector<int> &cols,vector<vector<string>> &result)
    {
        if(row == n)
        {
            result.push_back(drawResult(cols, n));
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(!isValid(row,i,cols))
            {
                continue;
            }
            cols[row]=i;
            search(n,row+1,cols,result);
        }
        
    }
    bool isValid(int row,int col,vector<int> &cols)
    {
        for(int i = 0; i < row; ++i)
        {
            if(cols[i] == col)
            {
                return false;
            }
            if(i - cols[i] == row - col)
            {
                return false;
            }
            if(i + cols[i] == row + col)
            {
                return false;
            }
        }
        return true;
    }
    vector<string> drawResult(vector<int> &cols, int n)
    {
        vector<string> result;
        for(int i = 0; i < cols.size(); ++i)
        {
            string temp(n, '.');
            temp[cols[i]] = 'Q';
            result.push_back(temp);
        }
        return result;
    } 
};

34. N皇后问题 II

根据n皇后问题,现在返回n皇后不同的解决方案的数量而不是具体的放置布局。

例1:

输入: n=1
输出: 1
解释:
1:
1

例2:

输入: n=4
输出: 2
解释:
1:
0 0 1 0
1 0 0 0
0 0 0 1
0 1 0 0
2:
0 1 0 0 
0 0 0 1
1 0 0 0
0 0 1 0
class Solution {
public:
    int sum;
    bool canPut(int row, int col, vector<int> &cols) {
        for (int i = 0; i < row; i++) {
            if (cols[i] - i == col - row) {
                return false;
            }
            if (cols[i] + i == col + row) {
                return false;
            }
            if (cols[i] == col) {
                return false;
            }
        }
        return true;
    }
    
    void dfs(int n, int k, vector<int> &cols) {
        if (k == n) {
            sum++;
            return;
        }
        
        for (int i = 0; i < n; i++) {
            if (!canPut(k, i, cols)) {
                continue;
            }
            cols[k] = i;
            dfs(n, k + 1, cols);
        }
    }
    
    int totalNQueens(int n) {
        vector<int> cols(n);
        
        sum = 0;
        dfs(n, 0, cols);
        return sum;
    }
};

 

### LintCode 211 字符串置换题思路 LintCode 211 的核心问题是判断两个字符串是否可以通过字符位置的调整而互相转换,即 **字符串置换**。此问题通常涉及以下几个方面: #### 1. 判断条件 要验证两个字符串 `s` 和 `t` 是否可以互换,需满足以下条件之一: - 如果两字符串长度不同,则直接返回 `false`[^1]。 - 若两字符串完全相同,则需要进一步确认是否存在至少一个重复字符,因为只有存在重复字符的情况下才能完成交换而不改变原字符串。 ```python from collections import Counter def canConvert(s, t): if len(s) != len(t): return False # 完全相同的字符串情况处理 if s == t: counter = Counter(s) for char_count in counter.values(): if char_count >= 2: # 存在重复字符即可 return True return False mapping_s_to_t = {} mapping_t_to_s = {} for c1, c2 in zip(s, t): if c1 not in mapping_s_to_t: mapping_s_to_t[c1] = c2 elif mapping_s_to_t[c1] != c2: return False if c2 not in mapping_t_to_s: mapping_t_to_s[c2] = c1 elif mapping_t_to_s[c2] != c1: return False return True ``` 上述代码逻辑如下: - 首先检查两者长度是否一致。 - 对于相等情况下的特殊判定:如果字符串本身无重复字符则无法通过任何置换达成目标状态。 - 构建双向映射关系来确保每次替换的一致性和唯一性。 #### 2. 时间复杂度分析 该方法的时间复杂度主要由字典查找决定,因此整体时间复杂度为 O(n),其中 n 是输入字符串的长度。 --- ### 示例测试用例 以下是几个典型的测试场景及其预期结果: ```python print(canConvert("aab", "baa")) # 输出应为True print(canConvert("abc", "bac")) # 输出应为False print(canConvert("abcdefghijklmnopqrstuvwxyz", "bcadefghijklmnopqrstuvwxyza")) # 输出应为True print(canConvert("abcdefg", "gfedcba")) # 输出应为True ``` 这些例子涵盖了不同的边界状况以及常规情形下程序的表现评估。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值