【Leetcode】818. Race Car

题目地址：

https://leetcode.com/problems/race-car/

有一辆车处在位置$0$，初始速度为$1$，有一个目标位置$t$。如果其当前速度为$v$，位置为$x$，每一步其可以采取如下操作：
1、其可以走到$x+v$的位置，并且$v$变为$2v$；
2、其可以将$v$变为$-\frac{v}{|v|}$（速度变为负数的意思是方向反向）。
问其至少多少步能到达$t$，其中$t\ge 1$。

由于速度一定是$2$的幂次，我们可以将$(x,k,d)$做成一个状态，$x$是位置，$k$是速度的$2$的指数，$d$是方向，正向为$1$负向为$0$。这样初始状态就是$(0,0,1)$。那么问题就转为从$(0,0,1)$走到$(t,.,.)$至少要多少步，每一步可以走到$(x+2^k,k+1,d)$或者$(x,0,d\wedge 1)$，可以用BFS来解决。我们可以将连续的同方向的加速分隔出来，那么每次走的距离是$1+2^1+...+2^{c-1}=2^c-1$，而这样的数的二进制表示即为连续的若干个$1$。问题即是要用若干个形如那样的整数的加减凑出$t$。如果走到$>2t$的位置是不划算的，同样如果走到$<0$的位置也不划算。代码如下：

class Solution {
 public:
  struct Node {
    int x, k, d;
    bool operator==(const Node& n) const {
      return x == n.x && k == n.k && d == n.d;
    }
  };

  int racecar(int target) {
    queue<Node> q;
    auto nhash = [](const Node& n) {
      auto h = hash<int>();
      return h(n.x) ^ h(n.k) ^ h(n.d);
    };
    unordered_set<Node, decltype(nhash)> vis(0, nhash);
    q.push({0, 0, 1});
    vis.insert({0, 0, 1});
    int res = 0;
    while (q.size()) {
      res++;
      for (int i = q.size(); i; i--) {
        auto t = q.front(); q.pop();
        int x = t.x + (1 << t.k) * (t.d * 2 - 1);
        if (0 <= x && x <= target * 2) {
          if (x == target) return res;
          if (!vis.count({x, t.k + 1, t.d})) {
            q.push({x, t.k + 1, t.d});
            vis.insert({x, t.k + 1, t.d});
          }
        }

        x = t.x;
        int d = t.d ^ 1;
        if (!vis.count({x, 0, d})) {
          q.push({x, 0, d});
          vis.insert({x, 0, d});
        }
      }
    }
    return -1;
  }
};

时空复杂度$O(t\log t)$。