搜索_LGP1219八皇后

搜索_LGP1219八皇后

题目

题目描述

检查一个如下的6 x 6的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列只有一个，每条对角线(包括两条主对角线的所有平行线)上至多有一个棋子。
列号　 1　 2　 3　 4　 5　 6

1 |　 | O |　 |　 |　 |　 |

2 |　 |　 |　 | O |　 |　 |

3 |　 |　 |　 |　 |　 | O |

4 | O |　 |　 |　 |　 |　 |

5 |　 |　 | O |　 |　 |　 |

6 |　 |　 |　 |　 | O |　 |

上面的布局可以用序列2 4 6 1 3 5来描述，第i个数字表示在第i行的相应位置有一个棋子，如下： 行号 1 2 3 4 5 6 列号 2 4 6 1 3 5 这只是跳棋放置的一个解。
请编一个程序找出所有跳棋放置的解。并把它们以上面的序列方法输出。解按字典顺序排列。请输出前3个解。最后一行是解的总个数。
特别注意: 对于更大的N(棋盘大小N x N)你的程序应当改进得更有效。不要事先计算出所有解然后只输出

输入格式

一个数字N (6 <= N <= 13) 表示棋盘是N x N大小的。

输出格式

前三行为前三个解，每个解的两个数字之间用一个空格隔开。第四行只有一个数字，表示解的总数。

样例输入

6

样例输出

2 4 6 1 3 5
3 6 2 5 1 4
4 1 5 2 6 3
4

解题

2019-07-20 17:16:54

解题思路

1. 常规的搜索题的思路:找规则,按照规则搜索答案
   本题和之前的一道"棋盘"的题目很像,搜索思路和它是一样的.只是与之相比本体多了斜线上不能有棋子的要求
2. 要善于观察规律.可以发现,本题搜索出的答案是对称的.从上下左右四个方向看去答案是一样的,也就是说对于同一种情况,有四种答案.从而就没必要担心输出的这个问题.只要在你选的方向上搜索是从小到大进行的, 那么直接从你选定的方向按顺序输出就可以了.
3. 对于负数的处理:可以加上一个够大的常数使之成为整数(但要确保唯一性)

一种处理的不是很好的代码如下:

这段代码的缺点就在于
在输出时没有使用对称的思想

1. 是通过建立一个结构体Ans和一个优先队列pq
2. 自定义比较和排序规律
3. 输出队列的前三个答案

#include <iostream>
#include <stack>
#include <map>
#include <queue>
#include <string>
using namespace std;
int map_rank[100], map_ita[100];
int map_rita[200];
int n;
typedef long long ll;

int G[20][20];
int ans[100][100];
struct Ans{
    int arr[50];
    friend bool operator>(Ans a1, Ans a2)
    {
        int i = 1;
        while(a1.arr[i] == a2.arr[i]) i++;
        return a1.arr[i] > a2.arr[i];
    }
};
priority_queue<Ans, vector<Ans>,greater<Ans> >pq;
bool isOk(int x, int y)
{
    if(map_rank[y]) return false;
    if(map_ita[x + y])return false;
    if(map_rita[x - y + 50]) return false;
    return true;
}
void resolve(int x, int y)
{
    map_rita[x - y + 50] = map_ita[x + y]=map_rank[y] = 0;
    G[y][x] = 0;
}
void solve(int x, int y)
{
    map_rita[x - y + 50] = map_ita[x + y]=map_rank[y] = 1;

}
int N;
void dfs(int x, int y)
{
    G[y][x] = 1;
    if(x == n)
    {
        N++;
        Ans t;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(G[i][j]) {
                    t.arr[i] = j;
                }
            }
        }
        pq.push(t);
        return;
    }
    solve(x, y);
    for(int i = 1; i <= n; i++)
    {
        if(!isOk(x + 1, i))continue;
        dfs(x + 1, i);
        resolve(x + 1, i);
    }
}

int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        G[i][1] = 1;
        if(!isOk(2, i))continue;
        solve(1, i);
        dfs(1, i);
        resolve(1, i);
    }
   int ans2 = pq.size();
    for(int i = 1; i <= 3; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            cout << pq.top().arr[j] << " ";
        }
        cout << endl;
        pq.pop();
    }
    cout << ans2 << endl;
    return 0;
}