回溯法的基本做法是搜尋，或是一種組織得井井有條的，能避免不必要搜尋的窮舉式搜尋法。這種方法適用於解一些組合數相當大的問題。

回溯法在問題的解空間樹中，按深度優先策略，從根結點出發搜尋解空間樹。演算法搜尋至解空間樹的任意一點時，先判斷該結點是否包含問題的解。如果肯定不包含，則跳過對該結點為根的子樹的搜尋，逐層向其祖先結點回溯；否則，進入該子樹，繼續按深度優先策略搜尋。

回溯法指導思想——走不通，就掉頭。設計過程：確定問題的解空間；確定結點的擴充套件規則；搜尋。

n皇后問題

要在n*n的國際象棋棋盤中放n個皇后，使任意兩個皇后都不能互相吃掉。規則：皇后能吃掉同一行、同一列、同一對角線的任意棋子。求所有的解。n=8是就是著名的八皇后問題了。

設八個皇后為xi，分別在第i行(i=1，2，3，4……，8)；

問題的解狀態：可以用(1,x1)，(2,x2)，……，(8,x8)表示8個皇后的位置；

由於行號固定，可簡單記為：(x1,x2,x3,x4,x5,x6,x7,x8)；

問題的解空間：(x1,x2,x3,x4,x5,x6,x7,x8)，1≤xi≤8(i=1，2，3，4……，8)，共88個狀態；

約束條件：八個(1,x1),(2,x2) ,(3,x3),(4,x4) ,(5,x5), (6,x6) , (7,x7), (8,x8)不在同一行、同一列和同一對角線上。

盲目的列舉演算法：通過8重迴圈模擬搜尋空間中的88個狀態，從中找出滿足約束條件的“答案狀態”。程式如下：

/*
 *說明：八皇后——盲目迭代法
 *日期：2013-12-18
 */
#include <iostream>
using namespace std;
bool check_1(int a[],int n)
{
for(int i=2;i<=n;i++)
{
    for(int j=1;j<=i-1;j++)
    {
        if ((a[i]==a[j])||(abs(a[i]-a[j])==i-j))
        {
            return false;
        }
    }
}
return true;//不衝突
}

void queens_1()
{
    int a[9];
    int count = 0;
    for(a[1]=1;a[1]<=8;a[1]++)
    {
        for(a[2]=1;a[2]<=8;a[2]++)
        {
            for(a[3]=1;a[3]<=8;a[3]++)
            {
                for(a[4]=1;a[4]<=8;a[4]++)
                {
                    for(a[5]=1;a[5]<=8;a[5]++)
                    {
                        for(a[6]=1;a[6]<=8;a[6]++)
                        {
                            for(a[7]=1;a[7]<=8;a[7]++)
                            {
                                for(a[8]=1;a[8]<=8;a[8]++)
                                {
                                    if(!check_1(a,8))   
                                        continue;
                                    else
                                    {
                                        for(int i=1;i<=8;i++)  
                                        {
                                            cout<<a[i];
                                        }
                                        cout<<endl;
                                        count++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

        }
    }
    cout<<count<<endl;
}

void main()
{
    queens_1();
}
 

程式思想比較簡單，最後可知共92種擺放方法。如果能夠排除那些沒有前途的狀態，會節約時間——回溯法（走不通，就回頭）。

bool check_2 (int a[ ],int n)
{//多次被呼叫，只需一重迴圈 
    for(int i=1;i<=n-1;i++)
    {
        if((abs(a[i]-a[n])==n-i)||(a[i]==a[n]))
            return false;
    }      
    return true;
}

void queens_2()
{
    int a[9];
    int count = 0;
    for(a[1]=1;a[1]<=8;a[1]++)
    {
        for(a[2]=1;a[2]<=8;a[2]++)
        {
            if (!check_2(a,2))  continue;
            for(a[3]=1;a[3]<=8;a[3]++)
            {
                if (!check_2(a,3))  continue;
                for(a[4]=1;a[4]<=8;a[4]++)
                {
                    if (!check_2(a,4))  continue;
                    for(a[5]=1;a[5]<=8;a[5]++)
                    {
                        if (!check_2(a,5))  continue;
                        for(a[6]=1;a[6]<=8;a[6]++)
                        {
                            if (!check_2(a,6))  continue;
                            for(a[7]=1;a[7]<=8;a[7]++)
                            {
                                if (!check_2(a,7))  continue;
                                for(a[8]=1;a[8]<=8;a[8]++)
                                {
                                    if (!check_2(a,8))  
                                        continue;
                                    else
                                    {
                                        for(int i=1;i<=8;i++)  
                                        {
                                            cout<<a[i];
                                        }
                                        cout<<endl;
                                        count++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

        }
    }
    cout<<count<<endl;
}

void main()
{
    queens_2();
}

n此演算法可讀性很好，體現了“回溯”。但它只針對八皇后問題，解決任意的n皇后問題還要修改程式結構。如果要解決n皇后的問題，就需要將n作為引數傳遞給函式，函式需要重寫來實現回溯（不能採用級聯的for迴圈，n不確定）；從另一方面，程式中出現了大量的for迴圈，而且for中的函式結構很相似，自然想到的是遞迴迭代回溯。這就是回溯比較常用的兩種實現方法：非遞歸回溯和遞歸回溯。

非遞歸回溯的程式實現：

void backdate (int n)
{  
    int count = 0;
    int a[100];

    int k = 1;
    a[1]=0;   
    while(k>0)
    {
        a[k]=a[k]+1;//對應for迴圈的1~n
        while((a[k]<=n)&&(!check_2(a,k)))//搜尋第k個皇后位置
        {
            a[k]=a[k]+1;
        }
          
        if(a[k]<=n)//找到了合理的位置
        {
            if(k==n )
            {//找到一組解
                for(int i=1;i<=8;i++)  
                {
                    cout<<a[i];
                }
                cout<<endl;
                count++;
            } 
            else 
            {
                k=k+1;//繼續為第k+1個皇后找到位置，對應下一級for迴圈 
                a[k]=0;//下一個皇后一定要從頭開始搜尋
            }
        }
        else
        {
            k=k-1;//回溯,對應執行外內層for迴圈回到更上層 
        }
    }
    cout<<count<<endl;
}

void main()
{
    backdate(8);
}

這樣也可以得到，8皇后問題的92中結果。更簡單、可讀的方法是採用遞迴的方式，如下：

int a[100], n, count;
void backtrack(int k)
{
    if (k>n)//找到解
    {
        for(int i=1;i<=8;i++)  
        {
            cout<<a[i];
        }
        cout<<endl;
        count++;
    }
    else
    {
        for (int i = 1;i <=n; i++)
        {
            a[k] = i;
            if (check_2(a,k) == 1)
            {backtrack(k+1);}
        }
    }
    
}

void main()
{
    n=8,count=0;
    backtrack(1);
    cout<<count<<endl;
}

可見，遞迴呼叫大大減少了程式碼量，也增加了程式的可讀性。給出其中的一個解，如下：