找到满足给定条件的字典序最小的字符串

给定一个由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 。

例如，如果前缀数组是{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
?>

Javascript

 
// Javascript implementation of the approach
 
// Function to return the required string
function smallestString(N, A)
{
     
    // First character will always be 'a'
    let ch = 'a';
 
    // To store the resultant string
    let 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 = String.fromCharCode(ch.charCodeAt(0) + 1);
 
    // Check one by one all element of
    // given prefix array
    for(let i = 1; i < N; i++)
    {
        let 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 = String.fromCharCode(
                ch.charCodeAt(0) + 1);
        }
    }
 
    // Return the resultant string
    return S;
}
 
// Driver code
let arr = [ 1, 1, 2, 3, 3 ];
let n = arr.length;
 
document.write(smallestString(n, arr));
 
// This code is contributed by souravmahato348
 

输出：

aabca

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。