Java实现 LeetCode 770 基本计算器 IV（暴力+分析题）
770. 基本计算器 IV
给定一个表达式 expression 如 expression = “e + 8 - a + 5” 和一个求值映射，如 {“e”: 1}（给定的形式为 evalvars = [“e”] 和 evalints = [1]），返回表示简化表达式的标记列表，例如 ["-1*a",“14”]
表达式交替使用块和符号，每个块和符号之间有一个空格。
块要么是括号中的表达式，要么是变量，要么是非负整数。
块是括号中的表达式，变量或非负整数。
变量是一个由小写字母组成的字符串（不包括数字）。请注意，变量可以是多个字母，并注意变量从不具有像 “2x” 或 “-x” 这样的前导系数或一元运算符 。
表达式按通常顺序进行求值：先是括号，然后求乘法，再计算加法和减法。例如，expression = “1 + 2 * 3” 的答案是 [“7”]。
输出格式如下：
对于系数非零的每个自变量项，我们按字典排序的顺序将自变量写在一个项中。例如，我们永远不会写像 “bac” 这样的项，只写 “abc”。
项的次数等于被乘的自变量的数目，并计算重复项。(例如，“aabc" 的次数为 4。)。我们先写出答案的最大次数项，用字典顺序打破关系，此时忽略词的前导系数。
项的前导系数直接放在左边，用星号将它与变量分隔开(如果存在的话)。前导系数 1 仍然要打印出来。
格式良好的一个示例答案是 ["-2aaa”, “3aab", "3bb", "4a”, “5*c”, “-6”] 。
系数为 0 的项（包括常数项）不包括在内。例如，“0” 的表达式输出为 []。
示例：
输入：expression = "e + 8 - a + 5", evalvars = ["e"], evalints = [1]
输出：["-1*a","14"]
输入：expression = "e - 8 + temperature - pressure",
evalvars = ["e", "temperature"], evalints = [1, 12]
输出：["-1*pressure","5"]
输入：expression = "(e + 8) * (e - 8)", evalvars = [], evalints = []
输出：["1*e*e","-64"]
输入：expression = "7 - 7", evalvars = [], evalints = []
输出：[]
输入：expression = "a * b * c + b * a * c * 4", evalvars = [], evalints = []
输出：["5*a*b*c"]
输入：expression = "((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a))",
evalvars = [], evalints = []
输出：["-1*a*a*b*b","2*a*a*b*c","-1*a*a*c*c","1*a*b*b*b","-1*a*b*b*c","-1*a*b*c*c","1*a*c*c*c","-1*b*b*b*c","2*b*b*c*c","-1*b*c*c*c","2*a*a*b","-2*a*a*c","-2*a*b*b","2*a*c*c","1*b*b*b","-1*b*b*c","1*b*c*c","-1*c*c*c","-1*a*a","1*a*b","1*a*c","-1*b*c"]
提示：
expression 的长度在 [1, 250] 范围内。
evalvars, evalints 在范围 [0, 100] 内，且长度相同。
PS：
首先这个题，先别慌，（尽管我很慌o(><；)oo），但是一定要理性分析，
我们把所有的方法分开，他就是让我们把这个式子分开，常数和变量的数分开，这可能是我这种笨蛋读了十分钟才读懂题目，
class Solution {
public List<String> basicCalculatorIV(String expression, String[] evalvars, int[] evalints) {
HashMap<String,Integer>map=new HashMap<>();
for (int i = 0; i <evalvars.length ; i++) {
map.put(evalvars[i],evalints[i]);
}
LinkedList<Expr> mainStack=new LinkedList();//存数字，变量
LinkedList<String> opStack=new LinkedList<>();//存符号
int i=0,len=expression.length();char [] str=expression.toCharArray();
while (i<len)
{
if (str[i]==' '){i++;continue;}
else if (Character.isDigit(str[i])){ //获取数字
int x=0;
while (i<len&&Character.isDigit(str[i]))
{x=10*x+str[i]-'0';i++;}//统计数字的常用模板
mainStack.push(new Expr(new Item(x)));
}else if (str[i]>='a'&&str[i]<='z')
{
StringBuilder sb=new StringBuilder();
while (i<len&&(str[i]>='a'&&str[i]<='z'))
{sb.append(str[i]);i++;}
String s=sb.toString();
if (map.containsKey(s))//如果该变量有值
{ //变量变数字
mainStack.push(new Expr(new Item(map.get(s))));
}else {
//创建变量多项式
mainStack.push(new Expr(new Item(1,s)));
}
//左括号直接入栈
}else if (str[i]=='('){opStack.push("(");i++;}
else if (str[i]==')'){
//遇到有括号，则不停出栈，运算，直到遇到左括号为止
while (!opStack.isEmpty()&&!opStack.peek().equals("(")){
String op=opStack.pop();
Expr expr2=mainStack.pop();
Expr expr1=mainStack.pop();
mainStack.push(expr1.operate(expr2,op));
} opStack.pop();i++;//左括号出栈，指针移动
}else if (str[i]=='*'){
while (!opStack.isEmpty()&&opStack.peek().equals("*"))
{
//如果栈顶为乘号，先计算乘号，把乘法处理完
String op=opStack.pop();
Expr expr2=mainStack.pop();
Expr expr1=mainStack.pop();
mainStack.push(expr1.operate(expr2,op));
}opStack.push("*");i++;//再入栈
}else { //把前驱的加减号处理完
while (!opStack.isEmpty()&&(opStack.peek().equals("+")||
opStack.peek().equals("-")||opStack.peek().equals("*"))){
String op=opStack.pop();
Expr expr2=mainStack.pop();
Expr expr1=mainStack.pop();
mainStack.push(expr1.operate(expr2,op));
}opStack.push(str[i]=='+'?"+":"-");i++;
}
}
while (!opStack.isEmpty())
{ //处理后缀表达式
String op=opStack.pop();
Expr expr2=mainStack.pop();
Expr expr1=mainStack.pop();
mainStack.push(expr1.operate(expr2,op));
}
List<String> res=new ArrayList<>();
Expr expr=mainStack.pop();
expr.clean();
for (Item item:expr.items)res.add(item.toString());
return res;
}
}
//单项式
class Item implements Comparable<Item>{
int coeff; //单项式系数
ArrayList<String> factors;//单项式字母
public Item(int coeff) {
this.coeff = coeff;factors=new ArrayList<>();
}
public Item() {
this.factors = new ArrayList<>();
coeff=0;
}
public Item(int coeff, String f) {
this.coeff = coeff;
this.factors = new ArrayList<>();
factors.add(f);
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
sb.append(coeff);
for (String s:factors)
{sb.append("*").append(s);}
return sb.toString();
}
@Override
public int compareTo(Item item) {
if (this.factors.size()==item.factors.size())//如果两个单项式字母长度相等
{
int i=0,len=this.factors.size();//按照字典顺序比较
while (i<len&&factors.get(i).compareTo(item.factors.get(i))==0)i++;
return i==len?0:factors.get(i).compareTo(item.factors.get(i));
}else {
//按长度从大到小排位
return item.factors.size()-factors.size();
}
}
//单项式相乘
Item mutil(Item item){
Item res=new Item();
res.coeff=coeff*item.coeff;//乘系数
res.factors.addAll(factors);
res.factors.addAll(item.factors); //合并字母
res.factors.sort(String::compareTo);//排序
return res;
}
}
//多项式：由多个单项式组成
class Expr{
ArrayList<Item> items; //单项式列表
public Expr(Item item) {
this.items = new ArrayList<>();
items.add(item);
}
void add(Expr expr){ //将另外多项式的项直接合并过来
items.addAll(expr.items);
items.sort(Item::compareTo);//排序
clean();//去除冗余项
}
void mul(Expr expr){
ArrayList<Item> res=new ArrayList<>();
for (Item item1:items)
for (Item item2:expr.items)
res.add(item1.mutil(item2)); //将每一项按乘法规则相乘
this.items=res;
items.sort(Item::compareTo);
clean();
}
Expr clean(){ //去除冗余同项
int i=0;
for (; i <items.size(); i++) {
//对于每个单项式，比较前后两个
while (i+1<items.size()&&items.get(i).compareTo(items.get(i+1))==0)
{
//如果前后两个单项式字母相等，则合并，并删除靠后的一个
items.get(i).coeff+=items.get(i+1).coeff;
items.remove(i+1);
}
//如果单项式系数=0 删除该项
if (i<items.size()&&items.get(i).coeff==0)
items.remove(i--);
}
return this;
}
Expr operate(Expr expr,String op){
switch (op){
case "*":mul(expr);break;
case "+":add(expr);break;
case "-":
for (Item item:expr.items)
item.coeff*=-1;
add(expr);
;break;
}
return this;
}
}
