N皇后問題要求求解在N*N的棋盤上放置N個皇后，並使各皇后彼此不受攻擊的可能的棋盤佈局，皇后彼此不受攻擊的所有可能的佈局，皇后彼此不受攻擊的約束條件是：任何兩個皇后均不能在棋盤同一行、同一列或者在對角線上出現。

由於N皇后問題不允許兩個皇后在同一行，所以，可用一維陣列X表示N皇后問題的解，X[i]表示第i行的皇后所在的列，條件表述如下:

• X[i] = X[s]，則第i行和第s行皇后在同一列上
• 如果第i行的皇后在第j列，第s行的皇后在第t列，即X[i] = j 和 X[s] = t，則只要i - j = s- t 或者 i + j = s + t，說明兩個皇后在對角線上，對兩個等式進行變換後，得到結論，只要|i- s| = |j - t|（即|i- s| = |x[i] - x[s]|），則皇后在同一對角線上

解N皇后問題需要遍歷解空間樹，遍歷中要隨時判定當前棋盤佈局是否滿足要求，符合要求則繼續向下遍歷，直至判斷得到一個滿足約束條件的葉子結點，從而獲得一個滿足要求的棋盤佈局，不符合要求的結點將被捨棄（稱之為剪枝），並回溯到上一層的結點繼續遍歷，當整棵樹遍歷結束時，已獲得所有滿足要求的棋盤佈局

上面的就是高度為3的解空間樹，樹的每一層與棋盤的每一行是對應的，首先選擇第一行的皇后的位置的時候，是有三個選擇的，而這三個選擇都是不發生衝突的，因為此時棋盤上還沒有任何皇后，當選擇第二行的皇后的位置時，對於以上一次選擇的為根的子樹而言，只有兩種選擇，而此時就需要判斷是否與之前的選擇有衝突，如果有衝突的話就需要剪枝（就是說這種方法不符合要求，不必再繼續往下嘗試了），按照這種方法直至找到滿足題意的結果進行輸出。

皇后位置滿足約束條件的判定如下：

int place(int s) {
    int i = 1;
    for(; i < s; i++) {
        if(abs(i-s) == abs(X[i]-X[s]) || X[i] == X[s]) {
            return false;
        }
    }

    return true;
} 

回溯演算法：

void Trial(int i, int n) {
    int j, k;
    if(i > n) {
        //輸出 
        for(k = 1
 
; k <= n; k++) {
            printf("%d ", X[k]);
        }
        printf("\n");
    } else {
        for(j = 1; j <= n; j++) {
            X[i] = j;
            if(place(i)) {
                Trial(i+1, n);
            }
        }
    } 
}

完整程式碼：

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

#define true 1
#define false 0

void Trial(int i, int n, int *X);
int place(int s, int *X);

int place(int s, int *X) {
    int i = 1;
    for(; i < s; i++) {
        if(abs(i-s) == abs(X[i]-X[s]) || X[i] == X[s]) {
            return false;
        }
    }

    return true;
} 
void Trial(int i, int n, int *X) {
    int j, k;
    if(i > n) {   //輸出 
        for(k = 1; k <= n; k++) {
            printf("%d ", X[k]);
        }
        printf(" \n");
    } else {
        for(j = 1; j <= n; j++) {
            X[i] = j;
            if(place(i, X)) {
                Trial(i+1, n, X);
            }
        }
    } 
}


void main(void) {
    int n;
    int *Queen = NULL;
    printf("請輸入皇后的個數.\n");
    scanf("%d", &n);
    Queen = (int *)malloc(sizeof(int) * (n+1));
    Trial(1, n, Queen); 
} 

執行結果：