Find the numbers of strings that can be formed after processing Q queries

Given a number N(1<=N<=2000)., The task is to find the number strings of size N that can be obtained after using characters from 'a' to 'z' and by processing the given q(1<=q<=200000) queries.

For each query given two integers L, R (0<=L<=R<=N) such that substring [L, R] of the generated string of size N must be a palindrome. The task is to process all queries and generate a string of size N such that the substrings of this string defined by all queries are palindrome.

The answer can be very large. So, output answer modulo 1000000007.

Note: 1-based indexing is considered for the string.

Examples:

Input : N = 3
query 1: (1, 2)
query 2: (2, 3)
Output : 26
Explanation : Substring 1 to 2 should be 
palindrome and substring 2 to 3 should be palindrome. so, all 
three characters should be same. so, we can obtain 26 such strings.

Input : N = 4
query 1: (1, 3)
query 2: (2, 4)
Output : 676
Explanation : substring 1 to 3 should be 
palindrome and substring 2 to 4 should be a palindrome. 
So, a first and third character should be the same and 
second and the fourth should be the same. So, we can 
obtain 26*26 such strings.

Approach : An efficient solution is to use union-find algorithm.

• Find the mid-point of each range (query) and if there are many queries having the same mid-point then only retain that query whose length is max, i.e (where r – l is max).
• This would have reduced the number of queries to 2*N at max since there is a 2*N number of mid-points in a string of length N.
• Now for each query do union of element l with r, (l + 1) with (r – 1), (l + 2) with (r – 2) and so on. We do this because the character which would be put on the index l would be the same as the one we put on index r. Extending this logic to all queries we need to maintain disjoint-set data structure. So basically all the elements of one component of disjoint-set should have the same letter on them.
• After processing all the queries, let the number of disjoint-set components be x, then the answer is 26^x

.

Below is the implementation of the above approach :


C++
// C++ program to implement above approach

#include <bits/stdc++.h>
using namespace std;
#define N 2005
#define mod (int)(1e9 + 7)

// To store the size of string and
// number of queries
int n, q;

// To store parent and rank of ith place
int par[N], Rank[N];

// To store maximum interval
map<int, int> m;

// Function for initialization
void initialize()
{
    for (int i = 0; i <= n; i++) {
        par[i] = i;
        Rank[i] = 0;
    }
}

// Function to find parent
int find(int x)
{
    if (par[x] != x)
        par[x] = find(par[x]);

    return par[x];
}

// Function to make union
void Union(int x, int y)
{
    int xpar = find(x);
    int ypar = find(y);

    if (Rank[xpar] < Rank[ypar])
        par[xpar] = ypar;
    else if (Rank[xpar] > Rank[ypar])
        par[ypar] = xpar;
    else {
        par[ypar] = xpar;
        Rank[xpar]++;
    }
}

// Power function to calculate a raised to m1
// under modulo 10000007
int power(long long a, long long m1)
{
    if (m1 == 0)
        return 1;
    else if (m1 == 1)
        return a;
    else if (m1 == 2)
        return (1LL * a * a) % mod;
    else if (m1 & 1)
        return (1LL * a * power(power(a, m1 / 2), 2)) % mod;
    else
        return power(power(a, m1 / 2), 2) % mod;
}

// Function to take maxmium interval
void query(int l, int r)
{
    m[l + r] = max(m[l + r], r);
}

// Function to find different possible strings
int possiblestrings()
{
    initialize();

    for (auto i = m.begin(); i != m.end(); i++) {
        int x = i->first - i->second;
        int y = i->second;

        // make union of all chracters which
        // are meant to be same
        while (x < y) {
            Union(x, y);
            x++;
            y--;
        }
    }

    // find number of different sets formed
    int ans = 0;
    for (int i = 1; i <= n; i++)
        if (par[i] == i)
            ans++;

    // return the required answer
    return power(26, ans) % mod;
}

// Driver Code
int main()
{
    n = 4;

    // queries
    query(1, 3);
    query(2, 4);

    cout << possiblestrings();

    return 0;
}
Java
// Java program to implement above approach
import java.util.*;

class GFG
{
    static final int N = 2005;
    static final int mod = 1000000007;

    // To store the size of string and
    // number of queries
    static int n, q;

    // To store parent and rank of ith place
    static int[] par = new int[N], Rank = new int[N];

    // To store maximum interval
    static HashMap<Integer,
                   Integer> m = new HashMap<>();

    // Function for initialization
    static void initialize()
    {
        for (int i = 0; i <= n; i++)
        {
            par[i] = i;
            Rank[i] = 0;
        }
    }

    // Function to find parent
    static int find(int x)
    {
        if (par[x] != x)
            par[x] = find(par[x]);

        return par[x];
    }

    // Function to make union
    static void Union(int x, int y)
    {
        int xpar = find(x);
        int ypar = find(y);

        if (Rank[xpar] < Rank[ypar])
            par[xpar] = ypar;
        else if (Rank[xpar] > Rank[ypar])
            par[ypar] = xpar;
        else
        {
            par[ypar] = xpar;
            Rank[xpar]++;
        }
    }

    // Power function to calculate a raised to m1
    // under modulo 10000007
    static long power(long a, long m1)
    {
        if (m1 == 0)
            return 1;
        else if (m1 == 1)
            return a;
        else if (m1 == 2)
            return (1L * a * a) % mod;
        else if (m1 % 2 == 1)
            return (1L * a * power(power(a, m1 / 2), 2)) % mod;
        else
            return power(power(a, m1 / 2), 2) % mod;
    }

    // Function to take maxmium interval
    static void query(int l, int r)
    {
        if (m.containsKey(l + r))
            m.put(l + r, Math.max(m.get(l + r), r));
        else
            m.put(l + r, r);
    }

    // Function to find different possible strings
    static long possiblestrings()
    {
        initialize();

        for (Integer i : m.keySet())
        {
            int x = i - m.get(i);
            int y = m.get(i);

            // make union of all chracters which
            // are meant to be same
            while (x < y)
            {
                Union(x, y);
                x++;
                y--;
            }
        }

        // find number of different sets formed
        int ans = 0;
        for (int i = 1; i <= n; i++)
            if (par[i] == i)
                ans++;

        // return the required answer
        return power(26, ans) % mod;
    }

    // Driver Code
    public static void main(String[] args)
    {
        n = 4;

        // queries
        query(1, 3);
        query(2, 4);

        System.out.println(possiblestrings());
    }
}

// This code is contributed by
// sanjeev2552
Python3
# Python3 program to implement above approach
N = 2005
mod = 10**9 + 7

# To store the size of string and
# number of queries
n, q = 0, 0

# To store parent and rank of ith place
par = [0 for i in range(N)]
Rank = [0 for i in range(N)]

# To store maximum interval
m = dict()

# Function for initialization
def initialize():

    for i in range(n + 1):
        Rank[i], par[i] = 0, i

# Function to find parent
def find(x):
    if (par[x] != x):
        par[x] = find(par[x])

    return par[x]

# Function to make union
def Union(x, y):

    xpar = find(x)
    ypar = find(y)

    if (Rank[xpar] < Rank[ypar]):
        par[xpar] = ypar
    elif (Rank[xpar] > Rank[ypar]):
        par[ypar] = xpar
    else:
        par[ypar] = xpar
        Rank[xpar] += 1

# Power function to calculate a raised to m1
# under modulo 10000007
def power(a, m1):

    if (m1 == 0):
        return 1
    elif (m1 == 1):
        return a
    elif (m1 == 2):
        return (a * a) % mod
    elif (m1 & 1):
        return (a * power(power(a, m1 // 2), 2)) % mod
    else:
        return power(power(a, m1 // 2), 2) % mod

# Function to take maxmium interval
def query(l, r):
    if l + r in m.keys():
        m[l + r] = max(m[l + r], r)
    else:
        m[l + r] = max(0, r)

# Function to find different possible strings
def possiblestrings():
    initialize()

    for i in m:
        x = i - m[i]
        y = m[i]

        # make union of all chracters which
        # are meant to be same
        while (x < y):
            Union(x, y)
            x += 1
            y -= 1

    # find number of different sets formed
    ans = 0
    for i in range(1, n + 1):
        if (par[i] == i):
            ans += 1

    # return the required answer
    return power(26, ans) % mod

# Driver Code
n = 4

# queries
query(1, 3)
query(2, 4)

print(possiblestrings())

# This code is contributed by Mohit Kumar
C#
// C# program to implement above approach
using System;
using System.Collections.Generic;

class GFG{

const int N = 2005;
const int mod = 1000000007;

// To store the size of string and
// number of queries
static int n;
//static int q;

// To store parent and rank of ith place
static int[]par = new int[N];
static int[]Rank = new int[N];

// To store maximum interval
static Dictionary<int,
                  int> m = new Dictionary<int,
                                          int>();

// Function for initialization
static void initialize()
{
    for(int i = 0; i <= n; i++)
    {
        par[i] = i;
        Rank[i] = 0;
    }
}

// Function to find parent
static int find(int x)
{
    if (par[x] != x)
        par[x] = find(par[x]);

    return par[x];
}

// Function to make union
static void Union(int x, int y)
{
    int xpar = find(x);
    int ypar = find(y);

    if (Rank[xpar] < Rank[ypar])
        par[xpar] = ypar;
    else if (Rank[xpar] > Rank[ypar])
        par[ypar] = xpar;
    else
    {
        par[ypar] = xpar;
        Rank[xpar]++;
    }
}

// Power function to calculate a raised to m1
// under modulo 10000007
static long power(long a, long m1)
{
    if (m1 == 0)
        return 1;
    else if (m1 == 1)
        return a;
    else if (m1 == 2)
        return (1L * a * a) % mod;
    else if (m1 % 2 == 1)
        return (1L * a * power(
               power(a, m1 / 2), 2)) % mod;
    else
        return power(power(a, m1 / 2), 2) % mod;
}

// Function to take maxmium interval
static void query(int l, int r)
{
    if (m.ContainsKey(l + r))
        m[l + r] = Math.Max(m[l + r], r);
    else
        m[l + r] = r;
}

// Function to find different possible strings
static long possiblestrings()
{
    initialize();

    foreach(KeyValuePair<int, int> i in m)
    {
        int x = i.Key - m[i.Key];
        int y = m[i.Key];

        // Make union of all chracters
        // which are meant to be same
        while (x < y)
        {
            Union(x, y);
            x++;
            y--;
        }
    }

    // Find number of different sets formed
    int ans = 0;
    for(int i = 1; i <= n; i++)
        if (par[i] == i)
            ans++;

    // Return the required answer
    return power(26, ans) % mod;
}

// Driver Code
public static void Main(string[] args)
{
    n = 4;

    // Queries
    query(1, 3);
    query(2, 4);

    Console.Write(possiblestrings());
}
}


// This code is contributed by rutvik_56
Output:

676