如何建造一条无延迟投掷器链––MCBE 计划刻机制详解

/*copyright @hhhxiao*/

#include <algorithm>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
struct BlockPos {
    int x, y, z;
    bool operator==(const BlockPos& p) const {
        return x == p.x && y == p.y && z == p.z;
    }
};
struct BlockTick {
    int tick;
    BlockPos pos;
    int priorityOffset;
    bool operator<(const BlockTick& rhs) const {
        if (tick < rhs.tick || tick > rhs.tick)
            return this->tick < rhs.tick;
        else
            return this->priorityOffset < rhs.priorityOffset;
    }
    bool operator>(const BlockTick& rhs) const {
        if (tick < rhs.tick || tick > rhs.tick)
            return this->tick > rhs.tick;
        else
            return this->priorityOffset > rhs.priorityOffset;
    }
    inline void tickBlock() { printf("%-2d | ", pos.x); }
};
class MovePriorityQueue {
   public:
    size_t size() const { return heap_.size(); }
    bool empty() const { return heap_.empty(); }
    BlockTick top() { return heap_.front(); }
    BlockTick pop() {
        std::pop_heap(heap_.begin(), heap_.end(), std::greater<BlockTick>());
        auto tick = heap_.back();
        heap_.pop_back();
        return tick;
    }
    void push(const BlockTick& tick) {
        heap_.push_back(tick);
        std::push_heap(heap_.begin(), heap_.end(), std::greater<BlockTick>());
    }
   private:
    std::vector<BlockTick> heap_;
};
struct BlockTickingQueue {
    MovePriorityQueue nextTickQueue;
    MovePriorityQueue activeTickQueue;
    void add(const BlockTick& tick) { this->nextTickQueue.push(tick); }
    void tick() {
        while (!nextTickQueue.empty()) {
            auto tick = nextTickQueue.pop();
            activeTickQueue.push(tick);
        }
        while (!activeTickQueue.empty()) {
            /* code */
            auto t = activeTickQueue.top();
            t.tickBlock();
            activeTickQueue.pop();
        }
    }
};
int main() {
    for (int n = 1; n <= 99; n++) {
        BlockTickingQueue q;
        printf("| ");
        for (int i = 0; i < n; i++) {
            BlockTick t = {0, {i + 1, 0, 0}, 0};
            q.add(t);
        }
        q.tick();
        printf("\n");
    }
    return 0;
}

template <class _RandomAccessIterator, class _Distance, class _Tp, 
          class _Compare>
void
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
            _Distance __topIndex, _Tp __value, _Compare __comp)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}

template <class _RandomAccessIterator, class _Compare,
          class _Distance, class _Tp>
inline void 
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Compare __comp,
                _Distance*, _Tp*) 
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0), 
              _Tp(*(__last - 1)), __comp);
}

template <class _RandomAccessIterator, class _Compare>
inline void 
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
          _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  __push_heap_aux(__first, __last, __comp,
                  __DISTANCE_TYPE(__first), __VALUE_TYPE(__first));
}

template <class _RandomAccessIterator, class _Distance, class _Tp>
void 
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value);
}

def adjustList(l):
    d = len(l)-1
    h = 0
    s = h*2 + 2
    while s < d:
        l[h] = l[s]
        h = s
        s = h*2 + 2
    if s == d:
        l[h] = l[s-1]
        h = s - 1
    l[h] = l.pop(-1)

def operation(l):
    t = []
    while len(l) > 1:
        t.append(l[0])
        adjustList(l)
    t.append(l[0])
    return t

def getOrder(num):
    r = []
    l = operation(list(range(num)))
    for i in l:
        r.append(l[i]+1)
    return r

print(getOrder(128))