找到字典序的下一个平衡括号序列

给定一个平衡括号序列作为包含字符‘(‘或‘)’的字符串str ，任务是找到下一个字典顺序平衡序列，如果可能，否则打印-1 。
例子：

Input: str = “(())” 
Output: ()()
Input: str = “((()))” 
Output: (()()) 
 

方法：首先找到最右边的左括号，我们可以用右括号替换它，得到字典序更大的括号字符串。更新后的字符串可能不平衡，我们可以用字典上最小的部分填充字符串的剩余部分：即首先使用尽可能多的左括号，然后用右括号填充剩余位置。换句话说，我们尽量保持尽可能长的前缀不变，后缀被字典序最小的替换。
为了找到这个位置，我们可以从右到左遍历字符，并保持左括号和右括号的平衡深度。当我们遇到左括号时，我们会减少深度，当我们遇到右括号时，我们会增加深度。如果我们在某个时刻遇到左括号，并且处理此符号后的余额为正，那么我们已经找到了可以更改的最右边位置。我们更改符号，计算必须添加到右侧的左括号和右括号的数量，并以字典序最小的方式排列它们。
如果我们找不到合适的位置，那么这个序列已经是最大可能的一个，没有答案。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to find the lexicographically
// next balanced bracket
// expression if possible
string next_balanced_sequence(string& s)
{
    string next = "-1";
    int length = s.size();
    int depth = 0;
    for (int i = length - 1; i >= 0; --i) {
 
        // Decrement the depth for
        // every opening bracket
        if (s[i] == '(')
            depth--;
 
        // Increment for the
        // closing brackets
        else
            depth++;
 
        // Last opening bracket
        if (s[i] == '(' && depth > 0) {
            depth--;
            int open = (length - i - 1 - depth) / 2;
            int close = length - i - 1 - open;
 
            // Generate the required string
            next = s.substr(0, i) + ')'
                   + string(open, '(')
                   + string(close, ')');
            break;
        }
    }
    return next;
}
 
// Driver code
int main()
{
    string s = "((()))";
 
    cout << next_balanced_sequence(s);
 
    return 0;
}

Java

// Java implementation of the approach
class Sol
{
     
// makes a string containing char d
// c number of times
static String string(int c, char d)
{
    String s = "";
    for(int i = 0; i < c; i++)
    s += d;
     
    return s;
}
     
// Function to find the lexicographically
// next balanced bracket
// expression if possible
static String next_balanced_sequence(String s)
{
    String next = "-1";
    int length = s.length();
    int depth = 0;
    for (int i = length - 1; i >= 0; --i)
    {
 
        // Decrement the depth for
        // every opening bracket
        if (s.charAt(i) == '(')
            depth--;
 
        // Increment for the
        // closing brackets
        else
            depth++;
 
        // Last opening bracket
        if (s.charAt(i) == '(' && depth > 0)
        {
            depth--;
            int open = (length - i - 1 - depth) / 2;
            int close = length - i - 1 - open;
 
            // Generate the required String
            next = s.substring(0, i) + ')'
                + string(open, '(')
                + string(close, ')');
            break;
        }
    }
    return next;
}
 
// Driver code
public static void main(String args[])
{
    String s = "((()))";
 
    System.out.println(next_balanced_sequence(s));
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the approach
 
# Function to find the lexicographically
# next balanced bracket
# expression if possible
def next_balanced_sequence(s) :
 
    next = "-1";
    length = len(s);
    depth = 0;
     
    for i in range(length - 1, -1, -1) :
         
        # Decrement the depth for
        # every opening bracket
        if (s[i] == '(') :
            depth -= 1;
 
        # Increment for the
        # closing brackets
        else :
            depth += 1;
 
        # Last opening bracket
        if (s[i] == '(' and depth > 0) :
             
            depth -= 1;
            open = (length - i - 1 - depth) // 2;
            close = length - i - 1 - open;
 
            # Generate the required string
            next = s[0 : i] + ')' + open * '(' + close* ')';
            break;
             
    return next;
 
 
# Driver code
if __name__ == "__main__" :
 
    s = "((()))";
 
    print(next_balanced_sequence(s));
 
    # This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
 
class GFG
{
     
// makes a string containing char d
// c number of times
static String strings(int c, char d)
{
    String s = "";
    for(int i = 0; i < c; i++)
    s += d;
     
    return s;
}
     
// Function to find the lexicographically
// next balanced bracket
// expression if possible
static String next_balanced_sequence(String s)
{
    String next = "-1";
    int length = s.Length;
    int depth = 0;
    for (int i = length - 1; i >= 0; --i)
    {
 
        // Decrement the depth for
        // every opening bracket
        if (s[i] == '(')
            depth--;
 
        // Increment for the
        // closing brackets
        else
            depth++;
 
        // Last opening bracket
        if (s[i] == '(' && depth > 0)
        {
            depth--;
            int open = (length - i - 1 - depth) / 2;
            int close = length - i - 1 - open;
 
            // Generate the required String
            next = s.Substring(0, i) + ')' +
                        strings(open, '(') +
                        strings(close, ')');
            break;
        }
    }
    return next;
}
 
// Driver code
public static void Main(String []args)
{
    String s = "((()))";
 
    Console.WriteLine(next_balanced_sequence(s));
}
}
 
// This code is contributed by Princi Singh

Javascript

 
// Javascript program for the above approach
 
// makes a string containing char d
// c number of times
function string(c, d)
{
    let s = "";
    for(let i = 0; i < c; i++)
    s += d;
     
    return s;
}
     
// Function to find the lexicographically
// next balanced bracket
// expression if possible
function next_balanced_sequence(s)
{
    let next = "-1";
    let length = s.length;
    let depth = 0;
    for (let i = length - 1; i >= 0; --i)
    {
 
        // Decrement the depth for
        // every opening bracket
        if (s[i] == '(')
            depth--;
 
        // Increment for the
        // closing brackets
        else
            depth++;
 
        // Last opening bracket
        if (s[i] == '(' && depth > 0)
        {
            depth--;
            let open = (length - i - 1 - depth) / 2;
            let close = length - i - 1 - open;
 
            // Generate the required String
            next = s.substr(0, i) + ')'
                + string(open, '(')
                + string(close, ')');
            break;
        }
    }
    return next;
}
 
// Driver Code
 
    let s = "((()))";
 
    document.write(next_balanced_sequence(s));
  
 // This code is contributed by sanjoy_62.

输出：

(()())

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