# 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.

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 ` `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 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
``` My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.