找到具有不同整数的最长子数组答案

【问题标题】：Find the longest subarray with distinct integers找到具有不同整数的最长子数组
【发布时间】：2016-03-09 03:30:16
【问题描述】：

编写一个方法，该方法接受一个整数数组并返回其最长子数组的长度，该子数组具有不同的整数。

例如[1,2,3,4,2,3] 应该返回 4。

【问题讨论】：

有趣的问题。

【解决方案1】：

我使用 HashSet 来跟踪从索引 i 到索引 j 的所有元素，并在遍历列表时保留一个计数器。线性运行时间和空间：

public static int longestSubarray(int[] arr) {
    
    int i = 0, j = 1, max = 0, currLength = 1;
    max = Math.max(max, currLength);
    HashSet<Integer> set = new HashSet<Integer>();
    set.add(arr[0]);
    
    while (i < arr.length - 1 && j < arr.length) {
        if (!set.contains(arr[j])) {
            currLength++;
            set.add(arr[j++]);
        }
        else {
            set.remove(arr[i++]);
            currLength--;
        }
    }
    
    return Math.max(currLength, max);
}

【讨论】：

似乎对于 [1,2,3,2,3] 它给出了 2 而不是 3 的错误结果。或者我错过了一些东西。

【解决方案2】：

public int[] getLargestSubArray(int[] array) {
    int length = array.length;
    Set<Integer> set = new HashSet<>();
    int longest = 0;
    int start = 0;

    int longestCurrent = 0;
    int startCurrent = 0;

    int j = 0;
    while (j < length) {
        if (!set.contains(array[j])) {
            set.add(array[j]);
            longestCurrent++;

            if (longestCurrent > longest) {
                longest = longestCurrent;
                start = startCurrent;
            }
            j++;
        } else {
            while (startCurrent < j) {
                longestCurrent--;
                if (array[startCurrent++] == (array[j])) {
                    break;
                }
            }
            set.remove(array[j]);
        }
    }
    int[] longestSubSequence = new int[longest];
    System.arraycopy(array, start, longestSubSequence, 0, longest);
    return longestSubSequence;
}

【讨论】：

【解决方案3】：

public static int sizeOfLongestDistinctSubArrayO1(int[] arr) {
    int max = 0;
    Map<Integer, Integer> counts = new HashMap<>();
    int cur = 0;
    int prev = 0;
    for (int i = 0, len = arr.length; i < len; i++) {
        if (counts.containsKey(arr[i])) {
            int j = counts.get(arr[i]);
            max = Math.max(max, cur);
            prev = Math.max(j, prev);
            cur = i - prev;
            counts.put(arr[i], i);
        } else {
            cur++;
            counts.put(arr[i], i);
        }
    }
    return Math.max(max, cur);
}

【讨论】：

【解决方案4】：

python版本

#!/usr/bin/env python3

input = [1,2,3,4,2,3,4,5,6,7,3,4]
tmp_list = []
max = 0

for i in input:
    if i not in tmp_list:
        tmp_list.append(i)
    else:
        max = len(tmp_list) if len(tmp_list) > max else max
        tmp_list = [i]

print (max if max >= len(tmp_list) else len(tmp_list))

【讨论】：

哎呀没有注意到java标签:(，但传达了算法

【解决方案5】：

public int lengthOfLongestSubarray(int[] arr) {
        
    int max = 0; // Maximum length of subarray with unique elements
    Map<Integer,Integer> map = new HashMap<>();
    // let longest subarray starts at i and ends at j
    for(int i = -1,j = 0; j < arr.length;j++) {
        if(map.containsKey(arr[j])) {
            i = Math.max(i,map.get(arr[j]));
        }
        max = Math.max(max,j-i);
        map.put(arr[j],j);
    }
    return max;
}

【讨论】：

【解决方案6】：

C#版本

核心逻辑：

private static int Solve(string s) {
    var dict = new Dictionary < string,int > ();
    var arr = s.Split(" ", StringSplitOptions.RemoveEmptyEntries);
    var start = 0;
    var substrLen = 0;
    for (var i = 0; i < arr.Length; i++) {
        if (dict.ContainsKey(arr[i])) {
            substrLen = substrLen < i - start ? i - start: substrLen;
            var tempStart = dict[arr[i]] + 1;
            for (var j = dict[arr[i]]; j > start; j--) {
                dict.Remove(arr[i]);
            }

            start = tempStart;
            dict[arr[i]] = i;
        }
        else {
            dict.Add(arr[i], i);
        }
    }

    return dict.Count;
}

完整代码here

【讨论】：

【解决方案7】：

import java.util.*; 
class GFG{ 
static int largest_subarray(int a[], int n) 
{ 
HashSet<Integer> set = new HashSet<Integer>(); 
int ans = 0; 
int counter = 0;
for(int i = 0; i < n; i++) 
{ 
  if(set.contains(a[i])){
     set.clear();
     counter =0;
     }
     set.add(a[i]);
     counter++;
     ans = Math.max(ans, counter);
     
   } 
// Return final ans 
return ans; 
} 

// Driver Code 
public static void main(String[] args) 
{ 
int arr[] = { 1, 2, 4, 4, 5, 6, 7, 8, 3, 4, 5, 3, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4 
}; 
int n = arr.length; 
System.out.print(largest_subarray(arr, n)); 
} 
}

【讨论】：