回溯的那些个算法

最近看算法，那些个回溯算法，总结起来可以一句话：撞了南墙就回头，回到撞墙以前的状态，总能找到路到罗马。既然到了罗马，我就知道来时的路。有点像《源代码》的情节，男主一死就往回，起死回生，再来一次，最后顺利找出凶手。

经典的回溯比如八皇后，二叉树求和的路径，数组的全排列，问题就不描述了，代码粘贴下，留个念想。

八皇后

#include 
#include 
#define N 8
 int column[N+1];
 int rup[2*N+1];
 int lup[2*N+1];
 int queen[N+1]={0};
 int num;
 void backtrack(int);
 int main()
 {
     int i;
     num=0;
     for(i=1;i<=N;i++)
     column[i]=1;
    
     for(i=1;i<=2*N;i++)
     rup[i]=lup[i]=1;
     backtrack(1);
 system("pause");
 return 0;   
 }
 void backtrack(int i)
 {
   int j,x,y;
   if(i>N)
   {
     printf("\n解答%d\n",++num);
     for(y=1;y<=N;y++)
     {
        for(x=1;x<=N;x++)
        if(queen[y]==x)
           printf("Q");
           else
           printf(".");
        printf("\n");
     }
   }else
   {
      for(j = 1; j <= N; j++) {
            if(column[j] == 1 && rup[i+j] == 1 && lup[i-j+N] == 1) {
                queen[i] = j;
                column[j] = rup[i+j] = lup[i-j+N] = 0; // 
                backtrack(i+1);
                column[j] = rup[i+j] = lup[i-j+N] = 1;
            }
        }
 
   }
    
 }

二叉树求和

#include
#include
#include 

using namespace std;
static int sum(0);
static int count(0);

template
struct BiNode
{
	T data;
	struct BiNode *rchild,*lchild;
};

template
class BiTree
{
public:
	BiTree(){
		cout<<"int root node"<*> sta;
		return FindPath(i, root, sta);
	};

private:
	BiNode *root;
	void Create(BiNode* &bt);
	void Release(BiNode *bt);
	int Depth(BiNode* bt);
	int FindPath(T i, BiNode* bt, stack*> &sta);
};

template 
void BiTree::Release(BiNode *bt) 
{
	
	if(bt==NULL)
	{
		Release(bt->lchild );
		Release(bt->rchild );
		delete bt;
	}
}

//先序遍历构建树 
template 
void BiTree::Create(BiNode* &bt) 
{
	T ch;
    cin>>ch;
    if(ch== 0)bt=NULL;
    else
    {
	    bt=new BiNode;
	    bt->data =ch;
	    cout<<"left child"<lchild );
	    cout<<"right child"<rchild );
    }
}


template 
int BiTree::Depth(BiNode* bt)
{
	if (NULL == bt)
	{
		return 0;
	}
	int d1 = Depth(bt->lchild);
	int d2 = Depth(bt->rchild);
	return (d1 > d2 ? d1 : d2)+ 1;
}

//采用回溯法查找路径 
template 
int BiTree::FindPath(T i, BiNode* bt, stack*> &sta)
{   static int count;
	if (NULL != bt)
	{
		sta.push(bt); //将根节点压栈 ，栈用来保存结果集 
	}
	sum += bt->data; 

	if (sum == i && bt->lchild == NULL && bt->rchild == NULL)//当求到和且左子树和右子数都为空也就是到了叶节点时，就找到了解 
	{ 
           //打印结果 
		stack*> sta2(sta);
		BiNode* p;
		cout << "One of the path is: " ;
		while (!sta2.empty())
		{
			p = sta2.top();
			cout << p->data << " ";
			sta2.pop();
		}
		cout << endl;
		count ++;
	}
	//当没有到叶节点时，继续找。 
	if (NULL != bt->lchild)
	{
		FindPath(i, bt->lchild, sta);
	}
	if (NULL != bt->rchild)
	{
		FindPath(i,bt->rchild, sta);
	}
	//回溯时，需要回到之前的状态，所以要减去sum，并且弹栈。 
	sum -= bt->data;
	sta.pop();	
	return count;
}

int main()
{ 

    BiTree a;
   cout << "There are " << a.FindPath(22) << " path all." << endl;
   system("pause");
   return 0;
}

打印数组的全排列

#include 
using namespace std;
void swap(int &a,int &b)//交换连个元素
{
    int tem;
    tem = a;
    a = b;
    b = tem;
}
int sum=0;
void cal(int *a,int first,int end)
{
    if(first == end)//如果递归到深层时，到最后交换的元素即时最后一个元素时就打印出来
    {
        sum++;
        for(int i = 0; i <= end; i++)
        cout<