Weighted Prefix Search

Last Updated : 12 Sep, 2023

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<bits/stdc++.h> 
#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

<script> 
    // Javascript program to find the maximum weight with given prefix. 
      
    // Return the maximum weight of  
    // string having given prefix. 
    function maxWeight(str, weight, n, prefix) 
    { 
        let ans = -1; 
        let check; 
    
        // Traversing all strings 
        for (let i = 0; i < n; i++) 
        { 
            check = true; 
    
            // Checking if string contain given prefix. 
            for (let 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; 
    } 
      
    let n = 3; 
    let str = ["geeks", "geeksfor", "geeksforgeeks"]; 
    let weight = [15, 30, 45]; 
    let prefix = "geek"; 
  
    document.write(maxWeight(str, weight,  
                                n, prefix)); 
      
</script>

Output:

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<bits/stdc++.h> 
#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)); 

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)

Anuj Chauhan

Improve

What is Linear Search?

Weighted Prefix Search

C++

Java

Python3

C#

Javascript

C++

Java

Python3

C#

Javascript

Please Login to comment...

Similar Reads

What kind of Experience do you want to share?