查找满足给定条件的字典上最小的字符串

给定一个数组，它是N个整数的arr [] ，其中arr [i]代表字符串S的长度(i +1)前缀中不同字符的数量。任务是找到满足给定前缀数组的按字典顺序最小的字符串(如果存在)。该字符串应为小写英文字母[az]。如果不存在这样的字符串，则打印-1 。

例子：

Input: arr[] = {1, 1, 2, 3}
Output: aabc
prefix[0] has 1 distinct character
prefix[1] has 1 distinct character
prefix[2] has 2 distinct characters
prefix[3] has 3 distinct characters
And the string is the smallest possible.

Input: arr[] = {1, 2, 2, 3, 3, 4}
Output: abacad

Input: arr[] = {1, 1, 3, 3}
Output: -1

做法：每个字符串的第一个字符将始终为“A”。由于我们必须找到字典上最小的字符串。因此，如果不同的字符的长度i和i + 1的前缀的数量是相同的，则第(i + 1)个字符将是“A”，否则这将是从在长度的所有字符的不同的字符i和它会比长度i的前缀中的最大字符大一个。
例如，如果前缀数组为{1、2、2、3、4}，则第一个字符为‘a’ ，第二个字符为‘b’，因为不同字符的数量为2 (也可以为‘c ‘或‘d’等，但我们必须按字典顺序将其最小化)。第三个字符将是‘a’或‘b’，但我们取‘a’是因为“ aba”小于“ abb” 。
同样，第四个和第五个字符是“ c”和“ d” 。因此，满足给定前缀数组的结果字符串将为“ abacd” 。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Function to return the required string
string smallestString(int N, int A[])
{
    // First character will always be 'a'
    char ch = 'a';
  
    // To store the resultant string
    string S = "";
  
    // Since length of the string should be
    // greater than 0 and first element
    // of array should be 1
    if (N < 1 || A[0] != 1) {
        S = "-1";
        return S;
    }
  
    S += ch;
    ch++;
  
    // Check one by one all element of given prefix array
    for (int i = 1; i < N; i++) {
        int diff = A[i] - A[i - 1];
  
        // If the difference between any two
        // consecutive elements of the prefix array
        // is greater than 1 then there will be no such
        // string possible that satisfies the given array
        // Also, string cannot have more than
        // 26 distinct characters
        if (diff > 1 || diff < 0 || A[i] > 26) {
            S = "-1";
            return S;
        }
  
        // If difference is 0 then the (i + 1)th character
        // will be same as the ith character
        else if (diff == 0)
            S += 'a';
  
        // If difference is 1 then the (i + 1)th character
        // will be different from the ith character
        else {
            S += ch;
            ch++;
        }
    }
  
    // Return the resultant string
    return S;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 1, 2, 3, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << smallestString(n, arr);
  
    return 0;
}

Java

// Java implementation of the above approach 
class GFG 
{ 
      
    // Function to return the required string 
    static String smallestString(int N, int []A) 
    { 
        // First character will always be 'a' 
        char ch = 'a'; 
      
        // To store the resultant string 
        String S = ""; 
      
        // Since length of the string should be 
        // greater than 0 and first element 
        // of array should be 1 
        if (N < 1 || A[0] != 1) 
        { 
            S = "-1"; 
            return S; 
        } 
      
        S += ch; 
        ch++; 
      
        // Check one by one all element of given prefix array 
        for (int i = 1; i < N; i++) 
        { 
            int diff = A[i] - A[i - 1]; 
      
            // If the difference between any two 
            // consecutive elements of the prefix array 
            // is greater than 1 then there will be no such 
            // string possible that satisfies the given array 
            // Also, string cannot have more than 
            // 26 distinct characters 
            if (diff > 1 || diff < 0 || A[i] > 26) 
            { 
                S = "-1"; 
                return S; 
            } 
      
            // If difference is 0 then the (i + 1)th character 
            // will be same as the ith character 
            else if (diff == 0) 
                S += 'a'; 
      
            // If difference is 1 then the (i + 1)th character 
            // will be different from the ith character 
            else
            { 
                S += ch; 
                ch++; 
            } 
        } 
      
        // Return the resultant string 
        return S; 
    } 
      
    // Driver code 
    public static void main(String args[]) 
    { 
        int []arr = { 1, 1, 2, 3, 3 }; 
        int n = arr.length; 
        System.out.println(smallestString(n, arr)); 
    } 
} 
  
// This code is contributed by Ryuga

Python3

# Function to return the required string
def smallestString(N, A):
      
    # First character will always be 'a'
    ch = 'a'
  
    # To store the resultant string
    S = ""
  
    # Since length of the string should be
    # greater than 0 and first element
    # of array should be 1
    if (N < 1 or A[0] != 1):
        S = "-1"
        return S
  
    S += str(ch)
    ch = chr(ord(ch) + 1)
  
    # Check one by one all element of 
    # given prefix array
    for i in range(1, N):
        diff = A[i] - A[i - 1]
  
        # If the difference between any two
        # consecutive elements of the prefix 
        # array is greater than 1 then there 
        # will be no such string possible that 
        # satisfies the given array. 
        # Also, string cannot have more than
        # 26 distinct characters
        if (diff > 1 or diff < 0 or A[i] > 26):
            S = "-1"
            return S
  
        # If difference is 0 then the 
        # (i + 1)th character will be 
        # same as the ith character
        elif (diff == 0):
            S += 'a'
  
        # If difference is 1 then the 
        # (i + 1)th character will be 
        # different from the ith character
        else:
            S += ch
            ch = chr(ord(ch) + 1)
  
    # Return the resultant string
    return S
  
# Driver code
arr = [1, 1, 2, 3, 3]
n = len(arr)
print(smallestString(n, arr))
  
# This code is contributed 
# by mohit kumar

C#

// C# implementation of the approach
using System;
  
class GFG
{
      
// Function to return the required string
static string smallestString(int N, int []A)
{
    // First character will always be 'a'
    char ch = 'a';
  
    // To store the resultant string
    string S = "";
  
    // Since length of the string should be
    // greater than 0 and first element
    // of array should be 1
    if (N < 1 || A[0] != 1) 
    {
        S = "-1";
        return S;
    }
  
    S += ch;
    ch++;
  
    // Check one by one all element of given prefix array
    for (int i = 1; i < N; i++)
    {
        int diff = A[i] - A[i - 1];
  
        // If the difference between any two
        // consecutive elements of the prefix array
        // is greater than 1 then there will be no such
        // string possible that satisfies the given array
        // Also, string cannot have more than
        // 26 distinct characters
        if (diff > 1 || diff < 0 || A[i] > 26) 
        {
            S = "-1";
            return S;
        }
  
        // If difference is 0 then the (i + 1)th character
        // will be same as the ith character
        else if (diff == 0)
            S += 'a';
  
        // If difference is 1 then the (i + 1)th character
        // will be different from the ith character
        else 
        {
            S += ch;
            ch++;
        }
    }
  
    // Return the resultant string
    return S;
}
  
// Driver code
static void Main()
{
    int []arr = { 1, 1, 2, 3, 3 };
    int n = arr.Length;
    Console.WriteLine(smallestString(n, arr));
}
}
  
// This code is contributed by mits

PHP

 1 || $diff < 0 || $A[$i] > 26) 
        { 
            $S = "-1"; 
            return $S; 
        } 
  
        // If difference is 0 then the (i + 1)th character 
        // will be same as the ith character 
        else if ($diff == 0) 
            $S .= 'a'; 
  
        // If difference is 1 then the (i + 1)th character 
        // will be different from the ith character 
        else
        { 
            $S .= $ch; 
            $ch++; 
        } 
    } 
  
    // Return the resultant string 
    return $S; 
} 
  
// Driver code 
$arr = array( 1, 1, 2, 3, 3 ); 
$n = sizeof($arr); 
echo(smallestString($n, $arr)); 
  
// This code is contributed by Code_Mech
?>

输出：

aabca