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

Last Updated : 11 Sep, 2020

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.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes