Dada una cadena P que consta solo de paréntesis y caracteres de asterisco (es decir, “(”, “)” y “ "), se le pedirá que reemplace todos los caracteres de asterisco para obtener una cadena de paréntesis equilibrada con la longitud más corta posible, donde puede reemplazar cada " " por un "(", o un ")", o una cadena vacía "".
Una cadena de paréntesis S es una cadena que consta solo de paréntesis (es decir, "(" y ")"), y se considera equilibrada si y solo si:
● S is an empty string, or
● there exist two balanced parenthesis strings A and B such that S=AB, or
● there exists a balanced parenthesis string C such that S=(C).
Por ejemplo, “”, “()”, “(())”, “() ()”, “() (())” son cadenas de paréntesis balanceadas.
Debido a una notoria incapacidad técnica, si hay varias soluciones con la menor longitud posible, entonces debe informar la más pequeña posible en orden lexicográfico.
Por cada dos cadenas diferentes A y B de la misma longitud n, decimos que A es menor que B en orden lexicográfico si y solo si existe algún número entero k tal que:
● 1≤k≤n, and
● the first (k−1) characters of A and that of B are exactly the same, and
● the k-th character of A is smaller than that of B.
Por ejemplo, “() (())” es más pequeño que “() () ()”, y en este caso, k = 4.
Entrada
Hay varios casos de prueba.
La primera línea contiene un número entero T (1≤T≤105), que denota el número de casos de prueba. Luego siga todos los casos de prueba.
Para cada caso de prueba, la única línea contiene una cadena de longitud n (1≤n≤105), que denota la cadena P que consta solo de paréntesis y caracteres de asterisco.
Se garantiza que la suma de n en todos los casos de prueba no sea mayor que 5 × 106.
Salida
Para cada caso de prueba, salida en una línea "¡No hay solución!" (sin comillas) si no existe una solución, o de lo contrario, la solución más pequeña posible en orden lexicográfico. Tenga en cuenta que los caracteres de salida distinguen entre mayúsculas y minúsculas.
Entrada de muestra
5
)) )
( ) *
) (*
((* ) () ((
Salida de muestra
sin solución!
()
() ()
(()) () (())
Idea : use la pila para almacenar uno de los paréntesis y luego deque para almacenar * para hacer coincidir
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cctype>
#include<iomanip>
#include<map>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<set>
#include<cctype>
#include<string>
#include<stdexcept>
#include<fstream>
#include<sstream>
#define mem(a,b) memset(a,b,sizeof(a))
#define debug() puts("what the fuck!")
#define dedebug() puts("what the fuck!!!")
#define ll long long
#define ull unsigned long long
#define speed {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); };
using namespace std;
const double PI = acos(-1.0);
const int maxn = 1e6 + 50;
const int N = 110;
const int INF = 0x3f3f3f3f;
const int inf = 0xfffffff;//比INF小，防止累加爆int
const double esp_0 = 1e-6;
const double gold = (1 + sqrt(5)) / 2;
const int mod = 193;
int gcd(int x, int y) {
return y ? gcd(y, x % y) : x;
}
char s[maxn];
stack<int>stk;
deque<int>d;
void init() {
while (!stk.empty()) {
stk.pop();
}
while (!d.empty()) {
d.pop_back();
}
}
int main() {
speed;
int t;
cin >> t;
while (t--) {
init();
cin >> s + 1;
int len = strlen(s + 1);
int flag = 1;
for (int i = 1; i <= len; ++i) {
if (s[i] == '*')d.push_back(i);
if (s[i] == '(')stk.push(i);
if (s[i] == ')') {
if (!stk.empty())stk.pop();
else if (!d.empty()) {
s[d.front()] = '(';
d.pop_front();
}
else {
flag = 0;
break;
}
}
}
while (!stk.empty()) {
if (!d.empty() && d.back() > stk.top()) {
s[d.back()] = ')';
d.pop_back();
stk.pop();
}
else {
flag = 0;
break;
}
}
if (!flag)cout << "No solution!" << endl;
else {
for (int i = 1; i <= len; ++i) {
if (s[i] == '(' || s[i] == ')')
cout << s[i];
}
cout << endl;
}
}
return 0;
}