化学方程式-ccf

题目：

分析：类似于计算运算表达式。

　　1、辅助数据结构：

　　　　（1）数组：使用52位整型数组表示52个字母。检索左部分所有表达式时，记录字母出现的次数；检索右部分所有表达式时，减去字母出现的次数。当左右表达式匹配时，数组的所有元素应该为0.

　　　　（2）字符栈：存取字符。

　　2、化学表达式预处理：

　　　　（1）通过"="，将方程式分割为左右两部分。

　　　　（2）通过"+"，将左右子串分别分割为更小的子表达式。

　　3、子表达式处理：

　　　　（1）设置前导值：左部分表达式，如果首位为数字，则前导值为首位的数字，否则默认为1；右部分同理，但是需要将值取反。

　　　　（2）表达式遍历：顺序遍历过程中穿插有递归操作。当遇到前括号时，首先判断紧跟后括号的值是否为数组（此处对后括号的判断导致无法处理平行括号，如果存在平行括号，表达式计算将出现错误），然后更新前导值，将括号内的字符串进行递归操作。

 　　4、问题中的规律：

　　　　（1）前导值作用于每个字母。

　　　　（2）其他数字：如果是紧跟随后括号，将作用于括号中的所有值，效果等效于前导值；如果是跟随在大写字母后，只作用与前面一个字母；如果是跟随在小写字母后，作用范围为当前位置到前序位置的第一个大写字母。

code：结果只有60分，还需要继续改进。我的代码只处理了嵌套括号，没有处理平行括号。

package yrc1;
import java.util.*;

/**
 * 只获得60分，还需要完善
 * 算法思想：
 * 
 * 2、使用52位长度的整型数组作为辅助。检索左字符串时，记录字母在字符串中出现的次数；
 * 检索右字符串时，减去字母在字符串中出现的次数。
 *
 *      (1)通过"+"将字符串分割为多个表达式
 */
public class Main4 {
    public static  void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();

        while(n>0){
            String str = in.nextLine();
            String[] one = str.split("=");
            String left  = one[0];
            String right = one[1];
            int[] dp = new int[52];
            String[] leftson;

            if(left.contains("+")){
                leftson = left.split("\+");
            }else{
                leftson = new String[1];
                leftson[0] = left;
            }
            for(int i=0;i<leftson.length;i++){
                int bs = 1;

                if(Character.isDigit(leftson[i].charAt(0))){
                    bs = leftson[i].charAt(0)-'0';
                    int j=1;
                    for(;j<leftson[i].length() && Character.isDigit(leftson[i].charAt(j));j++){
                        bs = bs*10+leftson[i].charAt(j)-'0';
                    }
                    leftson[i] = leftson[i].substring(j);
                }
                fun1(dp,bs,leftson[i]);
            }

            String[] rightson;
            if(right.contains("+")){
                rightson = right.split("\+");
            }else{
                rightson = new String[1];
                rightson[0] = right;
            }
            for(int i=0;i<rightson.length;i++){
                int bs = 1;
                if(Character.isDigit(rightson[i].charAt(0))){
                    bs = rightson[i].charAt(0)-'0';
                    int j=1;
                    for(;j<rightson[i].length() && Character.isDigit(rightson[i].charAt(j));j++){
                        bs = bs*10+rightson[i].charAt(j)-'0';
                    }
                    rightson[i] = rightson[i].substring(j);
                }
                fun1(dp,-bs,rightson[i]);
            }


            //a-z:97-122,A-Z:65-90,0-9:48-57
            boolean flag = true;
            for(int i=0;i<dp.length;i++){
                if(dp[i]!=0){
                    flag = false;
                    break;
                }
            }

            if(flag){
                System.out.println("Y");
            }else{
                System.out.println("N");
            }
            n--;
        }
    }
    //只处理了嵌套括号，没有处理平行括号
    public static void fun1(int[] dp,int bs,String str){
        Stack<Character> charStack = new Stack<>();
        for(int i=0;i<str.length();i++){
            char c = str.charAt(i);
            if(Character.isDigit(c)){      //处理非个位数
                int res = c-'0';
                int j=i+1;
                for(;j<str.length() && Character.isDigit(str.charAt(j));j++){
                    res = res*10+(str.charAt(j)-'0');
                }
                i = j-1;
                while (!charStack.empty() && charStack.peek()>=97){
                    dp[charStack.peek()-71] = dp[charStack.pop()-71]+res*bs;

                }
                if(!charStack.empty() && charStack.peek()<=90){
                    dp[charStack.peek()-65] = dp[charStack.pop()-65]+res*bs;
                }
            }else if(c=='('){
                int index = str.lastIndexOf(")");
                int newbs=bs;
                int curdigit=0;
                int j = index+1;
                for(;j<str.length() && Character.isDigit(str.charAt(j));j++){
                    curdigit = curdigit*10+(str.charAt(j)-'0');
                }
                newbs = curdigit==0?bs:curdigit*bs;
                fun1(dp,newbs,str.substring(i+1,index));
                i = j-1;
            }
            else{
                charStack.push(c);
            }
        }
        while(!charStack.empty()){
            char c = charStack.pop();
            int index = 0;
            if(c>=97){
                index = c-71;
            }else{
                index = c-65;
            }
            dp[index] = dp[index]+bs;
        }
    }
}