poj 3278

这是一道很水的bfs 题目。 点击打开链接

但是要注意的是 数组要开大点。因为 可能会访问到200000. 

注意剪枝。否则会超时的。

219ms

#include <iostream>
#include <memory.h>
#include <queue>
using namespace std;
const int N=200010;
int n,k,ans;
bool vis[N];
int cnt[N];
void bfs(int n,int k)
{
    memset(vis,false,sizeof(vis));
    memset(cnt,0,sizeof(cnt));
    queue<int > q;
    int cur,tmp;
    vis[n]=true;
    cnt[n]=0;
    q.push(n);
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        if(cur==k)
        {
            ans=cnt[cur];
            return ;
        }
        for(int i=1;i<=3;i++)
        {
            if(i==1)
            {
                if(cur>100000)
                    continue;
                tmp=cur+1;
            }
            else if(i==2)
            {
                if(cur==0)
                    continue;
                tmp=cur-1;
            }
            else
            {
                if(cur>66667)
                    continue;
                tmp=2*cur;
            }

            if(!vis[tmp])
            {
                cnt[tmp]=cnt[cur]+1;
                vis[tmp]=true;
                q.push(tmp);
            }
        }
    }

}
int main()
{
    while(cin>>n>>k)
    {
        bfs(n,k);
        cout<<ans<<endl;
    }
}

//通过修改主函数里面

/*if(abs(n-k) <=1) 
  {  cout<<abs(n-k)<<endl;  continue; 

       if((n << 1) == k){cout<<1<<endl;continue;}
        if(k < n){cout<<n-k<<endl;continue;}
        bfs(n,k);
        cout<<ans<<endl;

*/

时间就优化到了157ms

引用 poj上  

• Alex_Shepherd 的代码  。双向bfs 太牛逼了。留着学习

32ms

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <limits.h>
#include <bitset>
#define F "%I64d"
using namespace std;
typedef long long ll;
int dp[2][200000],N,K;
queue<int> QN,QK;
int bfs()
{
	while(!QN.empty())QN.pop();
	while(!QK.empty())QK.pop();
	memset(dp,-1,sizeof dp);
	QN.push(N);
	QK.push(K);
	dp[0][N] = dp[1][K] = 0;
	while(1)
	{
		if(QN.front() > 1 && dp[0][QN.front() - 1] == -1)
		{
			dp[0][QN.front() - 1] = dp[0][QN.front()] + 1;
			if(dp[1][QN.front() - 1] != -1)return dp[0][QN.front() - 1] + dp[1][QN.front() - 1];
			QN.push(QN.front() - 1);
		}
		if(QN.front() < 100000 && dp[0][QN.front() + 1] == -1)
		{
			dp[0][QN.front() + 1] = dp[0][QN.front()] + 1;
			if(dp[1][QN.front() + 1] != -1)return dp[0][QN.front() + 1] + dp[1][QN.front() + 1];
			QN.push(QN.front() + 1);
		}
		if(QN.front() < 100000 && dp[0][QN.front() << 1] == -1)
		{
			dp[0][QN.front() << 1] = dp[0][QN.front()] + 1;
			if(dp[1][QN.front() << 1] != -1)return dp[0][QN.front() << 1] + dp[1][QN.front() << 1];
			QN.push(QN.front() << 1);
		}
		if(QK.front() > 1 && dp[1][QK.front() - 1] == -1)
		{
			dp[1][QK.front() - 1] = dp[1][QK.front()] + 1;
			if(dp[0][QK.front() - 1] != -1)return dp[1][QK.front() - 1] + dp[0][QK.front() - 1];
			QK.push(QK.front() - 1);
		}
		if(QK.front() < 100000 && dp[1][QK.front() + 1] == -1)
		{
			dp[1][QK.front() + 1] = dp[1][QK.front()] + 1;
			if(dp[0][QK.front() + 1] != -1)return dp[1][QK.front() + 1] + dp[0][QK.front() + 1];
			QK.push(QK.front() + 1);
		}
		if((QK.front() & 1) == 0 && dp[1][QK.front() >> 1] == -1)
		{
			dp[1][QK.front() >> 1] = dp[1][QK.front()] + 1;
			if(dp[0][QK.front() >> 1] != -1)return dp[1][QK.front() >> 1] + dp[0][QK.front() >> 1];
			QK.push(QK.front() >> 1);
		}
		QN.pop();
		QK.pop();
	}
}
int main()
{
N:	while(~scanf("%d%d",&N,&K))
	{
		if(abs(N - K) <= 1){printf("%d\n",abs(N - K));continue;}
		if((N << 1) == K){puts("1");continue;}
		if(K < N){printf("%d\n",N - K);continue;}
		printf("%d\n",bfs());
	}
	return 0;
}