Codeforces 520B. Two Buttons

方法一：

可以看出，n大于m，直接输出n-m即可。

否则直接BFS了

#include<bitset>
#include<map>
#include<vector>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#define inf 0x3f3f3f3f
#define mem(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

const int N=123,MOD=1e9+7;
int boys[111];
int girls[111];
int dp[111][111];
int vis[600000];
struct node{
    int x,step;
};
int main()
{
    int n,m;scanf("%d%d",&n,&m);
    if(n >=m){
        printf("%d\n",n-m);return 0;
    }
    queue<node>Q;
    node s ;s.x = n;
    s.step = 0;
    Q.push(s);
    while(!Q.empty()){
        node now = Q.front();Q.pop();
        if(now.x == m){
            printf("%d\n",now.step);
            return 0;
        }
        int lx = now.x*2;
        int rx= now.x-1;
        node nt;nt.step = now.step +1;
        if(lx >0 && lx < m*2 && !vis[lx]){
            nt.x = lx;
            vis[nt.x] = 1;
            Q.push(nt);
        }
        if(rx >0 && rx < m*2  && !vis[rx]){
            nt.x = rx;
            vis[nt.x] = 1;
            Q.push(nt);

        }
    }

    return 0;
}

方法二，

Suppose that at some point we perform two operations of type 1 and then one operation of type 2; but in this case one operation of type 2 and one operation of type 1 would lead to the same result, and the sequence would contain less operations then before. That reasoning implies that in an optimal answer more than one consecutive operation of type 1 is possible only if no operations of type 2 follow, that is, the only situation where it makes sense is when n is smaller than m and we just need to make it large enough. Under this constraint, there is the only correct sequence of moves: if n is smaller than m, we just add 1 until they become equal; else we divide n by 2 if it is even, or add 1 and then divide by 2 if it is odd. The length of this sequence can be found in .

题意是n有两种操作，一个是减一。一个是翻倍。

于是，我们倒过来想，m到n有两种操作，一种是加一，一种是减小一半。

  考虑这种情况，当两个数，例如4 6 ，6 + 1 + 1 然后在 /2 ,花费3 ， 6/2 + 1花费2.

因此，超过一次的+1操作在这种情况下都是多消耗时间的，因此，尽可能的使用2操作，/2.直到不能使用，也就是m <= n的时候。

int main()
{
    int n,m;scanf("%d%d",&n,&m);
    int step =0;
    while(n < m){
        if(m&1){
            m++;
        }
        else{
            m>>=1;
        }
        step++;
    }
    printf("%d\n",step+n-m);
    return 0;
}