热冗余冷冗余

Problem statement:

问题陈述：

Given a string of balanced expression, find if it contains a redundant parenthesis or not. A set of parentheses is redundant if the same sub-expression is surrounded by unnecessary or multiple brackets. Print "Yes" if redundant else "No".

给定一串平衡表达式，请查找它是否包含多余的括号。 如果相同的子表达式被不必要的或多个括号括起来，则一组括号是多余的。 如果多余则打印“是”，否则打印“否”。

Input:

输入：

The first line of input contains an integer T denoting the number of test cases. The next line T contains an expression. The expression contains all characters and ^, *, /, +, -.

输入的第一行包含一个整数T，表示测试用例的数量。 下一行T包含一个表达式。 该表达式包含所有字符以及^，*，/，+，- 。

Output:

输出：

For each test case, in a new line, print YES or NO if the expression is redundant or not.

对于每个测试用例，如果表达式是否多余，请在新行中打印YES或NO。

Examples:

例子：

    Input:
T = 1
((a+b))
Output:
YES
(a+b) is surrounded by extra (), which is of no need.
Input:
T = 1
(a+(a+b))
Output:
NO
here there is no extra bracket.

Solution Approach

解决方法

Stack Approach

堆叠方式

We will traverse from left to right and perform the following operations.

我们将从左到右遍历并执行以下操作。

• If the given character is not ')' then push that into stack otherwise we check for other probabilities as:

  如果给定字符不是')'，则将其压入堆栈，否则我们将检查其他概率为：

• We start to pop elements from the stack and check if the immediately popped element is '(' without any other any operator (+, -, /, *) in between them then it is a possible case of redundant brackets:

  我们开始从堆栈中弹出元素，并检查立即弹出的元素之间是否没有其他任何运算符(+，-，/，*)为'(' ，那么可能是多余的括号：

• If the immediately popped element is open bracket ')' then it is a condition of the redundant bracket.

  如果立即弹出的元素是方括号')'，则这是冗余方括号的条件。

Example:

例：

    ((a)),(((a+b))),((c)+d)

Pseudo Code:

伪代码：

string Redundant(string str)
{
stack<char>st     //declare stack
//iterate from left to right
for(int i=0;i<str.length();i++)
{
//is character is not ')' then push it into the stack.
if(str[i]!=')')
{
st.push(str[i])
}
//if the character is '(' the check for above
//mentioned possibilites
else if(str[i]==')')
{
//declare a boolean variable to check for
//immediate popped element condition.
bool flag=true
//variable to store temporary top elements.
int x=st.top()
st.pop()
while(x!='(')
{
// Check for operators in expression
if(str[i]=='+'||str[i]=='-'||str[i]=='/||str[i]=='^'||str[i]=='*')
flag=false
x=st.top()
st.pop()
}
//if there is immediate bracket without any
//operator then its redundant bracket.
if(flag==true)
{return "YES"}
}
}
//there is no redundant brackets.
return "NO"
}

Time Complexity for above approach is: O(n)
Space Complexity for above approach is: O(n)

上述方法的时间复杂度为：O(n)
上述方法的空间复杂度为：O(n)

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{ll t;
cout << "Enter number of test cases: ";
cin >> t;
while (t--) {string str;
cout << "Enter string: ";
cin >> str;
stack<char> st;
for (int i = 0; i < str.length(); i++) {//is character is not ')' then push it into the stack.
if (str[i] != ')')
st.push(str[i]);
//if the character is '(' the check for
//above mentioned possibilites
else {
//declare a boolean variable to check for
//immediate popped element condition.
bool flag = true;
char x = st.top(); //variable to store temporary top elements.
st.pop();
while (x != '(') {// Check for operators in expression
if (x == '+' || x == '-' || x == '*' || x == '^' || x == '/')
flag = false;
x = st.top();
st.pop();
}
//if there is immediate bracket without any operator
//then its redundant bracket.
if (flag == true) {cout << "YES"
<< "\n";
goto end;
}
}
}
cout << "NO"
<< "\n";
end:;
}
return 0;
}

Output

输出量

Enter number of test cases: 4
Enter string: (a+b)
NO
Enter string: ((a+b))
YES
Enter string: (a+(b*c)-(d+e))
NO
Enter string: (a)
YES

2) Implementation

2)实施

Instead of using the stack to check redundancy, we make two variables to check the number of operators and the number of brackets and check for the condition if some character is present without any operators.

我们使用两个变量来检查运算符的数量和方括号的数量，并检查条件是否存在一些没有任何运算符的字符，而不是使用堆栈来检查冗余。

Pseudo Code:

伪代码：

string Redundant(string str)
{
//declare two variable for bracket and
//operator respectively.
int x,y
x=0  //initialise them with 0
y=0
//iterate through loop
for(int i=0;i<str.length();i++)
{
//if there is immediate breacket return yes
if(str[i]=='(' and str[i+2]==')')
return "YES"
//count number of '('
if(str[i]=='(')
x++;
//count number of operators.
if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/'||str[i]=='^')
y++;
}
//if number of breacket is higher than operator
//then its redundant else its not redundant.
if(x>y)
return "YES"
else
return "NO"
}

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{ll t;
cout << "Enter number of test cases: ";
cin >> t;
while (t--) {string str;
cout << "Enter string: ";
cin >> str;
int x = 0;
int y = 0;
for (int i = 0; i < str.length(); i++) {//immediate bracket without any operators
if (str[i] == '(' and str[i + 2] == ')') {cout << "YES"
<< "\n";
goto end;
}
else if (str[i] == '(')
x++;
if (str[i] == '+' || str[i] == '-' || str[i] == '^' || str[i] == '*' || str[i] == '/')
y++;
}
//if number of brackets is greater than its redundant.
if (x > y)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
end:;
}
return 0;
}

Output

输出量

Enter number of test cases: 3
Enter string: (a)
YES
Enter string: (a+(b-c))
NO
Enter string: (a+(b*c)-d+c)
NO

翻译自: https://www.includehelp.com/icp/redundant-bracket.aspx

热冗余冷冗余