Find a number in minimum steps(Level Order Traversal)(层序遍历）（BFS）

Given an infinite number line from -INFINITY to +INFINITY and we are on zero. We can move n steps either side at each n’th time.

1st time; we can move only 1 step to both ways, means -1 1;

2nd time we can move 2 steps  from -1 and 1;
-1 :  -3 (-1-2)  1(-1+2)
 1 :  -1 ( 1-2)  3(1+2)

3rd time we can move 3 steps either way from -3, 1, -1, 3 
-3:  -6(-3-3) 0(-3+3)
1:   -2(1-3)   4(1+3)
-1:  -4(-1-3)  2(-1+3)
3:     0(0-3)   6(3+3) 

Find the minimum number of steps to reach a given number n. 

Examples:

Input : n = 10
Output : 4
We can reach 10 in 4 steps,  1, 3, 6, 10 


Input : n = 13
Output : 5
We can reach 10 in 4 steps,  -1, 2, 5, 9, 14 

This problem can be modeled as tree. We put initial point 0 at root, 1 and -1 as children of root. Next level contains values at distance 2 and so on.

              0
            /    \
         -1       1  
        /  \       /  \
       1   -3   -1   3
     /  \   / \   / \   / \

The problem is now to find the closes node to root with value n. The idea is to do Level Order Traversal of tree to find the closest node. Note that using DFS for closest node is never a good idea (we may end up going down many unnecessary levels).
Below is C++ implementation of above idea.

思路一：将树的每个节点定义为结构体，包含值和位于的层数。

 

#include <iostream>
#include <queue>
#include <cstdlib>
using namespace std;
#define Inf 9999

// To represent data of a node in tree
struct number{
    int val;
    int level;
public:
    number(){}
    number(int n, int l):val(n),level(l) {}
};

void FindMiniSteps(int n){
    queue<number> que;
    struct number r(0, 1);
    que.push(r);
    while(!que.empty()){
        // Remove a node from queue
        struct number temp = que.front();
        que.pop();
        // To avoid infinite loop
        if(temp.val > Inf || temp.val < -Inf)
            break;
        // Check if dequeued number is same as n
        if(temp.val == n){
            cout << "Found number n at level " << temp.level-1 << endl;
            break;
        }
        // Insert children of dequeued node to queue
        que.push(number(temp.val-temp.level, temp.level+1));//先判断temp.val-temp.level == n,若相等则直接输出并结束
        que.push(number(temp.val+temp.level, temp.level+1));//这里也可以优化

    }
}


int main(){
    FindMiniSteps(13);
    FindMiniSteps(10);
    system("pause");
    return 0;
}

 

 

 

思路二：树的每个节点只包含一个数。

 

#include <iostream>
#include <queue>
#include <cstdlib>
using namespace std;
#define Inf 9999

void FindMiniSteps(int n){
    queue<int> que;
    int flag = 0;
    int step = 1;
    que.push(0);
    while(!que.empty()){
        int size = que.size();//记录第step层的元素个数
        for(int i = 0; i < size; i++){//查找第step层是否有和n相等的数，若有则输出step-1，结束
            int a = que.front();
            que.pop();
            if(a == n){
                flag = 1;//找到步数，结束，标记为1
                cout << "Found number n at level " << step-1 << endl;
                break;
            }
            que.push(a - step);//将a-step值放入队列,这里也可以先判断a-step ?= n,如果相等则可以直接输出，结束，
            //特别是如果a为某一层最后一个元素时，如果a-step == n，则可以提前结束，而不用比较下一层的很多元素和把下下层的元素放入队列中
            que.push(a + step);//将a+step值放入队列，这里也可以先判断a+step ?= n,如果相等则可以直接输出，结束
        }
        if(flag == 1)//如果flag == 1，结束
            break;
        step++;//下一层
    }
}

int main(){
    FindMiniSteps(13);
    FindMiniSteps(10);
    system("pause");
    return 0;
}

 

 

 

 

Found number n at level 5

Found number n at level 4