LeetCode-RLE Iterator

最新推荐文章于 2021-04-21 14:18:05 发布

BeHelium

最新推荐文章于 2021-04-21 14:18:05 发布

阅读量349

点赞数

分类专栏： LeetCode 文章标签： LeetCode Java

本文链接：https://blog.csdn.net/qq_24133491/article/details/82556801

版权

LeetCode 专栏收录该内容

306 篇文章 0 订阅

订阅专栏

Description：
Write an iterator that iterates through a run-length encoded sequence.

The iterator is initialized by RLEIterator(int[] A), where A is a run-length encoding of some sequence. More specifically, for all even i, A[i] tells us the number of times that the non-negative integer value A[i+1] is repeated in the sequence.

The iterator supports one function: next(int n), which exhausts the next n elements (n >= 1) and returns the last element exhausted in this way. If there is no element left to exhaust, next returns -1 instead.

For example, we start with A = [3,8,0,9,2,5], which is a run-length encoding of the sequence [8,8,8,5,5]. This is because the sequence can be read as “three eights, zero nines, two fives”.

Example 1:

Input: [“RLEIterator”,”next”,”next”,”next”,”next”], [[[3,8,0,9,2,5]],[2],[1],[1],[2]]
Output: [null,8,8,5,-1]
Explanation:

RLEIterator is initialized with RLEIterator([3,8,0,9,2,5]).
This maps to the sequence [8,8,8,5,5].
RLEIterator.next is then called 4 times:

.next(2) exhausts 2 terms of the sequence, returning 8.  The remaining sequence is now [8, 5, 5].

.next(1) exhausts 1 term of the sequence, returning 8.  The remaining sequence is now [5, 5].

.next(1) exhausts 1 term of the sequence, returning 5.  The remaining sequence is now [5].

.next(2) exhausts 2 terms, returning -1.  This is because the first term exhausted was 5,
but the second term did not exist.  Since the last term exhausted does not exist, we return -1.

Note:

0 <= A.length <= 1000
A.length is an even integer.
0 <= A[i] <= 10^9
There are at most 1000 calls to RLEIterator.next(int n) per test case.
Each call to RLEIterator.next(int n) will have 1 <= n <= 10^9.

题意：给定一个数组，偶数位表示下一个位置的数字出现的次数，奇数位表示数字；例如给定数组A=[3,8,0,9,2,5]表示的结果序列应当是有3个8、0个9、和2个5，即sequence=[8,8,8,5,5]；现要求模拟迭代器，构建next函数，实现遍历sequence；

解法：一开始我的想法是先把给定的数组A转换为sequence序列保存在List中，此后再定义一个位置下标index来实现迭代过程；但是题目中说明了0 <= A[i] <= 10^9；因此会出现Memory Limit Exceeded的问题；所以，我们只能够利用原数组A来实现；
我们可以定义两个变量，index用于表示在数组A中的位置，cnt用于表示此时在index处已经遍历过的index+1处的数字的个数；每次调用next(n)函数时，我们需要令cnt增加n后找到满足其大小的index处；需要注意的是index只处在数组A的偶数位；

Java

class RLEIterator {
    private int[] sequence;
    private int index;
    private int cnt;

    public RLEIterator(int[] A) {
        this.sequence = A;
        this.index = 0;
        this.cnt = 0;
    }

    public int next(int n) {
        this.cnt += n;
        while (index < this.sequence.length && this.cnt > this.sequence[index]) {
            this.cnt -= this.sequence[index];
            index += 2;
        }
        if (index >= this.sequence.length) {
            return -1;
        }
        if (index < this.sequence.length) {
            return this.sequence[index + 1];
        }
        return -1;
    }
}

/**
 * Your RLEIterator object will be instantiated and called as such:
 * RLEIterator obj = new RLEIterator(A);
 * int param_1 = obj.next(n);
 */