一个字符串在其所有子字符串中的词典排名

给定字符串str ，任务是在按字典顺序排列的所有子字符串中找到给定字符串的排名。

例子：

Input: S = “enren”
Output: 7
Explanation:
All the possible substrings in the sorted order are {“e”, “e”, “en”, “en”, “enr”, “enre”, “enren”, “n”, “n”, “nr”, “nre”, “nren”, “r”, “re”, “ren”}.
Therefore, the rank of the given string “enren” is 7.

Input: S = “geeks”
Output: 12
Explanation:
All possible substrings in the sorted order are {“e”, “e”, “ee”, “eek”, “eeks”, “ek”, “eks”, “g”, “ge”, “gee”, “geek”, “geeks”, “k”, “ks”, “s”}.
Therefore, the rank of the given string “geeks” is 12.

处理方法：按照以下步骤解决问题：

1. 初始化长度为26的向量数组arr[]以存储字符串存在的字符的索引，并将其排序为 0。
2. 存储每个字符的索引。的索引将被存储在ARR [0]，对于b，编曲[1]将存储其所有指数，等等。
3. 遍历存储在数组ARR []到其比字符串S的第一字符较小字符的每个索引。
4. 对于每个索引i ，从该索引开始的总子串是N – i 。添加N – i以排名，因为具有这些索引的所有字符都较小。
5. 现在，遍历后，存储从S的第一个字符开始的所有子串，并按字典顺序对这些子串进行排序。
6. 遍历排序后的子串并将每个子串与字符串S进行比较，并递增排名，直到找到等于S 的子串。
7. 打印rank + 1的值以获取给定字符串的等级。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find lexiographic rank
// of string among all its substring
int lexiographicRank(string s)
{
    // Length of string
    int n = s.length();
 
    vector alphaIndex[26];
 
    // Traverse the given string
    // and store the indices of
    // each character
    for (int i = 0; i < s.length(); i++) {
 
        // Extract the index
        int x = s[i] - 'a';
 
        // Store it in the vector
        alphaIndex[x].push_back(i);
    }
 
    // Traverse the aphaIndex array
    // lesser than the index of first
    // character of given string
    int rank = 0;
 
    for (int i = 0; i < 26
                    && 'a' + i < s[0];
         i++) {
 
        // If alphaIndex[i] size exceeds 0
        if (alphaIndex[i].size() > 0) {
 
            // Traverse over the indices
            for (int j = 0;
                 j < alphaIndex[i].size(); j++) {
 
                // Add count of substring
                // equal to n - alphaIndex[i][j]
                rank = rank
                       + (n
                          - alphaIndex[i][j]);
            }
        }
    }
 
    vector str;
 
    for (int i = 0;
         i < alphaIndex[s[0] - 'a'].size();
         i++) {
 
        // Store all substrings in a vector
        // str starting with the first
        // character of the given string
        string substring;
 
        int j = alphaIndex[s[0] - 'a'][i];
 
        for (; j < n; j++) {
 
            // Insert the current
            // character to substring
            substring.push_back(s[j]);
 
            // Store the substring formed
            str.push_back(substring);
        }
    }
 
    // Sort the substring in the
    // lexicographical order
    sort(str.begin(), str.end());
 
    // Find the rank of given string
    for (int i = 0; i < str.size(); i++) {
 
        if (str[i] != s) {
 
            // increase the rank until
            // the given string is same
            rank++;
        }
 
        // If substring is same as
        // the given string
        else {
            break;
        }
    }
 
    // Add 1 to rank of
    // the given string
    return rank + 1;
}
 
// Driver Code
int main()
{
    // Given string
    string str = "enren";
 
    // Function Call
    cout << lexiographicRank(str);
 
    return 0;
}

Java

// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to find lexiographic rank
// of String among all its subString
static int lexiographicRank(char []s)
{
  // Length of String
  int n = s.length;
 
  Vector []alphaIndex = new Vector[26];
  for (int i = 0; i < alphaIndex.length; i++)
    alphaIndex[i] = new Vector();
   
  // Traverse the given String
  // and store the indices of
  // each character
  for (int i = 0; i < s.length; i++)
  {
    // Extract the index
    int x = s[i] - 'a';
 
    // Store it in the vector
    alphaIndex[x].add(i);
  }
 
  // Traverse the aphaIndex array
  // lesser than the index of first
  // character of given String
  int rank = 0;
 
  for (int i = 0; i < 26 &&
           'a' + i < s[0]; i++)
  {
    // If alphaIndex[i] size exceeds 0
    if (alphaIndex[i].size() > 0)
    {
      // Traverse over the indices
      for (int j = 0;
               j < alphaIndex[i].size();
               j++)
      {
        // Add count of subString
        // equal to n - alphaIndex[i][j]
        rank = rank + (n - alphaIndex[i].get(j));
      }
    }
  }
 
  Vector str = new Vector();
 
  for (int i = 0;
           i < alphaIndex[s[0] - 'a'].size();
           i++)
  {
    // Store all subStrings in a vector
    // str starting with the first
    // character of the given String
    String subString = "";
 
    int j = alphaIndex[s[0] - 'a'].get(i);
 
    for (; j < n; j++)
    {
      // Insert the current
      // character to subString
      subString += (s[j]);
 
      // Store the subString formed
      str.add(subString);
    }
  }
 
  // Sort the subString in the
  // lexicographical order
  Collections.sort(str);
 
  // Find the rank of given String
  for (int i = 0; i < str.size(); i++)
  {
    if (!str.get(i).equals(String.valueOf(s)))
    {
      // increase the rank until
      // the given String is same
      rank++;
    }
 
    // If subString is same as
    // the given String
    else
    {
      break;
    }
  }
 
  // Add 1 to rank of
  // the given String
  return rank + 1;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given String
  String str = "enren";
 
  // Function Call
  System.out.print(lexiographicRank(str.toCharArray()));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program for the above approach
 
# Function to find lexiographic rank
# of among all its substrring
def lexiographicRank(s):
     
    # Length of strring
    n = len(s)
 
    alphaIndex = [[] for i in range(26)]
 
    # Traverse the given strring
    # and store the indices of
    # each character
    for i in range(len(s)):
 
        # Extract the index
        x = ord(s[i]) - ord('a')
 
        # Store it in the vector
        alphaIndex[x].append(i)
 
    # Traverse the aphaIndex array
    # lesser than the index of first
    # character of given strring
    rank = -1
 
    for i in range(26):
        if ord('a') + i >= ord(s[0]):
            break
 
        # If alphaIndex[i] size exceeds 0
        if len(alphaIndex[i]) > 0:
 
            # T raverse over the indices
            for j in range(len(alphaIndex[i])):
 
                # Add count of substrring
                # equal to n - alphaIndex[i][j]
                rank = rank + (n - alphaIndex[i][j])
                 
    # print(rank)
    strr = []
 
    for i in range(len(alphaIndex[ord(s[0]) - ord('a')])):
 
        # Store all substrrings in a vector
        # strr starting with the first
        # character of the given strring
        substrring = []
 
        jj = alphaIndex[ord(s[0]) - ord('a')][i]
 
        for j in range(jj, n):
 
            # Insert the current
            # character to substrring
            substrring.append(s[j])
 
            # Store the subformed
            strr.append(substrring)
 
    # Sort the subin the
    # lexicographical order
    strr = sorted(strr)
 
    # Find the rank of given strring
    for i in range(len(strr)):
        if (strr[i] != s):
 
            # Increase the rank until
            # the given is same
            rank += 1
 
        # If subis same as
        # the given strring
        else:
            break
 
    # Add 1 to rank of
    # the given strring
    return rank + 1
 
# Driver Code
if __name__ == '__main__':
     
    # Given strring
    strr = "enren"
 
    # Function call
    print(lexiographicRank(strr))
 
# This code is contributed by mohit kumar 29

C#

// C# program for
// the above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to find lexiographic rank
// of String among all its subString
static int lexiographicRank(char []s)
{
  // Length of String
  int n = s.Length;
 
  List []alphaIndex = new List[26];
  for (int i = 0; i < alphaIndex.Length; i++)
    alphaIndex[i] = new List();
 
  // Traverse the given String
  // and store the indices of
  // each character
  for (int i = 0; i < s.Length; i++)
  {
    // Extract the index
    int x = s[i] - 'a';
 
    // Store it in the vector
    alphaIndex[x].Add(i);
  }
 
  // Traverse the aphaIndex array
  // lesser than the index of first
  // character of given String
  int rank = 0;
 
  for (int i = 0; i < 26 &&
           'a' + i < s[0]; i++)
  {
    // If alphaIndex[i] size exceeds 0
    if (alphaIndex[i].Count > 0)
    {
      // Traverse over the indices
      for (int j = 0;
               j < alphaIndex[i].Count; j++)
      {
        // Add count of subString
        // equal to n - alphaIndex[i,j]
        rank = rank + (n - alphaIndex[i][j]);
      }
    }
  }
 
  List str = new List();
 
  for (int i = 0;
           i < alphaIndex[s[0] - 'a'].Count; i++)
  {
    // Store all subStrings in a vector
    // str starting with the first
    // character of the given String
    String subString = "";
 
    int j = alphaIndex[s[0] - 'a'][i];
 
    for (; j < n; j++)
    {
      // Insert the current
      // character to subString
      subString += (s[j]);
 
      // Store the subString formed
      str.Add(subString);
    }
  }
 
  // Sort the subString in the
  // lexicographical order
  str.Sort();
 
  // Find the rank of given String
  for (int i = 0; i < str.Count; i++)
  {
    if (!str[i].Equals(String.Join("", s)))
    {
      // increase the rank until
      // the given String is same
      rank++;
    }
 
    // If subString is same as
    // the given String
    else
    {
      break;
    }
  }
 
  // Add 1 to rank of
  // the given String
  return rank + 1;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given String
  String str = "enren";
 
  // Function Call
  Console.Write(lexiographicRank(str.ToCharArray()));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
 
// JavaScript program for the above approach
 
// Function to find lexiographic rank
// of string among all its substring
function lexiographicRank(s)
{
    // Length of string
    var n = s.length;
 
    var alphaIndex = Array.from(Array(26),
    ()=>new Array());
 
    // Traverse the given string
    // and store the indices of
    // each character
    for (var i = 0; i < s.length; i++) {
 
        // Extract the index
        var x = s[i].charCodeAt(0) -
               'a'.charCodeAt(0);
 
        // Store it in the vector
        alphaIndex[x].push(i);
    }
 
    // Traverse the aphaIndex array
    // lesser than the index of first
    // character of given string
    var rank = 0;
 
    for (var i = 0; i < 26
         && 'a'.charCodeAt(0) +
         i < s[0].charCodeAt(0);
         i++) {
 
        // If alphaIndex[i] size exceeds 0
        if (alphaIndex[i].length > 0) {
 
            // Traverse over the indices
            for (var j = 0;
                 j < alphaIndex[i].length; j++) {
 
                // Add count of substring
                // equal to n - alphaIndex[i][j]
                rank = rank
                       + (n
                          - alphaIndex[i][j]);
            }
        }
    }
 
    var str = [];
 
    for (var i = 0;
         i < alphaIndex[s[0].charCodeAt(0) -
         'a'.charCodeAt(0)].length;
         i++) {
 
        // Store all substrings in a vector
        // str starting with the first
        // character of the given string
        var substring = "";
 
        var j = alphaIndex[s[0].charCodeAt(0) -
        'a'.charCodeAt(0)][i];
 
        for (; j < n; j++) {
 
            // Insert the current
            // character to substring
            substring+=(s[j]);
 
            // Store the substring formed
            str.push(substring);
        }
    }
 
    // Sort the substring in the
    // lexicographical order
    str.sort();
 
    // Find the rank of given string
    for (var i = 0; i < str.length; i++) {
 
        if (str[i] != s) {
 
            // increase the rank until
            // the given string is same
            rank++;
        }
 
        // If substring is same as
        // the given string
        else {
            break;
        }
    }
 
    // Add 1 to rank of
    // the given string
    return rank + 1;
}
 
// Driver Code
 
// Given string
var str = "enren";
 
// Function Call
document.write( lexiographicRank(str));
 
 

输出：

7

时间复杂度： O(N ³ )
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live