Rockwall

导航

回溯算法题总结

今天笔试了华为的提前批,爆炸,三道题最后就拿了200分,各种输入输出问题。。。醉了啊,题都不是很难,但输入输出折腾了半天T  T。。。第三题是和尚挑水的问题,

第二题就是找出数组中只能被自己整除的数,思路也很简单,最水的方法就是对每一个数,与数组中的其他数字进行除法运算,时间复杂度是O(n2)就不写代码了,也可以用通过维护一个除数的数组,具体时间复杂度有点难算,应该是2nk,k是这个数组的长度。代码我稍微写了一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <vector>
#include <iostream>
 
using namespace std;
 
int main() {
    vector<int> nums{ 4,5};
    //即剔除只能本自己整除的数
    vector<int> temp{ 4 };
    int flag = true;
    for (int i = 0; i < nums.size(); i++) {
        for (auto iter = temp.begin(); iter != temp.end(); iter++) {
            if (*iter%nums[i] == 0) {
                *iter = nums[i];
                flag = false;
                break;
            }
            else if (nums[i] % (*iter) == 0) {
                flag = false;
                break;
            }
        }
        if (flag) {
            temp.push_back(nums[i]);
        }
        else {
            flag = true;
        }
    }
 
    for (auto m : temp) {
        cout << m << " ";
    }
}

  


一、问题
某寺庙里7个和尚:轮流挑水,为了和其他任务不能冲突,各人将有空天数列出如下表:
和尚1: 星期二,四;
和尚2: 星期一,六;
和尚3: 星期三,日;
和尚4: 星期五;
和尚5: 星期一,四,六;
和尚6: 星期二,五;
和尚7: 星期三,六,日;
请将所有合理的挑水时间安排表

其实思路很简单,就是使用回溯算法,但是我自己太坑了啊,当时看到八皇后的题时候,知道用回溯算法,但是就看了一眼,没自己动手实现,结果今天不会写回溯。。。哈哈哈哈哈,最后用了非常傻逼的方法,就是全排列以后然后再选择符合的答案输出,但是格式有问题。。。最后300就拿了100分  _(:з」∠)____ 23333,对了,第二题我更加傻逼,200分一分没拿,哈哈哈哈哈气哭了,还是因为输入问题。。。。。感觉要好好练一下输入输出啊。。。

今天通过这题把回溯算法总结一下吧。

 这边先上我用非回溯写的算法,首先全排列,然后判断即可。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <iostream>
#include <vector>
 
using namespace std;
 
void allCombination( vector<int> &nums, vector<vector<int>> &res, int start){
    if( start == 7 ){
        res.push_back(nums);
        return;
    }
    for( int i = start; i < 7; i++ ){
        swap(nums[i],nums[start]);
        allCombination(nums,res,start+1);
        swap(nums[i],nums[start]);
    }
}
 
int main(){
//  vector<vector<int>> source(7,vector<int>(7,0));
//  for( int i = 0; i < 7; i++ ){
//      for( int j = 0; j < 7; j++ ){
//          cin>>source[i][j];
//      }
//  }
    vector<vector<int>> source{{0,1,0,1,0,0,0},{1,0,0,0,0,1,0},{0,0,1,0,0,0,1},{0,0,0,0,1,0,0},{1,0,0,1,0,1,0},{0,1,0,0,1,0,0,},{0,0,1,0,0,1,1}};
    int count = 0;
    vector<int> nums{1,2,3,4,5,6,7};
    vector<vector<int>> res;
    allCombination(nums, res, 0);
    vector<vector<int>> resoult;
    bool flag = true;
    for( int i = 0; i < res.size(); i++ ){
        for( int j = 0; j < 7; j++ ){
            if(source[res[i][j]-1][j] == 0 ){
                flag = false;
                break;
            }
        }
        if( flag ){
                resoult.push_back(res[i]);
                count++;
        }
        else{
                flag = true;
        }
    }
    cout<<count<<endl;
    for( int i = 0; i < resoult.size(); i++ ){
        for( int j = 0; j < 7; j++ ){
            cout<<resoult[i][j]<<" ";
        }
        cout<<endl;
    }
}

那全排列的问题是什么?其实就是减枝的问题,在排列的时候没有直接将不可能的结果去掉,比如1,X,X,X,X,X,X这样的排列组合,如果第一个和尚规定第一天就不能抬水,那么所有1开头的组合方式都是没有必要去验证的。所以回溯算法的本质其实是在可能的解空间进行搜索,这样相对于枚举的优势就是能够更快的找到解。

如果有了这样的的思路,那我们就可以这样判断从第一天开始判断,往后进行判断,如果当天某一个和尚能够挑水,则放入解向量中,并把这个和尚的标志设为已经挑水,如果往下搜索以后,发现所有情况都不能满足了,则回退到上一步,换其他的和尚挑水,反复进行,直到所有可能情况都遍历。

这边需要注意的一个是截止条件,比如对于和尚挑水这一题,

1.截止条件应该就是第一天挑水的和尚为不存在的第八个和尚,即<8。

2.是一个成功解的判定条件是解向量的长度为7,即每一天都有和尚挑水。

3.如果当前这一天成功,则搜寻下一天,如果当天失败,则回退到上一天。对3过程进行迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <vector>
 
using namespace std;
 
void allPossibleResult( vector<int> &isSelected, int day, vector<vector<int>> &source, vector<int> res ){
    if( day == 7 ){
        for( int i = 0 ; i < 7; i++ ){
            cout<<res[i]<<" ";
        }
        cout<<endl;
        return;
    }
    else{
        for( int i = 0; i < 7; i++ ){
            res[day] = i+1; //第day天选择第i个和尚挑水
            if( source[i][day] == 1 && isSelected[i] != 1 ){
                isSelected[i] = 1;
                allPossibleResult(isSelected, day+1, source, res);
                isSelected[i] = 0;
            }
        }
    }
}
 
int main(){
    //  vector<vector<int>> source(7,vector<int>(7,0));
//  for( int i = 0; i < 7; i++ ){
//      for( int j = 0; j < 7; j++ ){
//          cin>>source[i][j];
//      }
//  }
    vector<vector<int>> source{{0,1,0,1,0,0,0},{1,0,0,0,0,1,0},{0,0,1,0,0,0,1},{0,0,0,0,1,0,0},{1,0,0,1,0,1,0},{0,1,0,0,1,0,0,},{0,0,1,0,0,1,1}};
    vector<int> isSelected(7,0);
    vector<int> res(7,0);
    int num = 0;
    int day = 0;
    allPossibleResult(isSelected, day, source, res);   
}

试着用回溯法解一下把皇后

其实八皇后最大的不同应该就是if判断语句不同,如何判断与这边不同。

我设置了一个判断函数,判断的过程就是判断行上是否有皇后存在,判断列上是否有皇后存在,然后判断对角线,这边比较麻烦的是对角线,其实对角线可以这么判断,对于坐标(a,b),如果对于点(c,d) a-c == b - d或者 a-c == d-b那么他们就是在一条对角线上,这样就能够判断所有行列和对角线了。其实感觉这个方法不怎么好,判断起来太复杂了。网上貌似提到了位操作的方法,可以思考下。

代码如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
#include <vector>
 
using namespace std;
 
bool isCheck(vector<vector<int>> matrix, int index, int i) {
    bool flag = true;
    for (int j = 0; j < 8; j++) {
        if (matrix[j][index] == 1 || matrix[i][j] == 1) {
            flag = false;
            break;
        }
        for (int k = 0; k < 8; k++) {
            if ((j - i == k - index || j - i == index - k) && j != i && k != index ) {
                if( matrix[j][k] == 1 )
                    flag = false;
            }
        }
    }
    return flag;
}
 
void EightQueen(vector<int> &res, vector<vector<int>> &matrix, int &count, int index) {
    if (index == 8) {
        for (auto m : res) {
            cout << m << " ";
        }
        cout << endl;
        count++;
        return;
    }
    for (int i = 0; i < 8; i++) {
        res[index] = i;
        if (isCheck(matrix, index,i)) {
            matrix[i][index] = 1;
            EightQueen(res, matrix, count, index + 1);
            matrix[i][index] = 0;
        }
    }
 
}
 
int main() {
    int sum = 0;
    vector<int> res(8, 0);
    vector<vector<int>> matrix(8, vector<int>(8, 0));
    int count = 0;
    EightQueen(res, matrix, count, 0);
    cout << count << endl;
}

我这边是通过一个一维数组输出的,比如{0,4,7,5,2,6,1,3}表示第一列的第1行放皇后,第二列的第4行放皇后,第三列的第7行放皇后.....

 

posted on   Rockwall  阅读(998)  评论(0编辑  收藏  举报

努力加载评论中...
点击右上角即可分享
微信分享提示