Question

一些背景

上周我在我的教科书中遇到了一个问题，它告诉我生成20个随机数，然后在相同的连续数字周围加上括号考虑我的程序输出的以下内容

697342(33)(666)(44)69(66)1(88)

我需要做什么

下一个问题是基本上获得这些单词的最长序列并在它们周围加上括号。如果你有

1122345(6666)

基本上你需要将括号括在四个6的左右，因为它们最常发生。我在我正在研究的章节（阵列和阵列列表）中完成了所有其他问题，但我似乎无法想出这个问题。

以下是我用括号括起连续数字的解决方案：

class Seq
{
    private ArrayList<Integer> nums;
    private Random randNum;
    public Seq()
    {
        nums = new ArrayList<Integer>();
        randNum = new Random();
    }
    public void fillArrList()
    {
        for (int i = 0 ; i < 20 ; i++)
        {
            int thisRandNum = randNum.nextInt(9)+1;
            nums.add(thisRandNum);
        }
    }

    public String toString() {
        StringBuilder result = new StringBuilder();
        boolean inRun = false;
        for (int i = 0; i < nums.size(); i++) {
            if (i < nums.size() - 1 && nums.get(i).equals(nums.get(i + 1))) {
                if (!inRun) {
                    result.append("(");
                }
                result.append(nums.get(i));
                inRun = true;

            } else {
                result.append(nums.get(i));
                if (inRun) {
                    result.append(")");
                }
                inRun = false;

            }
        }
        return result.toString();
    }
}

我的想法

遍历整个列表。创建一个计数变量，用于跟踪彼此连续的数量。 I.e 22的计数为2。 444计算3 接下来制作一个oldCount，将当前count与oldCount进行比较。如果我们的新count大于oldCount

，我们只想继续

之后我们需要一种方法来获取最大count变量的起始索引，以及结束。

我的思维方式是否正确？因为我在比较它们时无法更新oldCount和count变量，因为值不断变化。 我不是在寻找代码，而是在寻找一些有价值的提示。

我的计数正在重置

int startIndex, endIndex = 0;
        int count = 0;
        int oldCount = 0;

            for(int i = 0 ; i < nums.size(); i++)
            {
                if(nums.get(i) == nums.get(i+1) && count >= oldCount)
                {
                    count++;
                }
                oldCount = count;
            }

Answer 1

您建议的方式可行。然后，如果newcount大于oldcount，您将需要在另一个变量中存储一个额外的数字 - 最长序列开始的位置的索引。

然后，你可以去插入（在该索引的位置。

即。如果你有11223456666。

最大的序列以第一个数字6开始。即在索引7处，因此将7存储在变量中。

Answer 2

我认为你需要迭代整个列表，即使当前计数低于oldCount，例如， 111224444？

在迭代列表时保留4个变量：highestStartIndex，highestEndIndex，highestCount和currentCount。迭代整个列表并使用currentCount计算相等的相邻数字。当完成的currentCount高于highestCount时，更新最高*变量。最后使用* Index变量用paranthesis写出数字。

Answer 3

只有在走完所有元素后，您才会知道最长的子序列。

11222333333444555
11222(333333)444555

因此，只有在循环之后，您才能插入两个括号。

所以你必须保持局部最优：开始指数加上长度或最后的最佳指数。然后为每个序列提供当前序列的起始索引。

提问：

最佳状态（序列）和当前状态是两件事。人们不能提前说任何现状都是最终的最佳状态。

public String toString() {
    // Begin with as "best" solution the empty sequence.
    int startBest = 0; // Starting index
    int lengthBest = 0; // Length of sequence

    // Determine sequences:
    int startCurrent = 0; // Starting index of most current/last sequence
    for (int i = 0; i < nums.size(); i++) {
        // Can we add the current num to the current sequence?
        if (i == startCurrent || nums.get(i).equals(nums.get(i - 1)))) {
            // We can extend the current sequence with this i:
            int lengthCurrent = i - startCurrent + 1;
            if (lengthCurrent > lengthBest) { // Current length better?
                // New optimum:
                startBest = startCurrent;
                lengthBest = lengthCurrent;
            }
        } else {
            // A different num, start here.
            // As we had already a real sequence (i != 0), no need for
            // checking for a new optimum with length 1.
            startCurrent = i;
        }
    }
    // Now we found the best solution.
    // Create the result:
    StringBuilder result = new StringBuilder();
    for (int i = 0; i < nums.size(); i++) {
        result.append(nums.get(i));
    }
    // Insert the right ')' first as its index changes by 1 after inserting '('.
    result.insert(startBest + lengthBest, ")");
    result.insert(startBest, "(");
    return result.toString();
}

第一个问题是如何找到序列的结尾，并设置正确的序列开始。

原始算法的问题是只处理了一个序列（一个子序列开始）。

查找arraylist

3 个答案: