קלענסטער סובאַררייַ מיט ק דיסטינקט נומערן  


שוועריקייט לעוועל שווער
אָפט געבעטן אין אַמאַזאָן גוגל
מענגע האַש סליידינג ווינדאָו צוויי טייַטל

רעכן איר האָבן אַ ינטאַדזשער מענגע און אַ נומער ק. די פּראָבלעם ויסזאָגונג פרעגט צו געפֿינען אויס דער קלענסטער סאַב-מענגע פון ​​די קייט ינקלוסיוולי, אין אַזאַ אַ וועג, עס זענען פּונקט ק באַזונדער נומערן אין דעם קלענסטער סאַב-מענגע.

בייַשפּיל  

ינפּוט:

{1, 2, 2, 3, 4, 5, 5}

k = 3

אָוטפּוט:

קסנומקס, קסנומקס

דערקלערונג:

{2, 3, 4} איז דער קלענסטער סאַב-מענגע סטאַרטינג פֿון 2nd אינדעקס צו 4th אינדעקס מיט ק הייסט, 3 בוילעט עלעמענטן.

ינפּוט:

{2, 5, 6, 7}

k = 2

אָוטפּוט:

קסנומקס, קסנומקס

דערקלערונג:

{2, 5} איז דער קלענסטער סאַב-מענגע סטאַרטינג פון 2 אינדעקס צו 3 אינדעקס מיט ק י.ע., 2 בוילעט עלעמענטן.

אַלגאָריטהם  

  1. שטעלן די בוילעט עלעמענט צו 0 און לינקס זייַט און רעכט זייַט פּוינטערז צו -1.
  2. דורכגיין דורך די מענגע,
  3. ינקרעמענטינג די רעכט זייַט דורך 1, אויב קיין פון די פאַרשידענע עלעמענטן איז ווייניקער ווי די געגעבן נומער k,
  4. דערנאָך פאַרגרעסערן די ציילן און קראָם די אָפטקייַט פון מענגע עלעמענט אין די מאַפּע.
  5. אויב באַזונדער עלעמענטן זענען גלייַך צו די געגעבן נומער ק און די אַזוי געגרינדעט לענג איז קלענערער ווי די ביז אַהער דערהייַנטיקט לענג, די לינקס און רעכט זייַט ווייזט און ברעכן.
  6. אויב די נומער פון פאַרשידענע עלעמענטן געפֿונען צו זיין ווייניקער ווי ק, ברעכן.
  7. קאָנטראָלירן צי די נומער פון פאַרשידענע עלעמענטן געפֿונען צו זיין גלייַך צו ק, און פאַרגרעסערן די רעכט זייַט פּוינטערז.
  8. אויב באַזונדער עלעמענטן זענען גלייַך צו די געגעבן נומער ק און די אַזוי געגרינדעט לענג איז קלענערער ווי די ביז אַהער דערהייַנטיקט לענג, די לינקס און רעכט זייַט ווייזט און ברעכן.
  9. קאָנטראָלירן אויב די אָפטקייַט פון דעם עלעמענט איז געפֿונען צו זיין 1 און דאַן באַזייַטיקן דעם עלעמענט פֿון דער מאַפּע, אַנדערש רעדוצירן די ציילן פון די אָפטקייַט
  10. אויב די לינקס זייַט טייַטל איז געפֿונען צו זיין 0 און די רעכט זייַט איז גלייַך צו n, עס מיטל אַז עס איז פאַרקריפּלט.
  11. אַנדערש, דרוקן די לינקס זייַט און רעכט זייַט וואַלועס.
זע אויך
קאָרעוו סאָרט עריי לעעטקאָדע סאַלושאַן

דערקלערונג  

סטאָרד יעדער מענגע עלעמענטן אָפטקייַט בשעת טראַווערסינג די מענגע, און קלייַבן יעדער מענגע עלעמענט, און טשעק אויב מאַפּע גרייס איז ווייניקער ווי ק אויב עס איז געפֿונען ווייניקער ווי ק ווי מיר דאַרפֿן צו ציילן און קראָם די אָפטקייַט פון דעם מענגע עלעמענט און אויב די די מאַפּע גרייס איז ק (באַזונדער עלעמענט נומער) און די קראַנט לענג איז ווייניקער ווי די פריערדיקע לענג פון די סאַב-מענגע, און מיר וועלן דערהייַנטיקן די לינקס זייַט און רעכט זייַט פּוינטערז. דאָס אַלץ וועט גיין אין אַ שלייף ביז די גאנצע מאַפּע איז דורכגעקאָכט אַמאָל.

אויב די גרייס פון אַ מאַפּע איז ווייניקער ווי ק, ברעכן. מיר האָבן די וואַלועס אויף אַ מאַפּע. שלייף וועט גיין ביז די גרייס פון די מאַפּע געפֿונען צו זיין גלייך צו ק, די אָפטקייַט פון די מענגע עלעמענט אין אַ מאַפּע איז געפֿונען צו זיין גלייַך צו 1, מיר דאַרפֿן צו באַזייַטיקן דעם באַזונדער עלעמענט פֿון דער מאַפּע, אַנדערש מיר דאַרפֿן אָפטקייַט פון דעם באַזונדער עלעמענט פֿון אַ מאַפּע. ווידער מיר וועלן קאָנטראָלירן צי די מאַפּע גרייס איז גלייַך צו ק און די לענג פון די קראַנט סאַב-מענגע איז ווייניקער ווי די ביז אַהער דערהייַנטיקט לענג. דערהייַנטיקן די לינקע זייַט און רעכט זייַט פּוינטערז. אויב די אָפטקייַט פון די מענגע עלעמענט איז 1, באַזייַטיקן דעם עלעמענט אַנדערש און פאַרקלענערן די אָפטקייַט פון די עלעמענט.

נאָך די דורכפאָר פון די מענגע, אויב די לינקס זייַט טייַטל איז געפֿונען צו זיין 0 און די רעכט זייַט טייַטל צו n, דאָס מיטל אַז עס איז אַ פאַרקריפּלט ק. אַנדערש דרוקן די ווערט פון די לינקס און רעכט זייַט טייַטל, וואָס וואָלט זיין די סטאַרטינג פונט און סאָף פונט פון די סמאָלאַסט סאַב-מענגע ינקלוסיוולי.

זע אויך
גילטיק סודאָקו

ימפּלעמענטאַטיאָן  

C ++ פּראָגראַם פֿאַר סמאָלאַסט סובאַררייַ מיט די דיסטינקט נומערן # אַרייַננעמען

#include<map>

using namespace std;

void getSmallestSubarray(int arr[], int n, int k)
{
    int left = 0, right = n;
    int j = -1;
    map<int, int> MAP;
    for (int i=0; i<n; i++)
    {
        while (j < n)
        {
            j++;
            if (MAP.size() < k)
                MAP[arr[j]]++;

            if (MAP.size() == k && ((right - left) >= (j - i)))
            {
                left = i;
                right = j;
                break;
            }

        }
        if (MAP.size() < k)
            break;

        while (MAP.size() == k)
        {
            if (MAP[arr[i]] == 1)
                MAP.erase(arr[i]);
            else
                MAP[arr[i]]--;

            i++;

            if (MAP.size() == k && (right - left) >= (j - i))
            {
                left = i;
                right = j;
            }
        }
        if (MAP[arr[i]] == 1)
            MAP.erase(arr[i]);
        else
            MAP[arr[i]]--;
    }
    if (left == 0 && right == n)
        cout << "Invalid k" << endl;
    else
        cout << left << " " << right;
}
int main()
{
    int arr[] = {1, 2, 2, 3, 4, 5, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    getSmallestSubarray(arr, n, k);
    return 0;
}
2 4

Java פּראָגראַם פֿאַר סמאָלאַסט סובאַררייַ מיט די דיסטינקט נומערן

import java.util.HashMap;
import java.util.Map;
class smallestSubArray
{
    public static void getSmallestSubarray(int arr[], int n, int k)
    {
        int left = 0, right = n;
        int j = -1;
        HashMap<Integer, Integer> MAP=new HashMap<>();
        for (int i=0; i<n; i++)
        {
            while (j < n-1)
            {
                j++;
                if (MAP.size() < k)
                {

                    if(MAP.containsKey( arr[j] ))
                        MAP.put( arr[j], MAP.get( arr[j] ) + 1 );
                    else
                        MAP.put(arr[j],1);
                }

                if (MAP.size() == k && ((right - left) >= (j - i)))
                {
                    left = i;
                    right = j;
                    break;
                }
            }
            if (MAP.size() < k)
                break;

            while (MAP.size() == k)
            {
                if (MAP.get(arr[i]) == 1)
                    MAP.remove(arr[i]);
                else
                    MAP.put(arr[i], MAP.get(arr[i])-1);

                i++;

                if (MAP.size() == k && (right - left) >= (j - i))
                {
                    left = i;
                    right = j;
                }
            }
            if (MAP.get(arr[i]) == 1)
                MAP.remove(arr[i]);
            else
                MAP.put(arr[i], MAP.get(arr[i])-1);
        }
        if (left == 0 && right == n)
            System.out.println("Invalid k");
        else
            System.out.println(left+" "+right);
    }
    public static void main(String [] args)
    {
        int arr[] = {1, 2, 2, 3, 4, 5, 5};
        int n = arr.length;
        int k = 3;
        getSmallestSubarray(arr, n, k);

    }
}
2 4

קאַמפּלעקסיטי אַנאַליסיס פֿאַר סמאָלאַסט סובאַררייַ מיט די דיסטריביאַטאַד נומערן  

צייט קאַמפּלעקסיטי

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין דער מענגע.

זע אויך
גראף פּערז וועמענס פּראָדוקטן עקסיסטירן אין עריי

ספעיס קאַמפּלעקסיטי

אָ (N) ווו “N” איז די נומער פון עלעמענטן אין דער מענגע.