【算法实验三】（BFS-分支限界）【加1乘2平方】

最新推荐文章于 2020-11-08 20:53:11 发布

原创最新推荐文章于 2020-11-08 20:53:11 发布 · 277 阅读

2 ·

CC 4.0 BY-SA版权

算法设计专栏收录该内容

43 篇文章

订阅专栏

本文探讨了队列在算法中的基本应用，并通过一个具体的算法问题——从m变化到n的最少操作次数，展示了如何使用队列进行广度优先搜索（BFS）。文章对比了两种不同的实现方式，讨论了内存效率问题，最终提供了一个有效的解决方案。

1541.加1乘2平方

时限：1000ms 内存限制：10000K 总时限：3000ms

描述

最简单的队列的使用
#include <iostream>
#include <queue>
using namespace std;

queue<int> q1;
int main()
{
int temp, x;
q1.push(5);//入队
q1.push(8);//入队
temp = q1.front();//访问队首元素
q1.pop();//出队
q1.empty();//判队列是否为空
q1.back();//返回队尾元素
q1.size();//返回队列长度
}

给定两个正整数m、n，问只能做加1、乘2和平方这三种变化，从m变化到n最少需要几次

输入

输入两个10000以内的正整数m和n，且m小于n

输出

输出从m变化到n的最少次数

输入样例

1 16

输出样例

---------------------------------------第一次写的，可是他就怎么内存超限了，呜呜呜-------------------------------------------------------------

#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;

int m,n;
struct state
{
	int depth;
	int data;
};

state Plus(state m);
state Multiple2(state m);
state Square(state m);
state bfs(state m);

state Plus(state m)
{
	state tar;
	tar.depth=m.depth+1;
	tar.data=m.data+1;
	return tar;
}

state Multiple2(state m)
{
	state tar;
	tar.depth=m.depth+1;
	tar.data=m.data*2;
	return tar; 
}

state Square(state m)
{
	state tar;
	tar.depth=m.depth+1;
	tar.data=m.data*m.data;
	return tar;
}

state bfs(state m)
{
	queue<state> q;
	while(!q.empty())  //清空队列
    {
        q.pop();
    }
	q.push(m);
	while(!q.empty())
	{
		state p=q.front();
		if(p.data==n) break;
		q.pop();
		q.push(Plus(p));
		q.push(Multiple2(p));
		q.push(Square(p));
	}
	return q.front();
}

int main()
{
	cin>>m>>n;
	state begin,end;
	begin.data=m;
	begin.depth=0;
	end=bfs(begin);
	cout<<end.depth<<endl;
	return 0;
}

再次尝试：

#include<iostream>
#include<queue>
using namespace std;

int m,n;
queue<int> q;
int step[10001];
int used[10001];
int isfit(int p,int op);
int operate(int p,int i);

int bfs(int m)
{
	int op, p;//op->after operate   p->q.front(before oprate)
	q.push(m);
	used[m]=1;
	while(!q.empty())
	{
		p=q.front();
		q.pop();
		for(int i=0;i<3;i++)
		{
			op=operate(p,i);
			if(isfit(p,op))
			{
				return step[op];
			}
		}
	}
	return -1;
}

int operate(int p,int i)
{
	switch(i)
	{
		case 0: return p+1;
		case 1: return p*2;
		case 2: return p*p;
	}
}

int isfit(int p,int op)
{
	if(op<=n&&!used[op])
	{
		used[op]=1;
		step[op]=step[p]+1;
		if(op==n) return 1;
		else  q.push(op);
	}
	return 0;
}

int main()
{
	cin>>m>>n;
	int count=bfs(m);
	cout<<count<<endl;
	return 0;
}