线性时间解决方案

Question

在面试中我被问到这个问题。

你站在0，你必须到达一个位置X.你可以跳到D（1到D）。 如果X> D，很明显你在初始跳跃时无法到达位置X.

现在，每秒从1到N出现在随机位置的瓦片。这是作为零索引阵列A [k]给出的，其中A [k]表示出现在第k秒的瓦片的位置。 你必须找出，在那时你可以到达（或越过）目的地X.

如果可能在初始时或在A [0]之后，则返回0，或返回最小秒。 如果即使在所有瓷砖之后也不可能，则返回-1。

约束：1 <= N <= 100,000

1 <= D <= 100,000

1 <= X <= 100,000

1 <= A [i] <= X.

例如。

X = 7，D = 3

A = {1,3,1,4,2,5}

然后回答是3.因为在第3个第二个图块出现在位置4，所以可以达到X = 7。 在此之前的任何一秒都不可能。

我知道这是一个措辞太多的问题，但如果我不能很好地沟通，我绝对可以清除任何事情。

问题是预期的时间复杂度为O（N），您可以使用额外的空间O（X）。

我找到了一个O（n * log n * log n）的解决方案。 这是二次搜索并获得第一个[1..mid]元素，按位置排序并验证解决方案。 它似乎通过了测试用例，但它不是线性的。

我努力但却找不到任何O（N）解决方案。 你能帮我么？

Answer 1

通过线性你的意思是瓷砖数量的线性，对吧？

如果是这样，这个解决方案（在Java中）只迭代一次tile数组。

在每次迭代中，它还需要迭代D和X次，但它相对于tile数组的大小是线性的。

如果它听起来与您正在寻找的相似，请告诉我。

注意：为了简化，我假设位置“0”的磁贴在第二个数字“0”处可用，因此有效地将第二个“0”视为仅存在您所在的磁贴的时间，然后是另一个瓷砖出现在秒1,2等处。

    public class TestTiles {

        public static int calculateSecond(Integer x, Integer d, int[] tiles) {
            // start by making all positions unreachable (false)
            boolean[] posReachable = new boolean[x+1];
            // iterate each second only once
            for (int second = 0; second < tiles.length; second++) {
                int tile = tiles[second];  // this tile is available now
                // so mark all positions from "tile" to "tile + d" reachable
                for (int pos = tile; (pos <= tile + d) && pos <= x; pos++) {
                    posReachable[pos] = true;
                }
                // are all positions reachable now? if so, this is the second to return
                boolean reachable = true;
                for (int pos = 0; pos <= x; pos++) {
                    reachable &= posReachable[pos];
                }
                if (reachable) return second;
            }
            // we can't reach the position
            return -1;
        }

        public static void main(String[] args) {
            System.out.println(calculateSecond(7, 3, new int[]{0,1,3,1,4,2,5}));
            System.out.println(calculateSecond(20, 3, new int[]{0,1,3,1,4,2,5}));
            System.out.println(calculateSecond(2, 3, new int[]{0,1,3,1,4,2,5}));
            System.out.println(calculateSecond(4, 3, new int[]{0,1,3,1,4,2,5}));
            System.out.println(calculateSecond(15, 3, new int[]{0,12,3,9,6}));
        }

    }

Answer 2

以下建议应花费时间O（N * log（min（N，X / D）））。 请注意，特别是在O（N * log（N））中，因此具有比您提出的算法或mcdowella提出的优先级队列算法更好的界限; 在O（N *（X + D））中，因此具有比eugenioy提出的算法更好的界限; 随着D的增加不会增加（如mcdowella的数组算法，eugenioy算法和coproc算法那样）; 而且对于固定的X是O（N）。

我们的想法是保留一组我们仍然需要找到路径的间隔。 我们将这个集合存储在一个平衡树中，其中键是区间的下限，其值是上限。 当我们看到一个新的图块时，我们会找到包含此图块的间隔（如果有的话），并在图块周围分割间隔，丢弃任何小于D的结果间隔。当我们的地图为空时，我们就完成了。

接下来是Haskell的完整实现。

import Data.Ix
import Data.Map
import qualified Data.Map as M

-- setup: the initial set of intervals is just the singleton from 0 to x
search :: Int -> Int -> [Int] -> Maybe Int
search d x = search_ d (insertCandidate d 0 x empty)

search_ :: Int -> Map Int Int -> [Int] -> Maybe Int
search_ d = go where
    -- first base case: we've found all the paths we care about
    go intervals _ | M.null intervals = Just 0
    -- second base case: we're out of tiles, and still don't have all the paths
    go _ [] = Nothing
    -- final case: we need to take a time step. add one, and recursively search the remaining time steps
    go intervals (tile:tiles) = (1+) <$> go newIntervals tiles where
        newIntervals = case lookupLE tile intervals of
            Just (lo, hi) | inRange (lo, hi) tile
                -> insertCandidate d lo tile
                .  insertCandidate d tile hi
                .  delete lo
                $  intervals
            _ -> intervals

-- only keep non-trivial intervals
insertCandidate :: Int -> Int -> Int -> Map Int Int -> Map Int Int
insertCandidate d lo hi m
    | hi - lo <= d = m
    | otherwise    = insert lo hi m

在ghci中运行此示例的几个示例（我已经无耻地从其他答案中删除了示例）：

> search 3 7 [1,3,1,4,2,5]
Just 4
> search 3 20 [1,3,1,4,2,5]
Nothing
> search 3 2 [1,3,1,4,2,5]
Just 0
> search 3 4 [1,3,1,4,2,5]
Just 1
> search 3 15 [12,3,9,6]
Just 4

Answer 3

我会逐个处理磁贴，因为它们在数组中，跟踪最大可到达位置，并维护“挂起”磁贴的优先级队列。

1. 如果瓷砖大于X，则扔掉。
2. 如果图块已位于可到达区域内，请将其丢弃。
3. 如果此时无法访问该磁贴，请将其添加到挂起的队列中。
4. 如果磁贴扩展了可到达区域，则重新处理挂起队列中现在可以访问的最近磁贴，或者在此重新处理期间可以访问。
5. （如果现在可以访问X，请停止）。

除了从小整数优先级队列中添加和删除min的成本之外，每个区块最多处理两次，每次处理为O（1）步，其中有专门的算法 - 请参阅https：//cs.stackexchange .com / questions / 2824 / most-efficient-known-priority-queue-for-inserts 。

Answer 4

[Python中的这个解决方案类似于mcdowella的; 但是它不是使用优先级队列，而是使用大小为X的数组来表示最多X的位置。它的复杂度是O(N+min(N,X)*D) ，所以它不是真正的线性，而是N的线性...]

阵列world跟踪位置1，...，X-1。 通过跳转到最远的可到达区块，使用每个区块更新当前位置。

def jumpAsFarAsPossible(currentPos, D, X, world):
  for jump in range(D,0,-1): # jump = D,D-1,...,1
    reachablePos = currentPos + jump
    if reachablePos >= X:
      return X
    if world[reachablePos]:
      return jumpAsFarAsPossible(reachablePos, D, X, world)
  return currentPos

def solve(X,D,A):
  currentPos = 0
  # initially there are no tiles
  world = X * [False]

  for k,tilePos in enumerate(A):
    if tilePos < X:
      world[tilePos] = True

    # how far can we move now?
    if currentPos+D >= tilePos:
      currentPos = jumpAsFarAsPossible(currentPos, D, X, world)

    # have we reached X?
    if currentPos == X:
      return k # success in k-th second

  return -1 # X could not be reached

Answer 5

这是另一个尝试：

创建一个大小为X的数组B.将其初始化为MAX_VALUE，然后填入元素B [A [i]] = min（B [A [i]]，i），使B的每个元素都是巨大的或第一个图块出现在该正方形上的时间。

将当前时间初始化为零，并从左向右沿B工作，尝试使用不超过当前时间的B元素跳过最多D的切片，从0跳到X. 如果你不能再继续下去，可以将当前时间增加到B中任何方格中的最小值，以便你进一步跳跃。

成本是O（X log（D））+ O（N） - 您通过一次成本O（N）的A来初始化X，然后一次一步地沿着X工作。 如果你保留一个优先级队列来覆盖每个时间点的X中的下一个D元素，你可以找到成本不超过log（D）的X的最小可到达元素 - 并且这些是小整数，所以你可能能够做得更好。

Answer 6

我的解决方案是O(N)+O(X/D) 。 我有两个论点（好吧，一个借口和一个真实的论据）来捍卫它为O(N) ：

借口是我应该有O(X)空间，我甚至无法在O(N)时间内初始化它。 所以我假设数组是预先初始化的，因为我的O(X/D)部分只是将数组初始化为默认值，所以我很乐意忽略它。 （嘿，我说这是一个借口）。

真正的论点是X/D实际上不能大于N 我的意思是，如果我必须以每个最多D位置的步长移动X位置，则最小步数将是X/D （这意味着X/D-1平铺）。

• 因此， X/D-1 > N任何问题都是无法解决的。
• 因此，算法很可能从if (X/D > N+1) return -1 。
• 因此， O(X/D)永远不会大于O(N) 。
• 因此， O(N)+O(X/D)实际上与O(N)相同。

那就是说，我采用了我的解决方案：

数学设置

我将假设一个位置为0到X的“轨道”，因此0位于左侧， X位于右侧（我需要这个，因为我将谈论“最左边的区块”和类似的东西）。 轨道有X+1位置，编号为0到X 最初，在0处有一个瓦片，在X处有另一个瓦片。

我将曲目划分为块。 块大小使得任何两个相邻块组合恰好为D位置。 第一个块是k位置，第二个是Dk ，第三个是k再次，第四个是Dk ，等等， k是1和D-1之间的任何值。 如果D是偶数并且我们设置k=D/2 ，则所有块将是相等的大小。 如果将k设置为1并且成对处理块，我觉得实现可能会更容易一些，但我真的不知道（我没有实现这个）并且算法对于任何k都基本相同所以我'继续前进。

最后一个块可能被截断，但我只是假设它应该是它的大小，即使它意味着它超出了X 那不重要。 简单的例子，如果X=30 ， D=13 ， k=6 ，将有5块与尺寸6-7-6-7-6 （即0-5 ， 6-12 ， 13-18 ， 19-24 ， 25-31 ，位置31不是轨道的一部分）。

从现在开始，我将使用数组符号表示块，即我将块号k称为C[k] 。

非常重要的是，两个相邻的块总是合计到D位置，因为它可以保证：

• 如果每个块至少在其上具有瓦片，则问题得以解决（即不再需要瓦片）。
• 如果两个相邻的块上没有拼贴，则需要更多拼贴。

如果有一个块没有落入任何先前的情况（即其中没有tile，但前面和后面的块确实有tile），那么我们必须测量块中最左边的tile之间的距离向右，以及左边的块中最右边的图块。 如果该距离小于或等于D ，则该块不是问题。

总结一下：根据以下规则，有些块是有问题的，有些则不是：

• 一块上至少有一块瓷砖的块永远不会有问题。
• 没有瓷砖的块和邻居（左，右或两者）也没有瓷砖，总是有问题的。
• 当且仅当C[k+1].left - C[k-1].right > D ，没有瓦片的块C[k]与邻居C[k-1]和C[k+1]都具有瓦片是有问题的C[k+1].left - C[k-1].right > D

而且，跳入解决问题的部分：

• 当且仅当存在至少一个有问题的块时，我们需要更多的瓦片来完成轨道。

因此，处理O(X)位置的问题现在只处理O(N)块。 哪个好。

实施细节

在块数组中，每个块C[k]将具有以下属性：

• 布尔problematic ，初始化为true 。
• 整数left ，初始化为-1 。
• 整数right ，初始化为-1 。

此外，还会有一个problematicCounter ，初始化为数组C的元素数量。 这将打下来，当它达到零时，我们知道我们不需要更多的瓷砖。

算法如下：

if (X/D > N+1) return -1;  // Taking care of rounding is left as an exercise

Let C = array of chunks as described above

For each C[k] // This is the O(X/D) part
{
  Let C[k].problematic = true
  Let C[k].left = -1
  Let C[k].right = -1
}

Let problematicCounter = number of elements in array C

Let C[k] be the chunk that contains position 0 (usually the first one, but I'll leave open the possibility of "sentinel" chunks)
Let C[k].problematic = false
Let C[k].left = 0
Let C[k].right = 0
Decrement problematicCounter

// The following steps would require tweaking if there is one single chunk on the track
// I do not consider that case as that would imply D >= 2*N, which is kind of ridiculous for this problem
Let C[k] be the chunk containing position X (the last position on the track)
Let C[k].problematic = false
Let C[k].left = X
Let C[k].right = X
Decrease problematicCounter

// Initialization done. Now for the loop.
// Everything inside the loop is O(1), so the loop itself is O(N)
For each A[i] in array A (the array specifying which tile to place in second i)
{
  Let C[k] be the chunk containing position A[i]

  If C[k].problematic == true
  {
    Let C[k].problematic = false;
    Decrement problematicCounter
  }

  If C[k].first == -1 OR C[k].first > A[i]
  {
    Let C[k].first = A[i]

    // Checks that C[k-1] and C[k-2] don't go off array index bounds left as an exercise
    If C[k-1].problematic == true AND C[k-2].last <> -1 AND C[k].first - C[k-2].last <= D
    {
      Let C[k-1].problematic = false
      Decrement problematicCounter
    }

  If C[k].last == -1 OR C[k].last < A[i]
  {
    Let C[k].last = A[i]

    // Checks that C[k+1] and C[k+2] don't go off array index bounds left as an exercise
    If C[k+1].problematic == true AND C[k+2].first <> -1 AND C[k+2].first - C[k].last <= D
    {
      Let C[k+1].problematic = false
      Decrement problematicCounter
    }

    If problematicCounter == 0 Then return k // and forget everything else
}

return -1