2. 程式人生 > >關於回溯演算法的遞迴與非遞迴解法

關於回溯演算法的遞迴與非遞迴解法

阿新 • • 發佈：2018-12-30

摘要：本文簡要描述了回溯演算法的基本思路，並給出了幾個典型例項的原始碼

關鍵字：回溯，搜尋，非遞迴，全排列，組合，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<iostream>
#include<string>
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<<str[x[i]];
cout<<endl;
}
void Arrange()
{
int k = 0; x[k] = -1;

while(k >= 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:"<<endl;
while(cin>>str)
{
   cout<<str<<" arrange......"<<endl;
   Arrange();
   cout<<"input:"<<endl;
}
return 0;
}

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

////////////////////////////////////////
//回溯之N皇后問題[ 4<=N<=100]

#include <iostream>
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<<endl;
}
cout<<endl;
}
int count = 0;
void NQ()
{
int k = 0;
x[k] = -1;
while( k >= 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;
}

3.回溯之整數劃分==========================================================

/////////////////////////
//回溯之整數劃分

#include<iostream>
using namespace std;

#define N 100

int x[N];

int result[N];//儲存一組解
int count = 0;//解的組數

int sum(int k)
{
int sum = 0;
for(int i = 0; i <= k; ++i)
   sum += result[x[i]];
return sum;
}
//a1>=a2>=...>=an
//a1+a2+...+an = n
bool IsSuit(int n,int k)
{
if(sum(k) > n)
   return false;
if(k > 0 && result[x[k]] > result[x[k-1]] )
   return false;
return true;
}

void PrintResult(int n,int k)
{
if(sum(k) == n)
{
   for(int i = 0; i <= k; ++i)
     cout<<result[x[i]]<<" ";
   cout<<endl;
   count++;
}
}
void SplitInt(int n)
{
//解空間[n,n-1,n-2,...,1]
    for(int i = 0; i < n; ++i)
{
   result[i] = n - i;
}

    for(int m = 1; m <= n; ++m)
{
   int k = 0;
   x[k] = -1;
   while( k >= 0 )
   {
    x[k] = x[k] + 1;
    while(x[k] < n && !IsSuit(n,k) )
     x[k] = x[k] + 1;
    if(x[k] > n - 1)
     k = k - 1;
    else if( k == m - 1)
    {
     PrintResult(n,k);
    }
    else
    {
     k = k + 1;
     x[k] = -1;
    }
   }
}
}
int main()
{
int num;
while(cin>>num)
{
   count = 0;
   SplitInt(num);
   cout<<"共:"<<count<<"組"<<endl;
}
return 0;
}

4.回溯之組合===============================================================

/////////////////////////////////////////
//回溯之組合
//找出所有從m個元素中選取n(n<=m)元素的組合

#include<iostream>
using namespace std;

#define M 5
#define N 3
char elements[M]={'a','b','c','d','e'};

int x[N];

bool CanbeUsed(int k)
{
for(int i = 0; i < k; ++i)
   if(x[i] == x[k])
    return false;
if(k > 0 && elements[x[k]] < elements[x[k-1]])
{
   return false;
}
return true;
}

void PrintResult()
{
for(int i = 0; i < N; ++i)
{

    cout<<elements[x[i]]<< " ";
}
cout<<endl;
}

void Compose()
{
int k = 0;
x[k] = -1;
while( k >= 0 )
{
   x[k] = x[k] + 1;
   while(x[k] < M && !CanbeUsed(k))
    x[k] = x[k] + 1;
   if(x[k] > M - 1)
    k = k - 1;
   else if( k == N - 1)
   {
    PrintResult();
   }
   else
   {
    k = k + 1;
    x[k] = -1;
   }
}
}
int main()
{
Compose();
system("pause");
return 0;
}

5.回溯之0/1揹包=============================================================

//////////////////////////////////////////////////
//回溯之0/1揹包問題
//.0/1揹包
//一個旅行者有一個最多能用m公斤的揹包，現在有n件物品，它們的重量分別是W1，W2，...,Wn,它們的價值分別為C1,C2,...,Cn.
//若每種物品只有一件求旅行者能獲得最大總價值。
#include<iostream>
using namespace std;

#define M 50
#define N 5
int weight[N] = {10,15,12,19,18};
int value[N] = {5,2,2,1,1};

int x[N]={-1,-1,-1,-1,-1};

int max_weight = 0;
int max_value = 0;

bool CanbeUsed(int k)
{
for(int i = 0; i < k ; ++i)
{
   if(x[i] == x[k] )
    return false;
}

return true;
}

void CalResult(int k)
{
int totalValue = 0;
int totalWeight= 0;
for(int i = 0 ; i <= k; ++i)
{
   totalValue += value[x[i]];
   totalWeight += weight[x[i]];
}

if(totalValue > max_value && totalWeight <= M )
{
   max_value = totalValue;
   max_weight = totalWeight;
   cout<< totalWeight << " "<<totalValue<<endl;
}

}

void Bag()
{

//分別計算去1~N個物品的情況
for(int n = 1; n <= N; ++n)
{
   int k = 0;
   x[k] = -1;
   while( k >= 0)
   {
    x[k] = x[k] + 1;
    while(x[k] < n && !CanbeUsed(k))
     x[k] = x[k] + 1;

    if(x[k] > n - 1)
    {
     k = k - 1;
    }
    else if( k == n - 1)
    {
     CalResult(k);
    }
    else
    {
     k = k + 1;
     x[k] = -1;
    }
   }
}
}

int main()
{
Bag();
cout<<"最優解為weight:" << max_weight << ",value:" <<max_value<<endl;
system("pause");
return 0;
}

八皇后問題是一個古老而著名的問題，是回溯演算法的典型例題。該問題是19世紀著名的數學家高斯1850年提出：在8×8格的國際象棋盤上擺放8個皇后，使其不能互相攻擊，即任意兩個皇后都不能處於同一行、同一列或同一斜線上，問有多少種擺法。[英國某著名計算機圖形影象公司面試題]
解析：遞迴實現n皇后問題。
演算法分析：
陣列a、b、c分別用來標記衝突，a陣列代表列衝突，從a[0]~a[7]代表第0列到第7列。如果某列上已經有皇后，則為1，否則為0。
陣列b代表主對角線衝突，為b[i-j+7]，即從b[0]~b[14]。如果某條主對角線上已經有皇后，則為1，否則為0。
陣列c代表從對角線衝突，為c[i+j]，即從c[0]~c[14]。如果某條從對角線上已經有皇后，則為1，否則為0。

C++程式碼如下:
/* 實現N皇后問題*/
#include <stdio.h>

#define QUEENNUM 8
#define QCROSSNUM (QUEENNUM*2-1)

static char QueenArray[QUEENNUM][QUEENNUM];
static int a[QUEENNUM];
static int b[QCROSSNUM];
static int c[QCROSSNUM];

static int iQueenNum=0;//記錄皇后問題總共有多少中擺法

void Queen(int i);//i為行數

int main()
{
int iLine,iColumn;

for (iLine=0;iLine<QUEENNUM;iLine++)
{
   a[iLine]=0;
   for(iColumn=0;iColumn<QUEENNUM;iColumn++)
    QueenArray[iLine][iColumn]='*';
}

for(iLine=0;iLine<QCROSSNUM;iLine++)
   b[iLine] = c[iLine]=0;

Queen(0);

return 0;
}

void Queen(int i)
{
int iColumn;
for(iColumn=0;iColumn<QUEENNUM;iColumn++)
{
   if(a[iColumn]==0&&b[i-iColumn+7]==0&&c[i+iColumn]==0)
   {
    QueenArray[i][iColumn]='@';//皇后標誌
    a[iColumn]=1;
    b[i-iColumn+7]=1;
    c[i+iColumn]=1;
    if (i<(QUEENNUM-1))
     Queen(i+1);
    else
    {
     int iLine,iColumn;
     printf("The %d th state is :/n ",++iQueenNum);
     for(iLine=0;iLine<QUEENNUM;iLine++)
     {

       for(iColumn=0;iColumn<QUEENNUM;iColumn++)
        printf("%c",QueenArray[iLine][iColumn]);
       printf("/n");
    
     }
     printf("/n/n");
    }
     //後面無論如何也無法放置皇后，則回溯重置
    QueenArray[i][iColumn]='*';
    a[iColumn]=0;
    b[i-iColumn+7]=0;
    c[i+iColumn]=0;
   }
}
}

    這段程式碼與一般的N!之類的遞迴大不相同, 以往都是從大到小的基本遞迴，如N!、打靶等等。這些方法都是採用巢狀方法, 中間沒有迴圈，沒有回溯的出現。八皇后問題顯然不同,中間不但有迴圈,而且還有很嚴謹的回溯。切入點也不同,是設定行數.
    程式中，改變QUEENNUM的數值，就能得到N皇后的擺法。遞迴結束後的處理,包括清理本行的皇后,以及相關資料，即列的皇后資訊清除、主從對角線的標誌設定0。回溯法中，回溯後資料清理是有一定深度和難度的。學習的好方法就是多寫寫採用回溯法的遞迴演算法，多嘗試用回溯的方法做一些資料清理工作。

    遞迴演算法步驟:
    1.方法的選定，基本遞迴、分治法、動態規劃和回溯法的選擇哪種？
    2.考慮不滿足什麼樣的條件遞迴結束？
    3.考慮滿足條件，並且最後一次呼叫遞迴，如何處理？
    4.考慮中間的滿足條件狀態如何處理？如遞迴函式要傳入什麼引數，處理哪些資料？呼叫遞迴函式後，要清理哪些資料，得到的資料如何處理？


基本遞迴法：

一個打靶問題的程式碼如下：
/*10槍打中90環的有多少種可能 ---- by zhaquanmin*/
#include <stdio.h>

long int sum = 0;
int storeArray[10];

void Comput(int score,int num)
{
if(score<0 || score>(num+1)*10)
   return ;
if (num==0)
{
   storeArray[num]=score;
   for(int i=0;i<10;i++)
     printf("%d "storeArray[i]);
   printf("/n");
   ++sum;
   return ;
}
for(int i=0;i<=10;++i)
{
   storeArray[num]=i;
   Comput(score-i,num-1);
}
}
int main()
{

Comput(90,9);
cout<<"sum="<<sum<<endl;
return 0;
}

相關推薦

關於回溯演算法的遞迴與非遞迴解法

摘要：本文簡要描述了回溯演算法的基本思路，並給出了幾個典型例項的原始碼 關鍵字：回溯，搜尋，非遞迴，全排列，組合，N皇后，整數劃分，0/1揹包 回溯是按照某種條件在解空間中往前試探搜尋,若前進中遭到失敗,則回過頭來另擇通路繼續搜尋。 符號宣告： 解空間：[a1,a2,a3,.

[計算機程式設計C++] Fibonaci數列的遞迴與非遞迴演算法實現

本文是對西安交通大學C++慕課第三章程式設計練習的16題的講解。 參考部落格：https://blog.csdn.net/zombie_slicer/article/details/38871799 題目內容： 編寫程式，顯示Fibonaci序列的前n項（從

樹的前、中、後序遍歷演算法（遞迴與非遞迴）、層序遍歷

二叉樹層次遍歷 非遞迴 void LevelOrder(Tree* T) { if(T == nullptr) return ; queue<Tree *> myqueue; myqueue.push(T); while(!myqueu

揹包問題的遞迴與非遞迴演算法

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

排序演算法6——圖解歸併排序及其遞迴與非遞迴實現

排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非

二叉樹後序遍歷（遞迴與非遞迴）演算法及C語言實現

二叉樹後序遍歷的實現思想是：從根節點出發，依次遍歷各節點的左右子樹，直到當前節點左右子樹遍歷完成後，才訪問該節點元素。 圖 1 二叉樹   如圖 1 中，對此二叉樹進行後序遍歷的操作過程為： 從根節點 1 開始，遍歷該節點的左子樹（以節點 2 為根節點）； 遍歷節點 2 的左子樹（以節點 4 為根

Java排序演算法(三)--歸併排序（MergeSort）遞迴與非遞迴的實現

歸併有遞迴和非遞迴兩種。 歸併的思想是： 1.將原陣列首先進行兩個元素為一組的排序，然後合併為四個一組，八個一組，直至合併整個陣列； 2.合併兩個子陣列的時候，需要藉助一個臨時陣列，用來存放當前的

二分查詢演算法（遞迴與非遞迴兩種方式）

首先說說二分查詢法。 二分查詢法是對一組有序的數字中進行查詢，傳遞相應的資料，進行比較查詢到與原資料相同的資料，查詢到了返回對應的陣列下標，沒有找到返回-1； 如下示例，其中有序陣列中, 是按照從小到

建立有向圖的鄰接表，深度優先遍歷和廣度優先遍歷的遞迴與非遞迴演算法，判斷是否是有向無環圖，並輸出一種拓撲序列

/*（1）輸入一組頂點，建立有向圖的鄰接表,進行DFS（深度優先遍歷）和BFS（廣度優先遍歷）。 寫出深度優先遍歷的遞迴和非遞迴演算法。 （2）根據建立的有向圖，判斷該圖是否是有向無環圖，若是，則輸出其一種拓撲有序序列。*/ #include<stdio.h>

圖的深度優先遍歷(遞迴與非遞迴演算法)和廣度優先遍歷

老師的題目：： 實驗內容 已知某地區的公路網以圖表示，圖中的頂點表示站點，任意兩站點間的路段以帶權的邊構成的鄰接矩陣表示，矩陣中非零元表示兩個站點間存在直接的路段，否則沒有路段。 開啟E:\Test資料夾中的exp06.cpp檔案，補充編寫所需程式碼。程式首先進行圖的連通性判定，若圖連通則輸出連通訊息，否則

漢諾塔遞迴與非遞迴演算法

1. 基本遞迴演算法： 原文：https://blog.csdn.net/hehe5229/article/details/60874167 #include<stdio.h>   #include<stdlib.h>   int count=0; &

圖的深度優先和廣度優先演算法（DFS遞迴與非遞迴）

本部落格前面文章已對圖有過簡單的介紹，本文主要是重點介紹有關圖的一些具體操作與應用 無向圖——鄰接矩陣的深度優先和廣度優先演算法實現 測試環境：VS2008（C） #include "st

【C++】斐波那契數列前N項的和遞迴與非遞迴演算法

定義：斐波那契數列（Fibonacci sequence），又稱黃金分割數列、因數學家列昂納多·斐波那契以兔子繁殖為例子而引入，故又稱為“兔子數列”，指的是這樣一個數列：0、1、1、2、3、5、8、1

二叉樹的遍歷演算法（遞迴與非遞迴）

        二叉樹的常用遍歷演算法有前序，中序，後序三種遍歷方法，可用遞迴及非遞迴方法實現，程式碼如下： public class BSTTraversal { public static class Node{ private int value; pri

無向圖的鄰接矩陣，深度優先遍歷和廣度優先遍歷的遞迴與非遞迴演算法

/*（1）輸入一組頂點，建立無向圖的鄰接矩陣。 進行DFS（深度優先遍歷）和BFS（廣度優先遍歷）。 寫出深度優先遍歷的遞迴和非遞迴演算法。*/ #include<stdio.h> #define max 40 //最大頂點個數 #define M 10000

二叉樹3種遍歷演算法遞迴與非遞迴實現詳解

一, 二叉樹先序遍歷的實現     遞迴實現 void PreOrderTraverse(BiTree T) { if( T ) { VisitF(T->data);//訪問根節點 PreOrderTra

求{1，2，3}的子集————回溯法(遞迴與非遞迴)

求ar[]={1,2,3}的子集序列，小夥伴們可以先自己嘗試解一下~~ #include<iostream> using namespace std; //用回溯法搜尋子集樹 void fun(int *ar,int *br,int n)//非遞迴

二叉樹前序遍歷的遞迴與非遞迴演算法

       前幾天參加了阿里暑期實習的內推面試，發現自己的資料結構演算法基礎特別薄弱，比如其中一個問題是中序遍歷的遞迴與非遞迴演算法，我平時看資料結構只知道遞迴演算法，非遞迴的演算法直接被問懵逼了，在思考了幾十秒之後想出了用陣列存放每次遍歷節點的父節點，然後用for迴圈遍

遞迴與非遞迴實現走迷宮演算法

●問題描述： 　　給出一個矩陣，其中0表示通路，1表示牆壁，這樣就形成了一個迷宮，要求編寫演算法求出其中一條路徑。 ●遞迴思路： 　　編寫一個走迷宮函式，傳入二位陣列的下標，先假設該點位於最終路徑上（將0置為2）再探測周圍四個點是否可以走通（是否為０），如果可以走通則將該點

快速排序遞迴與非遞迴演算法

快速排序是不穩定的，是對氣泡排序的改進。它的改進之處在於每輪會使一個基數歸位，同時可以使基數兩邊的兩組數基本有序（基數左邊的數都小於基數，基數右邊的數都大於基數）它的平均時間複雜度O(nlogn)，最壞時間複雜度就是退化成氣泡排序O(n^2)思路無論是遞迴還是非遞迴，都需要給