የፓሊንድሮም ንዑስ ክርክር ጥያቄዎች  


የችግር ደረጃ ጠንካራ
ውስጥ በተደጋጋሚ ተጠየቀ አማዞን ByteDance eBay Expedia google ኢላማዊ የ Microsoft የ PayPal Pinterest Synopsys
ተለዋዋጭ ፕሮግራም ሃምሽንግ የጥያቄ ችግር ሕብረቁምፊ

የችግሩ መግለጫ  

ችግሩ “Palindrome Substring Queries” የሚለው ክር እና የተወሰኑ መጠይቆች እንደተሰጡዎት ይናገራል። በእነዚያ መጠይቆች ፣ ከእዚያ መጠይቅ የተሠራው ማጠፊያ “palindrom” ወይም አለመሆኑን መወሰን አለብዎት።

ለምሳሌ  

String str = "aaabbabbaaa"

Queries q[] = { {2, 3}, {2, 8},{5, 7}, {3, 7} }
The Substring [2 3] is not a palindrome

The Substring [2 8] is a palindrome

The Substring [5 7] is not a palindrome

The Substring [3 7] is a palindrome

ማብራሪያ-የመጫኛ መስመሩ [2,8] ፓሊንደሮም ነው ፣ ስለሆነም ውጤቱ አዎ ነው። የመጫኛ ሰሌዳው “አባባብ” ነው።

ቀረበ  

በእያንዳንዱ ጥያቄ ላይ በመመርኮዝ ክር እና የተወሰኑ ጥያቄዎችን ሰጥተናል ፡፡ እኛ የተሰራውን የመለኪያ መስመሩን መወሰን አለብን ሀ ፓሊንድሮም ኦር ኖት. ገመድ ይጠቀሙ ሃምሽንግ ይህንን ለመፍታት ፡፡ ሁለት ድርድሮችን አንድ ለዋናው ገመድ አንድ ደግሞ ለተገለበጠው ገመድ እንጠቀማለን ፡፡ ከዚያ የስትሪንግ ሃሽ እሴቶችን እናከማቸዋለን ፡፡ እዚህ የሃሽ እሴት ከሌላው የተለየ ሊሆን ይችላል ፡፡ ለ ‹ገመድ› የሃሽ እሴትን እንወስዳለን እና ለተለወጠው ገመድ ሀሽ እሴትን እንቀይር እንበል ፡፡ ቅድመ ቅጥያ እና ቅጥያ ድርድር እንወስዳለን ፡፡

String str አለን እንበል “aabbbababaaa”።

እኛ እንደ ‹str› ሃሽ እሴቶችን እናከማቸዋለን

ቅድመ ቅጥያ [i] = str [0] + str [1] * 101 + str [2] * 1012  + ………. + Str [i-1] * 101 *i-xNUMX  .

ለእያንዳንዱ ቅድመ ቅጥያ [i] እሴት። የሚከተሉትን እሴቶች ይኖረናል

Prefix[0]=0,
Prefix[1]= 97 + 97 *101, ( 0+ ASCII value of a)
Prefix[2]= 97 + 97 *101 + 98 *101^2
Prefix[3]= 97 + 97 *101 + 98 *101^2 + 98 *101^3 ( 0 + ASCII value of a’s and ASCII value of b).
.
.
.
Prefix [12]= 97 + 97 *101 + 98 *101^2 + 98 *101^3 +…… +97 *101^11 as length of String is 12.

 

ተመልከት
ሁሉንም ነጥቦች ለመጎብኘት አነስተኛ ጊዜ Leetcode መፍትሄ

ስለዚህ አሁን ብዙዎቻችሁ የሃሽ እሴቶችን በእንደዚህ አይነት መንገድ የማከማቸት መንገድ ይህ ለምን እንደሆነ እያሰቡ ነው ፡፡ በትንሽ የጊዜ ውስብስብነት ውስጥ ቀለል ያለ ቀመር በመጠቀም ማንኛውንም የተሰጠ የማጣቀሻ ሃሽ እሴት ለመፈለግ መልሱ መንገድ ነው ፡፡

የሃሽ እሴት (ግራ ፣ ቀኝ) = ቅድመ ቅጥያ [ቀኝ + 1] - ቅድመ ቅጥያ [ግራ]።

የግራ እና ቀኝ የመነሻ ነጥብ ሊሆን ይችላል ፣ የሕብረቁምፊ ሃሽ እሴት (2 ፣ 4) = “ቢቢቢ” ማግኘት ከፈለግን ፣ በቀላል ይሆናል

ቅድመ ቅጥያ [5] - ቅድመ ቅጥያ [2] = 98 * 1013 + 98 * 1014 + 98 * 1015.

ይህ እሴት ፓሊንደሮምን ለማወቅ ይረዳል ፡፡ ምክንያቱም በተመሳሳይ ቅጥያ ቅጥያ እናደርጋለን ፣ ግን በዚህ ጊዜ ካለፈው ፣ እንዴት እንደ ሆነ እንመልከት ፡፡

String str: “aabbababaaa”።

suffix[i] = str[n-1]+ str[n-2] *101 + str[n-3]*1022  + ……….+ str[n-i]*101*i-1  .
suffix[0]=0,
suffix [1]= 97 + 97 *101, ( 0+ ASCII value of a)
suffix [2]= 97 + 97 *101 + 97 *101^2,
suffix [3]= 97 + 97 *101 + 97 *101^2 + 98 *101^3 ( 0 + ASCII value of a’s and ASCII value of b).
.
.
.
.
suffix [11]= 97 + 97 *101 + 97 *101^2 + 98 *101^3 +…… +97 *101^10 as length of String is 11.

አሁን በመጠቀም የተገላቢጦሽ የሃሽ እሴት ዋጋን ማስላት እንችላለን-

የተገላቢጦሽ የሃሽ እሴት (ግራ ፣ ቀኝ)-የሃሽ እሴት (ቀኝ ፣ ግራ) = ቅጥያ [n-ግራ] - ቅጥያ [n-ቀኝ -1]።

ለምሳሌ

ለምሳሌ: String str “aabbbababaaa”።

የተገላቢጦሽ የሃሽ እሴት: ማጠፊያ (2,4):

የ “ቢቢባ” እሴት መሻር “abbb” ነው

ቅጥያ [11-1] - ቅጥያ [11-4-1] = ቅጥያ [10] -suffix [6]።

እና አሁን ካለ ፓሊንደሮምን ለመፈለግ እኩልነት አለን ፡፡

አሁን እንደ ቅድመ ቅጥያ እና ቅጥያ ሁለት ድርድር አለን ፣ በመካከላቸው አንድ ዝምድና አለን ፡፡

(ቅድመ-ቅጥያ [ቀኝ + 1] - ቅድመ ቅጥያ [ግራኝ])  =  (ቅጥያ [n - ግራኝ] - ቅጥያ [n - ቀኝ- 1])

ተመልከት
አሁን ካለው ቁጥር ምን ያህል ቁጥሮች ያነሱ ናቸው Leetcode መፍትሔ

(101ግራ) (101n - ትክክል - 1)

 

የፓሊንድሮም ንዑስ ክርክር ጥያቄዎችጭንቅላታም መያያዣ መርፌ  

ኮድ  

ለፓሊንዲሮም ንዑስ-መስመር ጥያቄዎች C + ኮድ

#include<iostream>

using namespace std;

#define p 101
#define MOD 1000000007

struct Queries
{
    int left, right;
};
bool CheckPalindrome(string str, int left, int right)
{
    while (right > left)
        if (str[left++] != str[right--])
            return (false);
    return (true);
}
unsigned long long int moduloPower(unsigned long long int base,unsigned long long int exponent)
{
    if (exponent == 0)
        return 1;
    if (exponent == 1)
        return base;

    unsigned long long int temp = moduloPower(base, exponent / 2);

    if (exponent % 2 == 0)
        return (temp % MOD * temp % MOD) % MOD;
    else
        return (((temp % MOD * temp % MOD) % MOD)* base % MOD)% MOD;
}

unsigned long long int ModuloMultiplicativeInverse(unsigned long long int n)
{
    return moduloPower(n, MOD - 2);
}

void HashPrefix( string str, int n, unsigned long long int prefix[], unsigned long long int powerArr[])
{
    prefix[0] = 0;
    prefix[1] = str[0];

    for (int i = 2; i <= n; i++)
        prefix[i] = (prefix[i - 1] % MOD + (str[i - 1] % MOD * powerArr[i - 1] % MOD) % MOD) % MOD;

    return;
}

void HashSuffix( string str, int n, unsigned long long int suffix[], unsigned long long int powerArr[])
{
    suffix[0] = 0;
    suffix[1] = str[n - 1];

    for (int i = n - 2, j = 2; i >= 0 && j <= n; i--, j++)
        suffix[j] = (suffix[j - 1] % MOD+ (str[i] % MOD* powerArr[j - 1] % MOD)% MOD)% MOD;

    return;
}
void GetQueryOutput(string str, Queries q[], int m, int n, unsigned long long int prefix[], unsigned long long int suffix[], unsigned long long int powerArr[])
{
    for (int i = 0; i <= m - 1; i++)
    {
        int left = q[i].left;
        int right = q[i].right;

        unsigned long long HashValue= ((prefix[right + 1] - prefix[left] + MOD) % MOD* ModuloMultiplicativeInverse(powerArr[left]) % MOD)% MOD;

        unsigned long long reverseHashValue= ((suffix[n - left] - suffix[n - right - 1] + MOD) % MOD* ModuloMultiplicativeInverse(powerArr[n - right - 1]) % MOD)% MOD;

        if (HashValue == reverseHashValue)
        {
            if (CheckPalindrome(str, left, right) == true)
                cout<<"The Substring ["<< left <<" "<<right<<"] is a palindrome\n";
            else
                cout<<"The Substring ["<< left <<" "<<right<<"] is a palindrome\n";
        }

        else
            cout<<"The Substring ["<< left <<" "<<right<<"] is not a palindrome\n";
    }

    return;
}
void assginedPowers(unsigned long long int powerArr[], int n)
{
    powerArr[0] = 1;

    for (int i = 1; i <= n; i++)
        powerArr[i] = (powerArr[i - 1] % MOD * p % MOD) % MOD;

    return;
}
int main()
{
    string str = "aaabbabbaaa";
    int n = str.length();

    unsigned long long int powerArr[n + 1];

    assginedPowers(powerArr, n);

    unsigned long long int prefix[n + 1];
    unsigned long long int suffix[n + 1];

    HashPrefix(str, n, prefix, powerArr);
    HashSuffix(str, n, suffix, powerArr);

    Queries q[] = { {2, 3}, {2, 8},{5, 7}, {3, 7} };
    int m = sizeof(q) / sizeof(q[0]);

    GetQueryOutput(str, q, m, n, prefix, suffix, powerArr);
    return (0);
}
The Substring [2 3] is not a palindrome
The Substring [2 8] is a palindrome
The Substring [5 7] is not a palindrome
The Substring [3 7] is a palindrome

የጃቫ ኮድ ለፓሊንዲሮም ንዑስ ገመድ አልባ ጥያቄዎች

public class PalindromeSubstringQuery
{
    static int p = 101;
    static int MOD = 1000000007;

    public static class Queries
    {
        int left, right;
        public Queries(int left, int right)
        {
            this.left = left;
            this.right = right;
        }
    }
    public static boolean CheckPalindrome(String str, int left, int right)
    {
        while (right > left)
        {
            if (str.charAt(left++) != str.charAt(right--))
                return (false);
        }
        return (true);
    }
    public static int moduloPower(int base, int exponent)
    {
        if (exponent == 0)
        {
            return 1;
        }
        if (exponent == 1)
        {
            return base;
        }
        int temp = moduloPower(base, exponent / 2);

        if (exponent % 2 == 0)
        {
            return (temp % MOD * temp % MOD) % MOD;
        }
        else
        {
            return (((temp % MOD * temp % MOD) % MOD) * base % MOD) % MOD;
        }
    }
    public static int ModuloMultiplicativeInverse(int n)
    {
        return moduloPower(n, MOD - 2);
    }

    public static void HashPrefix(String str, int n,int prefix[], int powerArr[])
    {
        prefix[0] = 0;
        prefix[1] = str.charAt(0);

        for (int i = 2; i <= n; i++)
        {
            prefix[i] = (prefix[i - 1] % MOD+ (str.charAt(i - 1) % MOD * powerArr[i - 1] % MOD) % MOD) % MOD;
        }
        return;
    }
    public static void HashSuffix(String str, int n,int suffix[], int powerArr[])
    {
        suffix[0] = 0;
        suffix[1] = str.charAt(n - 1);

        for (int i = n - 2, j = 2; i >= 0 && j <= n; i--, j++)
        {
            suffix[j] = (suffix[j - 1] % MOD + (str.charAt(i) % MOD* powerArr[j - 1] % MOD) 	% MOD) % MOD;
        }
        return;
    }
    public static void GetQueryOutput( String str, Queries q[], int m, int n, int prefix[], int suffix[], int powerArr[])
    {
        for (int i = 0; i <= m - 1; i++)
        {
            int left = q[i].left;
            int right = q[i].right;

            long HashValue= ((prefix[right + 1] - prefix[left] + MOD) % MOD* ModuloMultiplicativeInverse(powerArr[left]) % MOD)% MOD;

            long reverseHashValue= ((suffix[n - left] - suffix[n - right - 1] + MOD) % MOD* ModuloMultiplicativeInverse(powerArr[n - right - 1]) % MOD)% MOD;

            if (HashValue == reverseHashValue)
            {
                if (CheckPalindrome(str, left, right) == true)
                {
                    System.out.print("The Substring ["+left+" "+ right+"] is a palindrome\n");
                }
                else
                {
                    System.out.print("The Substring ["+left+" "+ right+"] is not a palindrome\n");
                }
            }
            else
            {
                System.out.print("The Substring ["+left+" "+ right+"] is not a palindrome\n");
            }
        }
        return;
    }
    public static void assginedPowers(int powerArr[], int n)
    {
        powerArr[0] = 1;

        for (int i = 1; i <= n; i++)
            powerArr[i] = (powerArr[i - 1] % MOD * p % MOD) % MOD;

        return;
    }
    public static void main(String[] args)
    {
        String str = "aaabbabbaaa";
        int n = str.length();

        int[] powerArr = new int[n + 1];

        assginedPowers(powerArr, n);

        int[] prefix = new int[n + 1];
        int[] suffix = new int[n + 1];

        HashPrefix(str, n, prefix, powerArr);
        HashSuffix(str, n, suffix, powerArr);

        Queries q[] = { new Queries(2, 3), new Queries(2, 8),new Queries(5, 7), new Queries(3, 7) };

        int m = q.length;

        GetQueryOutput(str, q, m, n, prefix, suffix, powerArr);
    }
}
The Substring [2 3] is not a palindrome
The Substring [2 8] is a palindrome
The Substring [5 7] is not a palindrome
The Substring [3 7] is a palindrome

ውስብስብነት ትንተና  

የጊዜ ውስብስብነት

ኦ (N + Q) የት "N" የሕብረቁምፊው መጠን እና "ጥ" የሚከናወኑ የጥያቄዎች ብዛት ነው ፡፡ ስለዚህ ፣ አልጎሪዝም እያንዳንዱን ጥያቄ በ O (1) ጊዜ እንደምንመልስ መስመራዊ የጊዜ ውስብስብነት አለው ፡፡

ተመልከት
ከተሰጠ ድምር ጋር ንዑስ ድርድርን ያግኙ (አሉታዊ ቁጥሮችን ያስተናግዳል)

የቦታ ውስብስብነት

ኦ (ኤን) የት "N" በተሰጠው ገመድ ውስጥ የቁምፊዎች ብዛት ነው። ምክንያቱም ለህብረቁምፊ የሃሽ እሴቶችን አከማችተናል ፡፡ ተጨማሪ ቦታ እንጠቀም ነበር ፡፡