使用仅列表作为参数的递归方法，找到具有重复元素的传染子阵列的最大长度

Question

问题： 找到具有重复元素的传染子阵列的最大长度。
例如：
[1 2 2 2 3 3 5 1 8] - 答案是3，因为2重复3次是最大重复时间。
[1 2] - 答案是1
[1 2 2 3 3] - 答案为2

，但是递归函数应仅具有列表作为参数。

int findmaxContagiousRepeatEdlength（list＆lt; integer＆gt; list）

我尝试过的内容：

class Answer
{
    public static int findMaxContagiousRepeatedLength(List<Integer> nums, int currentCount, int latestNumber)
    {
        if (nums.isEmpty())
            return 0;

        if (nums.get(0) == latestNumber) {
            return Math.max(currentCount+1, findMaxContagiousRepeatedLength(nums.subList(1, nums.size()), currentCount+1, nums.get(0)));
        } else {
            return findMaxContagiousRepeatedLength(nums.subList(1, nums.size()), 1, nums.get(0));
        }
    }

    public static void main(String[] args)
    {
        Integer[] nums = { 1,2,1,1,1,1,1,2,3,2,3,1,2,2};

        System.out.println("Max length: " +
                findMaxContagiousRepeatedLength(Arrays.asList(nums), 0, nums.length == 0 ? -1 : nums[0]));
    }
}

上述确实有效，但不符合参数限制的要求。 请帮助我弄清楚是否有可能有一个解决方案，其中递归功能只有列表作为参数。

Answer 1

最佳解决方案

使用您的功能

public static int findMaxContagiousRepeatedLength(List<Integer> nums, int currentCount, int latestNumber)
{
    if (nums.isEmpty())
        return 0;

    if (nums.get(0) == latestNumber) {
        return Math.max(currentCount+1, findMaxContagiousRepeatedLength(nums.subList(1, nums.size()), currentCount+1, nums.get(0)));
    } else {
        return findMaxContagiousRepeatedLength(nums.subList(1, nums.size()), 1, nums.get(0));
    }
}

并制作第二个功能，该功能使用默认参数调用您的函数

public static int findMaxContagiousRepeatedLength(List<Integer> nums)
{
    return findMaxContagiousRepeatedLength(Arrays.asList(nums), 0, nums.length == 0 ? -1 : nums[0]);
}

，现在您可以调用第二个功能，该功能将带有默认参数的第一个函数！

Answer 2

首先，只需浏览列表即可最好地解决此问题。
但是，如果您必须将递归与list＆lt; integer＆gt;作为唯一可以使用以下参数：

   public static int findMaxContiguousRepeatedLength(List<Integer> nums) {
        if (nums.isEmpty()) {
           return 0;
        }
        Iterator<Integer> it = nums.iterator();
        Integer start = it.next();
        int len = 1, pos = 1;
        while (it.hasNext()) {
           Integer curr = it.next();
           if (curr == start) {
               pos++;
               len++;
           } else {
               break;
           }
        }
        return Math.max(len,  findMaxContiguousRepeatedLength(nums.subList(pos,nums.size())));
        
    }

Answer 3

如果允许您（暂时）修改列表，则以下方法也将起作用：

public static int findMaxContiguousRepeatedLength(List<Integer> nums) {
    if (nums.isEmpty()) {
        return 0;
    }

    // carve out repeated chunk from back
    Integer back = nums.remove(nums.size() - 1);
    int repeats = 1;
    while(!nums.isEmpty() && nums.get(nums.size() - 1) == back) {
        nums.remove(nums.size() - 1);
        repeats++;
    }

    int res = Math.max(repeats, findMaxContiguousRepeatedLength(List<Integer> nums));
    while(repeats) { // restore
        repeats--;
        nums.add(back);
    }

    return res;   
}