ተደጋጋሚ ንዑስ ክፍል ከፍተኛ ርዝመት  


የችግር ደረጃ መካከለኛ
ውስጥ በተደጋጋሚ ተጠየቀ በእርግጥም Karat Roblox
ሰልፍ የሁለትዮሽ ፍለጋ ተለዋዋጭ ፕሮግራም ሃምሽንግ

በችግር ላይ “የተደጋገመ ንዑስ ረድፍ ከፍተኛው ርዝመት” ሁለት ድርድር ድርድር 1 እና ድርድር 2 ሰጥተናል ፣ የእርስዎ ተግባር በሁለቱም ውስጥ የሚታየውን ንዑስ ድርድር ከፍተኛውን ርዝመት መፈለግ ነው ፡፡ ድርድሮች.

ለምሳሌ  

ግቤት

[1,2,3,2,1]
[3,2,1,4,7]

ውጤት

3

ማብራሪያ:

ምክንያቱም ንዑስ-ድርድር ከፍተኛው ርዝመት 3 ሲሆን የጋራ ድርድር ደግሞ [3,2,1] ነው

ተደጋጋሚ ንዑስ ክፍል ከፍተኛ ርዝመትጭንቅላታም መያያዣ መርፌ

አልጎሪዝም  

  1. ውፅዓት ወደ 0 ያቀናብሩ ፡፡
  2. ከእውነተኛው የግብዓት ድርድር ርዝመት 1 በላይ በሆነ ርዝመት አንድ ተለዋዋጭ የቁጥር ብዛት ያውጅ።
  3. የድርድር የመጨረሻ ማውጫ ድርድር 1 [i] ከድርድር 2 [j] ጋር እኩል መሆኑን ያረጋግጡ ፣ እውነት ከሆነ ከዚያ val [i] [j] = val [i + 1] [j + 1] +1.
  4. ውፅዓት ከቫል [i] [j] ያነሰ መሆኑን ያረጋግጡ ከዚያ ውፅዓት = val [i] [j] ያድርጉ።
  5. በመላው ድርድር ላይ ብስጭት እና ከፍተኛውን ውጤት እናገኛለን ፡፡
  6. ተመላሽ ውጤት

ማስረጃ  

ምርታችንን ለማግኘት አንዳንድ ቀላል ማቋረጥን ማከናወን ያስፈልገናል ፡፡ ለዚህም ውጤቱን ወደ 0. እንጀምራለን ከዚያ 2-D ን እናሳውቃለን ማትሪክስ ከድርድር 1 እና ከድርድር ርዝመት አንድ የበለጠ ርዝመት።

ሁለቱንም ድርድር ከድርድሩ የመጨረሻ መረጃ ጠቋሚ እናልፋለን። ስለዚህ የተወሰኑትን ሁኔታዎች እንፈትሻለን እና ውጤቱን በውጤት ውስጥ እናከማቸዋለን ፡፡

ስለዚህ አንድ ምሳሌ እንውሰድ እና የበለጠ እንቀጥል ፡፡

ለምሳሌ

እንደ አንድ ድርድር ቢኖሩ እንበል

ተመልከት
የሶስት ቁልል እኩል የሆነ ድምርን ከፍተኛ ድምርን ያግኙ

int array1 [] = {1,2,3,2,1};

int array2 [] = {3,2,1,4,7};

ውጤት = 0;

  • i = 4, j = 4;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

ውጤት = 0;

  • i = 4, j = 3;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

ውጤት = 0;

  • i = 4, j = 2;

ድርድር 1 [i] == ድርድር 2 [j] እውነት ከተመለሰ እና ቫል [i] [j] = val [i + 1] [j + 1] +1

then val[4][2]=val[5][3]+1=1 then val[i][j]=1.

ከዚያ ውፅዓት <val [i] [j] እውነት ሆኖ ከተመለሰ ውጤቱን = 1 ያድርጉ ፡፡

ውጤት = 1;

  • i = 4, j = 1;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 4, j = 0;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 3, j = 4;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 3, j = 3;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 3, j = 2;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 3, j = 1;

ድርድር 1 [i] == ድርድር 2 [j] እውነት ከተመለሰ እና ቫል [i] [j] = val [i + 1] [j + 1] +1

ከዚያ ቫል [3] [1] = ቫል [4] [2] + 1 = 2 ከዚያ ቫል [3] [1] = 2።

ከዚያ ውፅዓት <val [i] [j] እውነት መመለሱን ያረጋግጡ እና ውፅዓት = val [i] [j] ያድርጉ።

ውጤት = 2;

  • i = 3, j = 0;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 2, j = 4;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 2, j = 3;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 2, j = 2;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 2, j = 1;

ድርድር 1 [i] == ድርድር 2 [j] ሐሰት ከተመለሰ እና ምንም ማድረግ የማይችል ከሆነ።

  • i = 2, j = 0;

ድርድር 1 [i] == ድርድር 2 [j] እውነት ከተመለሰ እና ቫል [i] [j] = val [i + 1] [j + 1] +1

ከዚያ ቫል [2] [0] = ቫል [3] [1] + 1 = 2 + 1 ከዚያም ቫል [2] [0] = 3።

ከዚያ ውፅዓት <val [i] [j] እውነት መመለሱን ያረጋግጡ እና ውፅዓት = val [2] [0] ያድርጉ።

ውጤት = 3;

እና ይህ በመዞሪያ ውስጥ እኩል ክፍሎችን ካገኘን በኋላም ቢሆን የተደጋገመ ድርድር ከፍተኛው ርዝመት 3 ይሆናል ፣ ነገር ግን በውጤቱ ላይ ዝመና አይሰራም ፣ ምክንያቱም ያ ንዑስ ቡድን አይሆንም

በ i = 1 ፣ j = 1 ላይ እንበል ቀጣዩን ተመሳሳይ ንጥረ ነገር እናገኛለን ስለዚህ ቫል ያደርገዋል ፡፡ [1] [1] = val [2] [2] +1;

ተመልከት
ቅደም ተከተሎች እንዲጨምሩ ለማድረግ አነስተኛ ልውውጦች

እና ውጤቱን የምንመረምር ከሆነ <val [1] [1] ከዚያ በሐሰት በተመለሰ ቁጥር ምንም አያደርግም።

ስለዚህ እዚህ ፣ ውጤቱ 3 ነው ፡፡

አፈጻጸም  

ለተደጋጋሚ ንዑስ ቡድን ከፍተኛ ርዝመት C ++ ፕሮግራም

#include <iostream>
using namespace std;

int lengthOfRepeatedArray(int array1[], int array2[])
{
    int output = 0;
    int val[6][6]= {0};

    for (int i = 4; i >= 0; --i)
    {
        for (int j = 4; j >= 0; --j)
        {
            if (array1[i] == array2[j])
            {
                val[i][j] = val[i+1][j+1] + 1;
                if(output < val[i][j])
                {
                    output = val[i][j];
                }
            }
        }
    }
    return output;
}
int main()
{
    int a[]= {1,2,3,2,1};
    int b[]= {3,2,1,4,7};

    cout<<lengthOfRepeatedArray(a,b);
    return 0;
}
3

የ ‹ጃቫ ፕሮግራም› ለተደጋገመ ንዑስ ቡድን ከፍተኛ ርዝመት

class repeatedArrayLength
{
    public static int lengthOfRepeatedArray(int[] array1, int[] array2)
    {
        int output = 0;
        int val[][] = new int[array1.length + 1][array2.length + 1];
        for (int i = array1.length - 1; i >= 0; --i)
        {
            for (int j = array2.length - 1; j >= 0; --j)
            {
                if (array1[i] == array2[j])
                {
                    val[i][j] = val[i+1][j+1] + 1;
                    if(output < val[i][j])
                        output = val[i][j];
                }
            }
        }
        return output;
    }
    public static void main(String []args)
    {
        int a[]= {1,2,3,2,1};
        int b[]= {3,2,1,4,7};
        System.out.println(lengthOfRepeatedArray(a,b));
    }
}
3

ለተደጋጋሚ ንዑስ ቡድን ከፍተኛ ርዝመት ውስብስብነት ትንተና  

የጊዜ ውስብስብነት

ኦ (ሀ × ለ) የት የመጀመሪያው ድርድር መጠን እና “ለ” የሁለተኛው ድርድር መጠን ነው።

የቦታ ውስብስብነት

ኦ (ሀ × ለ) የት የመጀመሪያው ድርድር መጠን እና “ለ” የሁለተኛው ድርድር መጠን ነው።

ማጣቀሻ