回溯搜索的非递归思路及实例源码（原创）

摘要：本文简要描述了回溯算法的基本思路，并给出了几个典型实例的源码

关键字：回溯，搜索，非递归，全排列，组合，N皇后，整数划分，0/1背包

回溯是按照某种条件在解空间中往前试探搜索,若前进中遭到失败,则回过头来另择通路继续搜索。

符号声明：

解空间：[a1,a2,a3,…,an];

x[k]为解空间元素的索引， 0 <= x[k] < n;k为数组x的索引；

a[x[0~n-1]]表示一组解。

//判断解空间中的a[x[k]]是否满足条件

bool CanbeUsed(int k)

{

    if(x[k] 不满足条件) return false;

    else return true;

}

算法描述如下：

(1)k = 0; x[k] = -1;

(2)while( k >= 0 )

    a. x[k] = x[k] + 1;

    b. while(x[k] < n && ( ! CanbeUsed(k) ))//遍历解空间，直到找到可用的元素

           x[k] = x[k] + 1;

    c. if(x[k] > n -1)//x[k]超出了解空间a的索引范围

           k = k - 1; //回溯

    d. else if( k == n -1)//找到了n - 1个元素

          输出一组解

    e. else     //当前元素可用，更新变量准备寻找下一个元素

          k = k + 1;

          x[k] = -1;

回溯的这种实现方式非常适合于在解空间中搜索特定长度的序列！

实例源码：

1.回溯之全排列(VC6.0/VS2005)==============================================

////////////////////////////////
//回溯搜索之全排列
#include
#include
using namespace std;
#define N 100
string str;
int x[N];

bool IsPlaced(int n)
{
    for(int i = 0; i < n ; ++i)
    {
        if(x[i] == x[n])
            return false;
    }
    return true;
}

void PrintResult()
{
    for(int i = 0; i < str.length(); ++i)
        cout<= 0)
    {
        x[k] = x[k] + 1;
        while(x[k] < str.length() && !IsPlaced(k))
        {
            x[k] = x[k] + 1;
        }

        if(x[k] > str.length() - 1)
        {
            k = k - 1;
        }
        else if( k == str.length() - 1)
        {
            PrintResult();
        }
        else

        {
            k = k + 1;
            x[k] = -1;

        }

    }
}


int main()
{
    cout<<"input:"<>str)
    {
        cout<< str << " arrange......" << endl;
        Arrange();
        cout << "input:" << endl;
    }
    return 0;
}

2.八皇后(N皇后)============================================================

////////////////////////////////////////
//回溯之N皇后问题[ 4<=N<=100]

#include 
using namespace std;


#define N 8

//用于防置皇后的棋盘
//0表示未放置，1表示已放置
int board[N][N]={
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0
};

int x[N];

//按列摆放
bool CanbePlaced(int k)
{
    for(int i = 0; i < k ; ++i)
    {
        if(x[i] == x[k] || abs(x[i] - x[k]) == abs(i - k))
            return false;
    }
    return true;

}
void PrintResult()
{
    for(int i = 0; i < N; ++i)
        for(int j = 0; j < N; ++j)
            board[i][j] = 0;
    for(int i = 0; i < N; ++i)
        board[i][x[i]] = 1;
    for(int i = 0; i < N; ++i)
    {
        for(int j = 0; j < N; ++j)
        {
            if(board[i][j] == 1)
                cout<<"* ";
            else
                cout<<"- ";
        }
        cout<= 0 )
    {
        x[k] = x[k] + 1;
        while(x[k] < N && !CanbePlaced(k))
            x[k] = x[k] + 1;
        if(x[k] > N - 1)
        {
            k = k - 1;
        }
        else if( k == N - 1)
        {
            PrintResult();
            count ++;
        }
        else
        {
            k = k + 1;
            x[k] = - 1;
        }
    }
}
int main()
{
    NQ();
    cout << "一共:" << count << "组摆放方法" << endl;
    system("pause");
    return 0;
}