八皇后

正好练习题有个八皇后，顺便就做了一下，第一种算法只考虑到求一种解，并且思路不是很清晰，用双重循环很难来做求全部解，所以第二种解法就换了一种思路，欢迎拍砖。递归本质上和栈是一致的，不过面对稍微复杂的逻辑，用递归并不是很好写。

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

#define TRUE 1
#define FALSE 0

struct _position{
    int x;
    int y;
};

typedef struct _position position;

#define MAX_SIZE 100
position pos[MAX_SIZE];
int stack_index = 0;

int isEmpty(){
    if(stack_index == 0){
        return TRUE;
    }else{
        return FALSE;
    }
}

void push(position p){
    if(stack_index < MAX_SIZE){
        pos[stack_index++] = p;
    }else{
        printf("stack is full");
    }
}

position pop(){
    if(isEmpty()){
        printf("stack is empty");
        position p = {-1, -1};
        return p;
    }else{
        return pos[--stack_index];
    }
}

position getTop(){
    if(!isEmpty()){
        return pos[stack_index-1];
    }else{
        printf("stack is empty");
        position p = {-1, -1};
        return p;
    }
}


#define QUEEN_SIZE 8
void printQueen();

int condition(position p){
    int i;
    for(i=0; i<stack_index; i++){
        int incline = abs(p.y-pos[i].y);
        int inclinetemp = abs(p.x-pos[i].x);
        if(inclinetemp==incline || pos[i].y==p.y){
            return FALSE;
        }
    }
    return TRUE;
}

int pushed = FALSE;
void arrangeQueen(){
    int i;
    int j = 0;
    for(i=0; i>=0 && i<QUEEN_SIZE; ){
        for(; j<QUEEN_SIZE; j++){
            position node;
            node.x = i;
            node.y = j;
            if(condition(node)){
                push(node);
                pushed = TRUE;
                break;
            }
        }    
        if(j == QUEEN_SIZE && !pushed){
            position p = pop();
            i = p.x;
            j = p.y+1;
        }else{
            j = 0;
            i++;
            pushed = FALSE;
        }    
        
        //printQueen();
    }
}


int queenrule(int x, int y){
    int i;
    for(i=0; i<stack_index; i++){
        int incline = abs(y-pos[i].y);
        int inclinetemp = abs(x-pos[i].x);
        if(inclinetemp==incline || pos[i].y==y){
            return FALSE;
        }
    }
    return TRUE;
}

int nextX = 0;
int nextY = 0;
int hasNext(position p, int start){
    if (p.x==-1 && p.y==-1) {
        return FALSE;
    }
    if(p.x+1 >= QUEEN_SIZE){
        return FALSE;
    }else{
        int j=start;
        for(;j<QUEEN_SIZE; j++){
            if(queenrule(p.x+1, j)){
                nextY = j;
                nextX = p.x+1;
                return TRUE;
            }
        }
        return FALSE;
    }
}

int count = 0;
void makeQueen(){
    position header = {0, 0};
    push(header);
    
    int j = 0;
    int next;
    while((next=hasNext(getTop(), j))||!isEmpty()){
        if(next){
            position p = {nextX, nextY};
            push(p);
            j = 0;
        }else{
            j = pop().y+1;
            if(isEmpty()){
                if(j<QUEEN_SIZE){
                    header.x = 0;
                    header.y = j;
                    push(header);
                    j = 0;
                }else{
                    return;
                }
            }
        }
        
        if(stack_index == QUEEN_SIZE){
            printQueen();
            count++;
        }
    }
}

void printQueen(){
    int i,j;
    for(i=0; i<QUEEN_SIZE; i++){
        for(j=0; j<QUEEN_SIZE; j++){
            if(pos[i].y == j && i<stack_index){
                printf("Q ");
            }else{
                printf("1 ");
            }
        }
        printf("\n");
    }
    printf("\n\n");
}

int main(void){
    /*
     //第一种做法
     arrangeQueen();
     printQueen();
     */
    
    makeQueen();
    
    printf("共有%d种解\n",count);
    return 0;
}