# 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 :26Explanation :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 :676Explanation :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; ` `} ` |

*chevron_right*

*filter_none*

## 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
[tabbyending]

**Output:**

676

## Recommended Posts:

- Find all strings formed from characters mapped to digits of a number
- Find the count of numbers that can be formed using digits 3, 4 only and having length at max N.
- Given two numbers as strings, find if one is a power of other
- Count of strings that can be formed using a, b and c under given constraints
- All possible strings of any length that can be formed from a given string
- Check if given string can be formed by two other strings or their permutations
- Count of strings that can be formed from another string using each character at-most once
- Print all possible strings of length k that can be formed from a set of n characters
- Sum of all numbers that can be formed with permutations of n digits
- N digit numbers divisible by 5 formed from the M digits
- Check whether a binary string can be formed by concatenating given N numbers sequentially
- Queries to find distance between two nodes of a Binary tree
- Queries to find maximum product pair in range with updates
- Find the Largest Cube formed by Deleting minimum Digits from a number
- Find longest palindrome formed by removing or shuffling chars from string

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.