GFG App
Open App
Browser
Continue

# Weighted Prefix Search

Given n strings and a weight associated with each string. The task is to find the maximum weight of string having the given prefix. Print “-1” if no string is present with given prefix.
Examples:

```Input :
s1 = "geeks", w1 = 15
s2 = "geeksfor", w2 = 30
s3 = "geeksforgeeks", w3 = 45
prefix = geek
Output : 45

All the string contain the given prefix, but
maximum weight of string is 45 among all.```

Method 1: (Brute Force)

Check all the string for given prefix, if string contains the prefix, compare its weight with maximum value so far.
Below is the implementation of above idea :

## C++

 `// C++ program to find the maximum weight with given prefix.` `// Brute Force based C++ program to find the` `// string with maximum weight and given prefix.` `#include` `#define MAX 1000` `using` `namespace` `std;`   `// Return the maximum weight of string having` `// given prefix.` `int` `maxWeight(``char` `str[MAX][MAX], ``int` `weight[],` `                          ``int` `n, ``char` `prefix[])` `{` `    ``int` `ans = -1;` `    ``bool` `check;`   `    ``// Traversing all strings` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{` `        ``check = ``true``;`   `        ``// Checking if string contain given prefix.` `        ``for` `(``int` `j=0, k=0; j < ``strlen``(str[i]) &&` `                           ``k < ``strlen``(prefix); j++, k++)` `        ``{` `            ``if` `(str[i][j] != prefix[k])` `            ``{` `                ``check = ``false``;` `                ``break``;` `            ``}` `        ``}`   `        ``// If contain prefix then finding` `        ``// the maximum value.` `        ``if` `(check)` `            ``ans = max(ans, weight[i]);` `    ``}`   `    ``return` `ans;` `}`   `// Driven program` `int` `main()` `{` `    ``int` `n = 3;` `    ``char` `str[3][MAX] = { ``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"` `};` `    ``int` `weight[] = {15, 30, 45};` `    ``char` `prefix[] = ``"geek"``;`   `    ``cout << maxWeight(str, weight, n, prefix) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java program to find the maximum ` `// weight with given prefix.`   `class` `GFG {` `    ``static` `final` `int` `MAX = ``1000``;`   `    ``// Return the maximum weight of string having` `    ``// given prefix.` `    ``static` `int` `maxWeight(String str[], ``int` `weight[],` `                              ``int` `n, String prefix)` `    ``{` `        ``int` `ans = -``1``;` `        ``boolean` `check;`   `        ``// Traversing all strings` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{` `            ``check = ``true``;`   `            ``// Checking if string contain given prefix.` `            ``for` `(``int` `j=``0``, k=``0``; j < str[i].length() &&` `                               ``k < prefix.length(); j++, k++)` `            ``{` `                ``if` `(str[i].charAt(j) != prefix.charAt(k))` `                ``{` `                    ``check = ``false``;` `                    ``break``;` `                ``}` `            ``}`   `            ``// If contain prefix then finding` `            ``// the maximum value.` `            ``if` `(check)` `                ``ans = Math.max(ans, weight[i]);` `        ``}`   `        ``return` `ans;` `    ``}`   `    ``// Driven program` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``3``;` `        ``String str[] = { ``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"` `};` `        ``int` `weight[] = {``15``, ``30``, ``45``};` `        ``String prefix = ``"geek"``;`   `        ``System.out.println(maxWeight(str, weight, n, prefix));` `    ``}` `}` `//This code is contributed by Sumit Ghosh`

## Python3

 `# Python program to find the maximum weight with given prefix.`   `# Return the maximum weight of string having` `# given prefix.` `def` `maxWeight(``str``, weight, n, prefix):` `    ``ans ``=` `-``1` `    ``check ``=` `False`   `    ``# Traversing all strings` `    ``for` `i ``in` `range``(n):` `        ``check ``=` `True` `        `  `        ``# Checking if string contain given prefix.` `        ``for` `j, k ``in` `zip``(``range``(``len``(``str``[i])), ``range``(``len``(prefix))):` `            ``if` `str``[i][j] !``=` `prefix[k]:` `                ``check ``=` `False` `                ``break` `            `  `        ``# If contain prefix then finding` `        ``# the maximum value.` `        ``if` `check:` `            ``ans ``=` `max``(ans, weight[i])`   `    ``return` `ans`   `# Driver program` `n ``=` `3` `str` `=` `[``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"``]` `weight ``=` `[``15``, ``30``, ``45``]` `prefix ``=` `"geek"`   `print``(maxWeight(``str``, weight, n, prefix))`   `#  This code is contributed by Aman Kumar.`

## C#

 `// C# program to find the maximum weight ` `// with given prefix.` `using` `System;`   `class` `GFG ` `{`   `    ``// Return the maximum weight of ` `    ``// string having given prefix.` `    ``static` `int` `maxWeight(``string` `[]str, ``int` `[]weight,` `                         ``int` `n, ``string` `prefix)` `    ``{` `        ``int` `ans = -1;` `        ``bool` `check;`   `        ``// Traversing all strings` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            ``check = ``true``;`   `            ``// Checking if string contain given prefix.` `            ``for` `(``int` `j=0, k=0; j < str[i].Length &&` `                     ``k < prefix.Length; j++, k++)` `            ``{` `                ``if` `(str[i][j] != prefix[k])` `                ``{` `                    ``check = ``false``;` `                    ``break``;` `                ``}` `            ``}`   `            ``// If contain prefix then finding` `            ``// the maximum value.` `            ``if` `(check)` `                ``ans = Math.Max(ans, weight[i]);` `        ``}`   `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 3;` `        ``String []str = {``"geeks"``, ``"geeksfor"``,` `                         ``"geeksforgeeks"``};` `        ``int` `[]weight = {15, 30, 45};` `        ``String prefix = ``"geek"``;`   `        ``Console.WriteLine(maxWeight(str, weight, ` `                          ``n, prefix));` `    ``}` `}`   `// This code is contributed by vt_m.`

## Javascript

 ``

Output:

`45`

Time Complexity: O(n*m*k) where n is the number of strings in the input array, m is the maximum length of any string in the array, and k is the length of the prefix.
Auxiliary Space: O(n*m)

Method 2 (efficient):

The idea is to create and maintain a Trie. Instead of the normal Trie where we store the character, store a number with it, which is maximum value of its prefix. When we encounter the prefix again update the value with maximum of existing and new one.
Now, search prefix for maximum value, run through the characters starting from the root, if one of character is missing return -1, else return the number stored in the root.
Below is the implementation of the above idea :

## C++

 `// C++ program to find the maximum weight` `// with given prefix.` `#include` `#define MAX 1000` `using` `namespace` `std;`   `// Structure of a trie node` `struct` `trieNode` `{` `    ``// Pointer its children.` `    ``struct` `trieNode *children[26];`   `    ``// To store weight of string.` `    ``int` `weight;` `};`   `// Create and return a Trie node` `struct` `trieNode* getNode()` `{` `    ``struct` `trieNode *node = ``new` `trieNode;` `    ``node -> weight = INT_MIN;`   `    ``for` `(``int` `i = 0; i < 26; i++)` `        ``node -> children[i] = NULL;` `}`   `// Inserting the node in the Trie.` `struct` `trieNode* insert(``char` `str[], ``int` `wt, ``int` `idx,` `                                ``struct` `trieNode* root)` `{` `    ``int` `cur = str[idx] - ``'a'``;`   `    ``if` `(!root -> children[cur])` `        ``root -> children[cur] = getNode();`   `    ``// Assigning the maximum weight` `    ``root->children[cur]->weight =` `                  ``max(root->children[cur]->weight, wt);`   `    ``if` `(idx + 1 != ``strlen``(str))` `        ``root -> children[cur] =` `           ``insert(str, wt, idx + 1, root -> children[cur]);`   `    ``return` `root;` `}`   `// Search and return the maximum weight.` `int` `searchMaximum(``char` `prefix[], ``struct` `trieNode *root)` `{` `    ``int` `idx = 0, n = ``strlen``(prefix), ans = -1;`   `    ``// Searching the prefix in TRie.` `    ``while` `(idx < n)` `    ``{` `        ``int` `cur = prefix[idx] - ``'a'``;`   `        ``// If prefix not found return -1.` `        ``if` `(!root->children[cur])` `            ``return` `-1;`   `        ``ans = root->children[cur]->weight;` `        ``root = root->children[cur];` `        ``++idx;` `    ``}`   `    ``return` `ans;` `}`   `// Return the maximum weight of string having given prefix.` `int` `maxWeight(``char` `str[MAX][MAX], ``int` `weight[], ``int` `n,` `                                       ``char` `prefix[])` `{` `    ``struct` `trieNode* root = getNode();`   `    ``// Inserting all string in the Trie.` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``root = insert(str[i], weight[i], 0, root);`   `    ``return` `searchMaximum(prefix, root);`   `}`   `// Driven Program` `int` `main()` `{` `    ``int` `n = 3;` `    ``char` `str[3][MAX] = {``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"``};` `    ``int` `weight[] = {15, 30, 45};` `    ``char` `prefix[] = ``"geek"``;`   `    ``cout << maxWeight(str, weight, n, prefix) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java program to find the maximum weight` `// with given prefix.`   `public` `class` `GFG{` `    ``static` `final` `int` `MAX = ``1000``;` `    `  `    ``// Structure of a trie node` `    ``static` `class` `TrieNode` `    ``{` `        ``// children` `        ``TrieNode[] children = ``new` `TrieNode[``26``];` `     `  `        ``// To store weight of string.` `        ``int` `weight;` `        `  `        ``// constructor` `        ``public` `TrieNode() {` `            ``weight = Integer.MIN_VALUE;` `            ``for` `(``int` `i = ``0``; i < ``26``; i++)` `                ``children[i] = ``null``;` `        ``}` `    ``}` `    ``//static TrieNode root;` `    `  `    ``// Inserting the node in the Trie.` `    ``static` `TrieNode insert(String str, ``int` `wt, ``int` `idx, TrieNode root)` `    ``{` `        ``int` `cur = str.charAt(idx) - ``'a'``;` `     `  `        ``if` `(root.children[cur] == ``null``)` `            ``root.children[cur] = ``new` `TrieNode();` `     `  `        ``// Assigning the maximum weight` `        ``root.children[cur].weight =` `                      ``Math.max(root.children[cur].weight, wt);` `     `  `        ``if` `(idx + ``1` `!= str.length())` `            ``root.children[cur] =` `               ``insert(str, wt, idx + ``1``, root.children[cur]);` `     `  `        ``return` `root;` `    ``}` `     `  `    ``// Search and return the maximum weight.` `    ``static` `int` `searchMaximum(String prefix, TrieNode root)` `    ``{` `        ``int` `idx = ``0``, ans = -``1``;` `        ``int` `n = prefix.length();` `     `  `        ``// Searching the prefix in TRie.` `        ``while` `(idx < n)` `        ``{` `            ``int` `cur = prefix.charAt(idx) - ``'a'``;` `     `  `            ``// If prefix not found return -1.` `            ``if` `(root.children[cur] == ``null``)` `                ``return` `-``1``;` `     `  `            ``ans = root.children[cur].weight;` `            ``root = root.children[cur];` `            ``++idx;` `        ``}` `     `  `        ``return` `ans;` `    ``}` `     `  `    ``// Return the maximum weight of string having given prefix.` `    ``static` `int` `maxWeight(String str[], ``int` `weight[], ``int` `n,` `                                           ``String prefix)` `    ``{` `        ``TrieNode root = ``new` `TrieNode();` `     `  `        ``// Inserting all string in the Trie.` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``root = insert(str[i], weight[i], ``0``, root);` `     `  `        ``return` `searchMaximum(prefix, root);` `     `  `    ``}` `     `  `    ``// Driven Program` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `n = ``3``;` `        ``String str[] = { ``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"` `};` `        ``int` `weight[] = {``15``, ``30``, ``45``};` `        ``String prefix = ``"geek"``;`   `        ``System.out.println(maxWeight(str, weight, n, prefix));` `    ``}` `}` `//This code is contributed by Sumit Ghosh`

## Python3

 `# Python program to find the maximum weight` `# with given prefix.` `# Structure of a trie node` `class` `TrieNode:` `    ``def` `__init__(``self``):` `        ``# Pointer its children.` `        ``self``.children ``=` `[``None``] ``*` `26` `        `  `        ``# To store weight of string.` `        ``self``.weight ``=` `float``(``'-inf'``)`   `# Create and return a Trie node` `def` `get_node():` `    ``return` `TrieNode()`   `# Inserting the node in the Trie.` `def` `insert(string, weight, idx, root):` `    ``cur ``=` `ord``(string[idx]) ``-` `ord``(``'a'``)` `    ``if` `not` `root.children[cur]:` `        ``root.children[cur] ``=` `get_node()` `        `  `    ``# Assigning the maximum weight` `    ``root.children[cur].weight ``=` `max``(root.children[cur].weight, weight)` `    ``if` `idx ``+` `1` `!``=` `len``(string):` `        ``root.children[cur] ``=` `insert(string, weight, idx ``+` `1``, root.children[cur])` `    ``return` `root`   `# Search and return the maximum weight.` `def` `search_maximum(prefix, root):` `    ``idx, n, ans ``=` `0``, ``len``(prefix), ``-``1` `    `  `    ``# Searching the prefix in Trie.` `    ``while` `idx < n:` `        ``cur ``=` `ord``(prefix[idx]) ``-` `ord``(``'a'``)` `        `  `        ``# If prefix not found return -1.` `        ``if` `not` `root.children[cur]:` `            ``return` `-``1` `        ``ans ``=` `root.children[cur].weight` `        ``root ``=` `root.children[cur]` `        ``idx ``+``=` `1` `    ``return` `ans`   `# Return the maximum weight of string having given prefix.` `def` `max_weight(strings, weights, n, prefix):` `    ``root ``=` `get_node()` `    `  `    ``# Inserting all string in the Trie.` `    ``for` `i ``in` `range``(n):` `        ``root ``=` `insert(strings[i], weights[i], ``0``, root)` `    ``return` `search_maximum(prefix, root)`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``n ``=` `3` `    ``strings ``=` `[``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"``]` `    ``weights ``=` `[``15``, ``30``, ``45``]` `    ``prefix ``=` `"geek"` `    ``print``(max_weight(strings, weights, n, prefix))` `    `  `# This code is contributed by prajwal kandekar`

## C#

 `// C# program to find the maximum weight` `// with given prefix.` `using` `System;`   `// Structure of a trie node` `public` `class` `TrieNode {` `    ``// Pointer its children.` `    ``public` `TrieNode[] Children;`   `    ``// To store weight of string.` `    ``public` `int` `Weight;`   `    ``public` `TrieNode()` `    ``{` `        ``Children = ``new` `TrieNode[26];` `        ``Weight = ``int``.MinValue;` `    ``}` `}`   `public` `class` `GFG {` `    ``// Create and return a Trie node` `    ``public` `static` `TrieNode GetNode()` `    ``{` `        ``return` `new` `TrieNode();` `    ``}`   `    ``// Inserting the node in the Trie.` `    ``public` `static` `TrieNode Insert(``string` `str, ``int` `wt,` `                                  ``int` `idx, TrieNode root)` `    ``{` `        ``int` `cur = str[idx] - ``'a'``;`   `        ``if` `(root.Children[cur] == ``null``)` `            ``root.Children[cur] = GetNode();`   `        ``// Assigning the maximum weight` `        ``root.Children[cur].Weight` `            ``= Math.Max(root.Children[cur].Weight, wt);`   `        ``if` `(idx + 1 != str.Length)` `            ``root.Children[cur] = Insert(str, wt, idx + 1,` `                                        ``root.Children[cur]);`   `        ``return` `root;` `    ``}`   `    ``// Search and return the maximum weight.` `    ``public` `static` `int` `SearchMaximum(``string` `prefix,` `                                    ``TrieNode root)` `    ``{` `        ``int` `idx = 0, n = prefix.Length, ans = -1;`   `        ``// Searching the prefix in Trie.` `        ``while` `(idx < n) {` `            ``int` `cur = prefix[idx] - ``'a'``;`   `            ``// If prefix not found return -1.` `            ``if` `(root.Children[cur] == ``null``)` `                ``return` `-1;`   `            ``ans = root.Children[cur].Weight;` `            ``root = root.Children[cur];` `            ``++idx;` `        ``}`   `        ``return` `ans;` `    ``}`   `    ``// Return the maximum weight of string having given` `    ``// prefix.` `    ``public` `static` `int` `MaxWeight(``string``[] str, ``int``[] weight,` `                                ``int` `n, ``string` `prefix)` `    ``{` `        ``TrieNode root = GetNode();`   `        ``// Inserting all string in the Trie.` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``root = Insert(str[i], weight[i], 0, root);`   `        ``return` `SearchMaximum(prefix, root);` `    ``}`   `    ``// Driver Program` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 3;` `        ``string``[] str` `            ``= { ``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"` `};` `        ``int``[] weight = { 15, 30, 45 };` `        ``string` `prefix = ``"geek"``;`   `        ``Console.WriteLine(` `            ``MaxWeight(str, weight, n, prefix));` `    ``}` `}`   `// This code is contributed by prasad264`

## Javascript

 `// JavaScript program to find the maximum weight` `// with given prefix.`   `// Structure of a trie node` `class TrieNode {` `  ``constructor() {` `  `  `    ``// Pointer its children.` `    ``this``.children = ``new` `Array(26);` `    ``this``.children.fill(``null``);` `    `  `    ``// To store weight of string.` `    ``this``.weight = Number.NEGATIVE_INFINITY;` `  ``}` `}`   `// Create and return a Trie node` `function` `get_node() {` `  ``return` `new` `TrieNode();` `}`   `// Inserting the node in the Trie.` `function` `insert(string, weight, idx, root) {` `  ``const cur = string.charCodeAt(idx) - ``'a'``.charCodeAt(0);` `  ``if` `(!root.children[cur]) {` `    ``root.children[cur] = get_node();` `  ``}` `  `  `  ``// Assigning the maximum weight` `  ``root.children[cur].weight = Math.max(root.children[cur].weight, weight);` `  ``if` `(idx + 1 !== string.length) {` `    ``root.children[cur] = insert(string, weight, idx + 1, root.children[cur]);` `  ``}` `  ``return` `root;` `}`   `// Search and return the maximum weight.` `function` `search_maximum(prefix, root) {` `  ``let idx = 0, n = prefix.length, ans = -1;`   `  ``// Searching the prefix in Trie.` `  ``while` `(idx < n) {` `    ``const cur = prefix.charCodeAt(idx) - ``'a'``.charCodeAt(0);` `    ``// If prefix not found return -1.` `    ``if` `(!root.children[cur]) {` `      ``return` `-1;` `    ``}` `    ``ans = root.children[cur].weight;` `    ``root = root.children[cur];` `    ``idx += 1;` `  ``}` `  ``return` `ans;` `}`   `// Return the maximum weight of string having given prefix.` `function` `max_weight(strings, weights, n, prefix) {` `  ``let root = get_node();`   `  ``// Inserting all string in the Trie.` `  ``for` `(let i = 0; i < n; i++) {` `    ``root = insert(strings[i], weights[i], 0, root);` `  ``}` `  ``return` `search_maximum(prefix, root);` `}`   `// Driver code` `const n = 3;` `const strings = [``"geeks"``, ``"geeksfor"``, ``"geeksforgeeks"``];` `const weights = [15, 30, 45];` `const prefix = ``"geek"``;` `console.log(max_weight(strings, weights, n, prefix));`

`45`

Time Complexity: O(n*m+k) where n is the number of strings in the input array, m is the maximum length of any string in the array, and k is the length of the prefix.
Auxiliary Space: O(n*m)

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.