【Leetcode】818. Race Car 818. 赛车

1
2

解法

A k A^k Ak表示连续的k个A,容易分析出,它会在该方向上走 2 k − 1 2^k-1 2k1步,我们可以将最后的结果表示为 A k 0 R A k 1 . . . A k n R A^{k_0}RA^{k_1}...A^{k_n}R Ak0RAk1...AknR,最后一个R可以去掉
它用数学表达式写出来就是: ( 2 k 0 − 1 ) + ( 2 k 2 − 1 ) + . . . − ( 2 k 1 − 1 ) − . . . . (2^{k_0}-1)+(2^{k_2}-1)+...-(2^{k_1}-1)-.... (2k01)+(2k21)+...(2k11)....
有个结论:

设K为target的二进制位数,那么有 t a r g e t ≤ 2 K − 1 target\le2^K-1 target2K1
如果要超过target后再往回走,最多会走到 2 K − 1 2^K-1 2K1的位置,不可以再往后走了,因为假如再多走S,正向一步走了S,反向要抵消这一步需要至少 l o g ( S ) log(S) log(S)步。

解法一:DIJSTRA

我们把图里的每个点i表示为【沿该方向向target走还差i距离】
初始为正向,那么 i = t a r g e t i=target i=target,所以起点是dist[target]=0
从点i可以去哪些点呢?我们由上文的分析可以知道 k j ≤ K k_j\le K kjK,所以从点i可以通过走 2 0 − 1 2^0-1 201 2 1 − 1 2^1-1 211 2 2 − 1 2^2-1 221、… 2 K − 1 2^K-1 2K1步,然后再掉头,即是附加 R R R A R AR AR A 2 R A^2R A2R A K R A^KR AKR,它们分别增加1、2、3、…、K+1步。
在没有加R的时候,剩余的距离为 i − ( 2 t − 1 ) i-(2^t-1) i(2t1),由于掉头了,那么剩余的距离变成 ( 2 t − 1 ) − i (2^t-1)-i (2t1)i,因为要倒着走才能到target了。
所以每个点i将会联通K+1个点。

现在我们用dijstra算法,每次取步数最少的那个点 i i i,它就是真正到点i的最少步数,然后再看看从点i走的点是否能改善距离。

需要注意的是,数轴上每个整数位置都可能成为点i,这样循环就不会停了,这时候要用上上面的结论,我们的车不可能跑出 [ − ( 2 K − 1 ) , 2 K − 1 ] [-(2^K-1),2^K-1] [(2K1),2K1],这就让点的个数变得有限了。

class Solution(object):
    def racecar(self, target):
        """
        :type target: int
        :rtype: int
        """
        K = target.bit_length()
        up = (1<<K)-1
        from heapq import heappush,heappop
        queue = [(0,target)]
        dist = {target:0}
        while queue:
            # print queue
            d,t = heappop(queue)
            if t in dist and dist[t]<d:continue
            for k in xrange(K+1):
                d2,t2 = d+k+1,(1<<k)-1-t
                if t2==0:
                    d2-=1
                if abs(t2)<=up and (t2 not in dist or dist[t2]>d2):
                    dist[t2]=d2
                    heappush(queue,(d2,t2))
        return dist[0]

解法二:DP

d p [ t ] dp[t] dp[t]表示走t距离用的最小步数
我们走到一个target,有三种情况:

  1. 如果target刚好等于 2 K − 1 2^K-1 2K1,那么就刚好要走K步。

  2. 永远不超过这个target,走到一个位置,反回去几步,再向前走。我们一定要正向走到不能再走,即走到 2 K − 1 − 1 2^{K-1}-1 2K11处。因为:

    首先,从上面的表达式我们知道,每个 A k i R A^{k_i}R AkiR小节的顺序不影响结果。那么我们可以假设,下标同为偶数的 k i k_i ki是递减排列的。
    那么,此时最大的 k 0 k_0 k0一定是K-1,否则,假如是更小的值k,从 2 k − 1 2^k-1 2k1 2 K − 1 − 1 2^{K-1}-1 2K11这段距离用后面更更小的 k i k_i ki来走,肯定花费的步数更多。

    走到 2 K − 1 − 1 2^{K-1}-1 2K11处再掉头,花费K步( A K − 1 R A^{K-1}R AK1R)。然后我们需要枚举往回走j步( 0 ≤ j &lt; K − 1 0\le j&lt;K-1 0j<K1)再掉头,花费j+1步( A j R A^jR AjR)。现在我们离target的距离缩短为 t a r g e t − ( 2 K − 1 − 1 ) + ( 2 j − 1 ) target-(2^{K-1}-1)+(2^j-1) target(2K11)+(2j1),即 t a r g e t − 2 K − 1 + 2 j target-2^{K-1}+2^j target2K1+2j,它要花费 d p [ t a r g e t − 2 K − 1 + 2 j ] dp[target-2^{K-1}+2^j] dp[target2K1+2j]步,所以总花费步数为 d p [ t a r g e t − 2 K − 1 + 2 j ] + K + j + 1 dp[target-2^{K-1}+2^j]+K+j+1 dp[target2K1+2j]+K+j+1

  3. 超过这个target,然后往回走。从上面的结论可知,我们最多走到 2 K − 1 2^K-1 2K1的位置,即花费K+1步( A K R A^KR AKR)。
    然后我们就要往回走 ( 2 K − 1 ) − t a r g e t (2^K-1)-target (2K1)target距离,这个距离要花 d p [ ( 2 K − 1 ) − t a r g e t ] dp[(2^K-1)-target] dp[(2K1)target]步。
    总共花费的步数是 d p [ ( 2 K − 1 ) − t a r g e t ] + K + 1 dp[(2^K-1)-target]+K+1 dp[(2K1)target]+K+1

综上所述,那么 d p [ t a r g e t ] dp[target] dp[target]就在上面的所有候选者里选最小值

class Solution(object):
    def racecar(self, target):
        """
        :type target: int
        :rtype: int
        """
        INF = 3*target
        f = [INF]*(target+1)
        f[0] = 0
        for t in xrange(1,target+1):
            k = t.bit_length()
            if t+1==1<<k:
                f[t]=k
                continue
            u = t-(1<<(k-1))
            for j in xrange(k-1):
                f[t]=min(f[t],f[u+(1<<j)]+k+j+1)
            if (1<<k)-t<t:
                f[t] = min(f[t],k+1+f[(1<<k)-t])
        return f[target]
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值