深度优先搜索笔记1-数字组合问题

《啊哈，算法》中将的深度优先搜索挺好，做个笔记。

问题1：

使用数字1-9组成xxx-xxx=xxx等式，每个数字只能使用一次。

分析：

使用枚举法可以实现，但是需要时间复杂度很高，谁用深度优先搜索比较合适。深度优先搜索的关键在于：解决当下该怎么做，至于下一步该怎么做与当下该怎么做是一样的。将数字1-9比作手里的牌，要发到1-9号箱子里面。需要实现的深度优先搜索的函数dfs(step)确定走到第step个箱子前需要做什么，伪代码：

void dfs(int step)
{
   判断边界
   尝试每一种可能
   for(int i=1;i<=n;i++)
   {
      继续下一步
      dfs(step+1); 
   }
   return;
}

代码

#include<iostream>
#include<vector>

using namespace std;

int a[10], book[10], total = 0; //a数组代表盒子，book数组标记手里的牌是否已经被发出去，total代表方法数


void dfs(int step)
{
    if (step == 10)//如果step=10说明手里的牌已经发完了，可以判断这次排列是否满足要求
    {
        if (a[1] * 100 + a[2] * 10 + a[3] + a[4] * 100 + a[5] * 10 + a[6] == a[7] * 100 + a[8] * 10 + a[9])
        {
            total++;
            printf("method %-3d: %d%d%d+%d%d%d=%d%d%d\n",total,a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
        }
        return;//返回这次函数调用
    }

    for (int i = 1; i <= 9; i++)//走到第step个盒子面前，依次尝试手里的牌（没有被发出去）
    {
        if (book[i] == 0)//等于0说明该牌没有被发出去，还在手里
        {
            a[step] = i;//将这张牌放到盒子里
            book[i] = 1;//标记这张牌已经被发出去了
            dfs(step + 1);//走到下一个盒子发牌
            book[i] = 0;//将发出的这张牌取消标记，因为再次返回到这个盒子时，要尝试其他的牌，这张牌可以用于后续盒子发牌
        }
    }
    return;//处理完成后返回
}
int main()
{
    dfs(1);
    system("pause");
    return 0;
}

问题2

输入两个整数 n 和 m，从数列1，2，3…….n 中随意取几个数,使其和等于 m,要求将其中所有的可能组合列出来

输入描述

每个测试输入包含2个整数,n和m

输出描述

按每个组合的字典序排列输出,每行输出一种组合

如：
输入：
5 5
输出：
5
1 4
2 3

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

typedef struct Data
{
    int n;
    int m;
    vector<int> book;
    vector<int> box;
};

void dfs(Data& data,int numOfBox,int step,vector<vector<int>>& result)
{
    if (step == numOfBox)
    {
        int sum = 0;
        for (int i = 0; i <numOfBox; i++)
        {
            sum+=data.box[i];
        }
        if (sum == data.m)
        {
            result.push_back(data.box);
        }
        return;
    }

    int start = 1;
    for (int i = data.book.size() - 1; i >= 1; i--)
    {
        if (data.book[i] == 1)
        {
            start = i;
            break;
        }
    }

    for (int i = start; i <= data.n; i++)
    {
        if (data.book[i] == 0)
        {
            data.book[i] = 1;
            data.box.push_back(i);
            dfs(data, numOfBox, step + 1,result);

            data.book[i] = 0;
            data.box.pop_back();
        }

    }
    return;
}

void show_1(vector<vector<int>>& v)
{
    for (int i = 0; i < v.size(); i++)
    {
        for (int j = 0; j < v[i].size(); j++)
        {
            cout << v[i][j] << " ";
        }
        cout << endl;
    }
}

void dealResult(vector<vector<int>>& v)
{

}

int main()
{
    Data data;
    vector<vector<int>> result,final;
    cin >> data.n>>data.m;
    for (int i = 0; i <=data.n; i++)
    {
        data.book.push_back(0);
    }
    int sum=0,num;
    for (int i = 1; i < data.n; i++)
    {
        sum += i;
        if (sum >= data.m)
        {
            num = i;
            break;
        }
    }
    if (sum < data.m)
    {
        cerr << "Error: m is too big" << endl;
        system("pause");
        exit(1);
    }
    for (int i =1; i <= num; i++)
    {
        dfs(data, i, 0, result);
    }
    show_1(result);
    system("pause");
    return 0;
}

参考文献：《啊哈，算法》–啊哈磊