搜索（三）——回溯

一、回溯 和 深度搜索 是什么关系
对于某一个搜索树来说（搜索树是起记录路径和状态判断的作用），回溯和DFS，其主要的区别是，回溯法在求解过程中不保留完整的树结构，而深度优先搜索则记下完整的搜索树。

 

二、递归回溯 和 迭代回溯

 

题目一：在n个数字中，任意找k个数字（k<=n)，打印所有的可能的情况。

#include <iostream>
#include <vector>
using namespace std;

void output(vector<int>& s, int k){
     for(int j=1;j<=k;j++){
         cout<<s[j]<<" ";
     }
     cout<<endl;
}

//递归回溯
// 已经设置 s[1]~s[l-1]，尝试设置 s[l] 
void recurse_traceback(vector<int>& s, int n, int k, int l){
    for(s[l]=s[l-1]+1;s[l]<n;s[l]++){
        if(l==k){
            output(s,k);
        }else{
            recurse_traceback(s,n,k,l+1);
        }
    }
}

//迭代回溯
// 模拟栈的使用 
void iterative_traceback(vector<int>& s, int n, int k, int l){
     s[l]=0;    //s[1]=0;
     while(l){
         while(s[l]<n){  //当前层s[l]已经设置，尝试做下一个动作
             if(l==k){   //到达最底层，打印结果 
                 output(s,k);
                 s[l]+=1;
             } else {    //否则深搜，进入下一层
                 l++;
                 s[l]=s[l-1]+1; 
             }
         }
         l--;    //下面处理完了，跳回上一层
         s[l]++; 
     }
}

int main(){
    int n=6;
    int k=3;
    vector<int> s(n+1,-1); //s=<-1,-1,-1,-1, -1,-1,-1>
    
    recurse_traceback(s,n,k,1);
    cout<<"-------------"<<endl;
    iterative_traceback(s,n,k,1);
    
    
	system("pause");
	return 0;
}        

 

 题目二：子串所有匹配位置
        写一个“非递归”的算法，找出pattern在长串中出现的位置，如输入长串是abcbc而pattern是abc时，要输出（0，1，2）、（0，3，4）、（0，1，4）

public class Test {
	private static void match(char[] pattern, char[] str) {
		int[] pos = new int[pattern.length]; // 默认为0???

		int l = 0;// 层次

		// 先设置第0层的首个值
		pos[l] = 0;

		while (l >= 0) {// 当前层至少在第0层；当第0层发生回溯时，退出

			// 当前层（当前层l已经设置值pos[l]）
			while (pos[l] < str.length) {

				if (l == pattern.length - 1) {// 1. 当前到达叶节点
					if (check(pattern, str, pos) == true)// 仅在叶节点检查
						output(pos);

					pos[l]++;// 当前层设置为下一个值（不一定有效）

				} else { // 2. 当前未到叶节点

					l++;// 进入下一层

					pos[l] = pos[l - 1] + 1;// 设置下一层为它的首个可能值
				}
			}

			l--;// 回溯到上一层

			if (l >= 0)// 上一层取它的下一个可能值
				pos[l]++;
		}
	}

	private static boolean check(char[] pattern, char[] str, int[] pos) {
		boolean flag = true;

		for (int i = 0; i < pattern.length; i++) {
			if (pattern[i] != str[pos[i]]) {
				flag = false;
				break;
			}
		}

		return flag;
	}

	private static void output(int[] pos) {
		for (int i = 0; i < pos.length; i++) {
			System.out.print(pos[i] + "\t");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		char[] p = { 'a', 'b', 'c' };
		char[] s = { 'a', 'b', 'c', 'b', 'c' };
		match(p, s);
	}

}