一维坐标的移动（基础BFS）(待补)

题目描述

在一个长度为n一维坐标轴上，左右分别有两个点A,B，现在想从A的坐标移动至B的坐标，移动规则如下：

1. 向前一步，坐标增加 1
2. 向后一步，坐标减少 1
3. 跳跃一步，使得坐标乘 2

坐标不能小于0或者大于n，请问A移至B至少需要操作多少次

输入格式

第一行三个整数，n,A,B分别代表坐标轴长度，起始点坐标，终点坐标。

输出格式

输出一个整数，表示需要操作的最少次数。

样例输入

10 2 7

样例输出

3

思路

每一次的抉择有三个分支，想到搜索的方法。因为求最少次数，BFS优先选择。

可知在最优操作集合中一定不会经过同一点，所以要对经过的点进行标记，否则将会插暴内存（所有能到达的点都会入队列）。

对于步数（操作数），因为BFS是队列思想，不进行递归，所以对于每一层的操作对同一个结构体先进行三种p.x的改变，再p.num+1,插入队列尾。

代码示例

#include<iostream>
#include<queue>
#include<string.h>
#define MAX (int)1e4
using namespace std;

int n,a,b,Min;
int vis[MAX];//一定要标记，不然队列内存插暴了 

struct point {
	int x,num;
	point(int xx,int mm){
		x=xx;
		num=mm;
	}
};

queue<point> q;

void bfs(int tx,int tnum){
	q.push(point(tx,tnum));
	vis[tx]=1;
	while(!q.empty())
	{
		point p=q.front();
		q.pop();
		if(p.x==b){
		cout<<p.num<<endl;
			break;
		}
		for(int i=0;i<3;++i){
			if(i==0){
				if(p.x<n&&vis[p.x+1]==0){
					q.push(point(p.x+1,p.num+1));
					vis[p.x+1]=1;
				}
			}
			if(i==1){
				if(p.x>0&&vis[p.x-1]==0){
					q.push(point(p.x-1,p.num+1));
					vis[p.x-1]=1;
				}
			}
			if(i==2){
				if(p.x*2<=n&&vis[p.x*2]==0){
					q.push(point(p.x*2,p.num+1));
					vis[p.x*2]=1;
				}
			}
		}	
	}	
}

int main()
{
	memset(vis,0,sizeof(vis));
	//Min=0x3fffffff;
	cin>>n>>a>>b;
	bfs(a,0);
	return 0;
}

本题也可采用dfs思想，关键在于剪枝和dfs的递归调用操作的顺序

代码示例

#include<iostream>
using namespace std;

int n,a,b,Min;
int vis[(int)1e4];

void dfs(int x,int sum)
{
	if(sum>=Min||sum>=2500) return ;
	if(x==b){
		if(sum<Min) Min=sum;
		return ;
	}
	vis[x]=1;
	if(x*2<=n&&vis[2*x]==0){ //先进行乘法操作在剪枝下可大大降低时间复杂度
		dfs(2*x,sum+1);
	}
	if(x+1<=n&&vis[x+1]==0){
		//vis[x+1]=1;
		dfs(x+1,sum+1);
		//vis[x+1]=0;
	}
	if(x-1>=0&&vis[x-1]==0){
		//vis[x-1]=1;
		dfs(x-1,sum+1);
		//vis[x-1]=0;
	}
	
	
	vis[x]=0;
}

int main()
{
	Min=0x3fffffff;
	cin>>n>>a>>b;
	dfs(a,0);
	cout<<Min<<endl;
	return 0;
}

当数量级比较大时，bfs方法会超时，可以进行数学上的优化，之后补上