我的代码看起来很完美，但显示错误的输出。有人可以帮我我在这里做错了什么吗？

Question

我必须返回数组中连续 seq 的最大 len。 考虑这个例子：-

N = 7
a[] = {2,6,1,9,4,5,3}

我的代码应该返回 6，但它给出 1。不知道怎么做？

int findLongestConseqSubseq(int arr[], int N)

 {
    //Your code here
    unordered_map<int,int> mp;
    int ans=0;
    for(int i=0;i<N;i++){
        if(mp.count(arr[i])>0){
            continue;
        }
       int len1=mp[arr[i]-1];
       int len2=mp[arr[i]+1];
       int ns=len1+len2+1;
       ans=max(ans,ns);
       mp[arr[i]-len1]=ns;
       mp[arr[i]+len2]=ns;
      // ans=max(ans,ns);
       }
     return ans;
  }

Answer 1

您的实现存在两个问题。

第一个问题是代码：

        if(mp.count(arr[i])>0){
            continue;
        }

此代码不足以确保重复的数字不会进入循环的其余部分（要了解为什么会这样，请考虑len1 或len2 都不为零时会发生什么。

您可以将其替换为：

        if(!mp.insert(pair<int,int>(arr[i], 1)).second) {
            continue;
        }

如果存在arr[i] 的条目，这将跳过循环的其余部分，但也会确保在计算 if 表达式后存在条目。

第二个问题是代码：

       int len1=mp[arr[i]-1];
       int len2=mp[arr[i]+1];

C++ 中映射的下标运算符具有创建条目（如果条目不存在）的副作用。这对您的算法来说是有问题的，因为您不希望这种情况发生。如果这样做会导致前一段代码跳过不应该的数字。解决方案是使用find，但由于此代码有点难看（恕我直言），编写辅助函数可能更简洁：

inline int findOrDefault(const unordered_map<int, int>& map, int key, int defaultValue) {
    auto find = map.find(key);
    return (find == map.end()) ? defaultValue : find->second;
}

并使用它来更新您的代码：

        int len1=findOrDefault(mp, arr[i]-1, 0);
        int len2=findOrDefault(mp, arr[i]+1, 0);

将所有这些放在一起，您最终会得到：

inline int findOrDefault(const unordered_map<int, int>& map, int key, int defaultValue) {
    auto find = map.find(key);
    return (find == map.end()) ? defaultValue : find->second;
}

int findLongestConseqSubseq(int arr[], int N)
{
    unordered_map<int,int> mp;
    int ans=0;
    for(int i=0;i<N;i++){
        if(!mp.insert(pair<int,int>(arr[i], 1)).second) {
            continue;
        }
        int len1=findOrDefault(mp, arr[i]-1, 0);
        int len2=findOrDefault(mp, arr[i]+1, 0);
        int ns=len1+len2+1;
        ans=max(ans,ns);
        mp[arr[i]-len1]=ns;
        mp[arr[i]+len2]=ns;
    }
    return ans;
}

Answer 2

好的，有时间再看一遍，我想出了这个。首先，我们对数组进行排序以使事情变得更容易。然后我们可以一次通过数字，每次下一个连续数字大一时计数。如果排序后下一个数字不是大一，那么我们重置并重新开始计数，将最高的连续计数存储在 max 中。

#include <iostream>
#include <algorithm>
#include <iterator>

using namespace std;


int main()
{


    cout << "Get Longest Consecutive Streak: " << endl;

    

    int intArray[] = { 9, 1, 2, 3, 4, 6, 8, 11, 12, 13, 14, 15 ,16 };

    int arrayLength = size(intArray);    

    sort(intArray, intArray + arrayLength); //Sort Array passing in array twice plus amount of indexes in array

    cout << "Sorted Array looks like this:" << endl; //Outputting sorted array to check
    for (int i = 0; i < arrayLength; i++) {
        cout << intArray[i] << " ";
    }

    cout << endl;


    int count = 1;
    int max = 1;

    /*
    * Loop through array, if the next number is one greater than current then add to count
    * If it is not, reset the count.
    * Store highest count value found passing through.
    * */

    for (int i = 0; i < arrayLength -1; i++) { 
        if (intArray[i + 1] == intArray[i] + 1) { //checking next value - is it equal to this one + 1?
            count++;
        }
        else { //else if it is not, store the value if it is higher that what is currently there, then reset
            if (max < count) {
                max = count;
            }
            count = 1;
        }
        
    }

    //Edge case: check again one more time if the current count (when finishing) is greater than any previous
    if (max < count) {
        max = count;
    }


    cout << "Longest Consecutive Streak:" << endl;
    cout << max << endl;

    

    return 0;



}