CCF java提交 ccf试题java

CCF_201912-3（java）

• 题目
• 分析
• 代码
• 结果

题目

分析

第三题在考试时建议最后来做，不是有多难，而是这一题一般都比较繁琐，代码量又大，耗时不说，一不小心就会出错。这一题一般都是对字符串进行处理，这次也不例外，不过这次的题目用正则表达式不太好匹配，通过读题我们知道就是对元素进行计数，所以我们也可以用hashmap来做。
对于一个化学方程式，我们可以先根据等号划分成左右两部分，然后再根据加号“+”进一步拆分。对于等号左右两边，我们可以相反计数，即对左边的元素进行正向计数（就是做加法），对右边的做减法，这样如果方程式是配平的话，最后所有元素的计数均为零，否则就是没有配平了。
根据加号拆分了以后，我们就需要根据他的组成结构来进行元素的寻找和计数了。首先由题目知他们由系数加化学式构成，那我们就可以先判断是否有系数，有更新系数，没有就是“1”。对于化学式，由“项”和“系数”构成，“项”中又可能有括号，所以我们要判断的符号就三个，前括号、后括号以及元素，括号有嵌套，其关系类似于父子关系，所以我们可以用树来表示嵌套关系，前括号表示有子节点产生，后括号表示子节点处理结束，回退到父节点。此外对于一个元素他可能既有前系数，又有后系数，对于后系数我们可以直接计算，但是对于前系数，我们并不知道它作用的元素有多少，所以我们还需要新建一个栈来存储前系数。
对于元素，我们需要判断其后面还有没有值，以及该值是什么，是一个大写字母，或者是小写字母，还是个数字。如果后面没值或者后面是大写字母的情况，就可以将该元素进行存储了，个数为1。如果是小写字母，我们就要判断其后是数字还是什么，需要知道其个数。如果是数字，我们只需要知道数字是什么，然后对元素和数字进行存储就行。
（废话一大堆，可能还是有点不清楚，直接上代码）

代码

import java.util.Scanner;
import java.util.HashMap;
import java.util.Stack;

public class Main {
	public static void main(String[] args) {
		Scanner sca=new Scanner(System.in);
     		String s=sca.nextLine();
     		int n=Integer.valueOf(s);
     		for(int i=0;i<n;i++) {
     			s=sca.nextLine();
      			String[] equation=s.split("=");
      			int val=1;//加减标记（左右标记）
      
      			HashMap<String,Integer> fin=new HashMap<>();//存储最终计数结果
      			for(int equa=0;equa<2;equa++) {
      				val=equa*-2+1;//左为1，由为-1
       				String[] expr=equation[equa].split("[+]");
       
                 		Stack<Integer> stack = new Stack<>();//存储系数
                 		for(int j=0;j<expr.length;j++) {
                 			Node node=new Node();//表明父子关系
        				char[] formula=expr[j].toCharArray();
        				int coef=1;//首位置的系数
        				String coefs=new String();
        				if(Character.isDigit(formula[0])){
        					coefs=digit(formula,0);
            					coef=Integer.valueOf(coefs);
            				}
            				for(int k=coefs.length();k<formula.length;k++) {
            					if(formula[k]=='(') {
            					 Node child = new Node();
                             			node.child = child;
                             			child.parent = node;
                             			node = child;
                             			if(Character.isDigit(formula[k+1])) {
                             			 	String stacks=digit(formula,k+1);
                              				stack.add(Integer.valueOf(stacks));
                              				k+=stacks.length();
                              			}
                              			else
                              				stack.add(1);
                              			}
                              			else if(formula[k]==')') {
                              				int dig=1;
          						if(k+1<formula.length&&Character.isDigit(formula[k+1])) {
          							String digs=digit(formula,k+1);
           							dig=Integer.valueOf(digs);
           							k+=digs.length();
          						}
          						node = node.parent;
                            				moveMap(node.map, node.child.map, stack.pop()*dig);
         					}
         					else {
          						int dig=1;
          						if(k+1<formula.length) {
           							if(Character.isDigit(formula[k+1])) {
            								String digs=digit(formula,k+1);
               								dig=Integer.valueOf(digs);
               							if(node.map.get(String.valueOf(formula[k]))!=null)
                							dig+=node.map.get(String.valueOf(formula[k]));
               							node.map.put(String.valueOf(formula[k]), dig);
               							k+=digs.length();
           						}
           						else if(Character.isLowerCase(formula[k+1])) {
            							String str=formula[k]+""+formula[k+1];
           	 						k++;
            							if(k+1<formula.length&&Character.isDigit(formula[k+1])) {
             								String digs=digit(formula,k+1);
                   							dig=Integer.valueOf(digs);
                   							k+=digs.length();
           		 					}
            							if(node.map.get(str)!=null)
                							dig+=node.map.get(str);
            							node.map.put(str, dig);
           						}
           						else 
           						{
            							if(node.map.get(String.valueOf(formula[k]))!=null)
                						dig+=node.map.get(String.valueOf(formula[k]));
               								node.map.put(String.valueOf(formula[k]), dig);
           							}
          						}
          						else {
           							if(node.map.get(String.valueOf(formula[k]))!=null)
            								dig+=node.map.get(String.valueOf(formula[k]));
           							node.map.put(String.valueOf(formula[k]), dig);
          						}
         					}
        				}
        				moveMap(fin, node.map, coef*val);
        			}
      			}
       			boolean judge = true;
             		for ( String str: fin.keySet() ) {
             		 	if ( fin.get(str) != 0 ) {
                  		judge = false;
                     		break;
                 	}
             	}
             	 if ( judge ) System.out.println("Y");
             	else System.out.println("N");
     	}
     	sca.close();
    }
    public static String digit(char[] formula,int i) {
    	String dig=formula[i]+"";
     	int length=formula.length;
     	while(i+1<length) {
     		if(Character.isDigit(formula[i+1])) {
       			dig+=formula[i+1];
       			i++;
      		}
      		else break;
      	}
     	return dig;
    }
     public static void moveMap(HashMap<String,Integer> fin,HashMap<String,Integer> map,int dig) {
     	for(String str:map.keySet()) {
     		if ( !fin.containsKey(str)) 
       			fin.put(str, map.get(str)*dig);
      		else
       			fin.put(str, fin.get(str)+map.get(str)*dig);
     	}
    }
}
class Node {
    HashMap<String, Integer> map = new HashMap<>();
    Node child = null, parent = null;
}

结果