POJ-Catch esa vaca

No importa qué tan alto de la montaña, escalar, subir siempre,
el camino puede ser largo, seguir adelante, será capaz de alcanzar.

POJ-Catch esa vaca

título Descripción

Farmer John ha sido informado de la ubicación de una vaca fugitiva y quiere cogerla inmediatamente. Se comienza en un punto N (0 ≤ N ≤ 100 000) en una línea de números y la vaca está en un punto K (0 ≤ K ≤ 100 000) en la misma línea número. Farmer John tiene dos modos de transporte: a pie y teletransporte.

• Caminar: FJ puede pasar de cualquier punto X a los puntos X - 1 o X + 1 en un solo minuto
• Teleporting: FJ puede pasar de cualquier punto X al punto 2 × X en un solo minuto.
  Si la vaca, sin darse cuenta de su persecución, no se mueve en absoluto, ¿cuánto tiempo se necesita para que Farmer John para recuperarlo?

entrada

Línea 1: Dos enteros separados por espacios: N y K

exportación

Línea 1: La menor cantidad de tiempo, en minutos, que se necesita para Farmer John para coger la vaca fugitiva.

Ejemplo de entrada

5 17

Ejemplo de salida

4

Insinuación

La forma más rápida de Farmer John para llegar a la vaca fugitiva es mover a lo largo de la ruta siguiente: 5-10-9-18-17, que dura 4 minutos.

Sujeto al efecto

Usted está en un cierto punto, otro punto de la vaca, es posible saltar directamente a sus propios 2 * n coordenadas, también se puede caminar por su cuenta coordinar n + 1 y n 1-coordenadas, pida, usted puede ser capaz de encontrar el mínimo número de pasos ganado, ganado posición no se mueve, esto es ejes unidimensionales.

portada analítica
Cada paso tiene tres opciones, pero no tiene que ir en una dirección desde hace mucho tiempo, sólo para resolver el actual, por lo que la idea de un BFS.
análisis de las ideas
De hecho, la idea es simple, pero hay un pozo, que la restricción.
No se puede ir a 0 después de la primera, y luego se puede mover hacia adelante infinita, pero continuará a ir allí un montón de estrategia no tiene sentido. Por lo que desea eliminar estos problemas innecesarios.
0 no viene después de esta resuelto, pero la cara de rango infinito no saben cómo dibujar los límites.
Pero podemos pensar, no debe ser 100.000, porque puede haber que volver un poco después de duplicación fue al punto de destino, tal solución es óptima. Sin embargo, los límites de más de 200.000, entonces es mejor ir directamente Retrocediendo más tarde, por lo que el límite se establece en 200.000
la idea bien puede escribir el código
de cuenta que, para evitar la dispersión del puntero, debemos determinar primero las restricciones, a continuación, antes de continuar.
En segundo lugar, el juez ya sea a través del lugar tanto como sea posible con la matriz, para abrir una más grande, cumple con los requisitos, pero no use el almacenamiento mapa, puede almacenar un hash, mapa, entonces popular árbol negro mano consulta hasta no tan bueno como el uso directo de arrays y hashes realidad.
en segundo lugar
G ++ se puede utilizar en q.push (nodo {1,2}) de esta manera directamente en la cola

Tiempo para AC

#include<algorithm>
#include<iostream>
#include<string.h>
#include<utility>
#include<stdio.h>
#include<vector>
#include<string>
#include<math.h>
#include<cmath>
#include<queue>
#include<stack>
#include<deque>
#include<map>
#pragma warning(disable:4244)
#define PI 3.1415926536
#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll ll_inf = 9223372036854775807;
const int int_inf = 2147483647;
const short short_inf = 32767;
const char char_inf = 127;
ll GCD(ll a, ll b) { return a ? GCD(b, a % b) : a; }
inline ll read() {
	ll c = getchar(), Nig = 1, x = 0;
	while (!isdigit(c) && c != '-')c = getchar();
	if (c == '-')Nig = -1, c = getchar();
	while (isdigit(c))x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar();
	return Nig * x;
}
inline void out(ll a)
{
	if (a < 0)putchar('-'), a = -a;
	if (a >= 10)out(a / 10);
	putchar(a % 10 + '0');
}
ll qpow(ll x, ll n, ll mod) {
	ll res = 1;
	while (n > 0) {
		if (n & 1)res = (res * x) % mod;
		x = (x * x) % mod; n >>= 1;
	}
	return res;
}
#define read read() 
bool judge[200007];
struct node {
	int x, step;
};
queue<node>q;
node temp;
void bfs(int End) {
	while (!q.empty()) {
		temp = q.front();
		q.pop();
		if (temp.x == End) {
			cout << temp.step << endl;
			return;
		}
		if ((temp.x * 2 <= 200000) && (!judge[temp.x * 2])) {////先判断条件
			judge[temp.x * 2] = true;
			q.push(node{ temp.x * 2,temp.step + 1 });
		}
		if ((temp.x + 1 <= 200000) && (!judge[temp.x + 1])) {////先判断条件
			judge[temp.x + 1] = true;
			q.push(node{ temp.x + 1,temp.step + 1 });
		}
		if ((temp.x >= 1) && (!judge[temp.x - 1])) {//先判断条件
			judge[temp.x - 1] = true;
			q.push(node{ temp.x - 1,temp.step + 1 });
		}
	}
}
int main() {
	int Sta = read, End = read;
	if (Sta >= End) {//因为反向走的方法只有一种，直接出结果就可以了
		cout << Sta - End << endl;
		return 0;
	}
	q.push(node{ Sta,0 });
	judge[Sta] = true;
	bfs(End);
}

Subproducto de la rueda mes