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

#define n 8
bool hash[n+1];
int p[n+1];
int count =0;

//暴力法 无优化
void generate(int index)
{
    if(index == n +1)
    {
        //每当到达边界判断是否可以
        bool flag = true;
        for(int i =1; i <= n; i++)
        {
            for(int j =i+1; j <= n; j++)
            {
                if(abs(i-j) == abs(p[i]-p[j]))
                {
                    flag = false;
                }
            }
        }
        if(flag)
        {
            count++;
        }
        return;
    }
    //生成１～ｎ的排列
    for(int x =1; x <=n; x++)
    {
        if(hash[x] == false)
        {
            p[index] = x;
            hash[x] = true;
            generate(index+1);
            hash[x] = false;
        }
    }
}

/*回朔法　有优化
在到达递归边界前的某层，由于一些事实导致已经不再
需要往任何一个子问题递归，就可以直接返回上一层。*/
void Generatep(int index)
{
    //递归边界，生成一个合法方案
    if(index == n +1)
    {
        count++;
        for(int k = 1; k <= n; k++ )
        {
            printf("%d ",p[k]);
        }
        printf("\n");
        return ;
    }
    //第ｘ行
    for(int x =1; x <=n; x++)
    {
        //第ｘ行还没有皇后
        if(hash[x] == false)
        {
            bool flag = true;//表示当前的皇后不会和之前的皇后冲突
            for(int pre =1; pre < index; pre++)//遍历之前的皇后
            {
                if(abs(index - pre) == abs(x - p[pre]))
                {
                    flag = false;
                    break;
                }
            }
            //如果可以把皇后放在第ｘ行
            if(flag)
            {
                //令第index列的皇后的行号为ｘ
                p[index] = x;
                //表示第ｘ行已被占用
                hash[x] = true;
                //递归处理第index+1　列皇后
                Generatep(index+1);
                //递归完毕后，还原第ｘ行为未占有
                hash[x] = false;
            }
        }
    }
}

int main()
{
    for(int m =0; m <=8; m++)
    {
        hash[m] = false;
    }

    Generatep(1);
    printf("%d\n",count);
    return 0;
}