Leetcode 726. 原子的数量 C++

Leetcode 726. 原子的数量

题目

给定一个化学式formula（作为字符串），返回每种原子的数量。

原子总是以一个大写字母开始，接着跟随0个或任意个小写字母，表示原子的名字。

如果数量大于 1，原子后会跟着数字表示原子的数量。如果数量等于 1 则不会跟数字。例如，H2O 和 H2O2 是可行的，但 H1O2 这个表达是不可行的。

两个化学式连在一起是新的化学式。例如 H2O2He3Mg4 也是化学式。

一个括号中的化学式和数字（可选择性添加）也是化学式。例如 (H2O2) 和 (H2O2)3 是化学式。

给定一个化学式，输出所有原子的数量。格式为：第一个（按字典序）原子的名子，跟着它的数量（如果数量大于 1），然后是第二个原子的名字（按字典序），跟着它的数量（如果数量大于 1），以此类推。

测试样例

示例 1:

输入: 
formula = "H2O"
输出: "H2O"
解释: 
原子的数量是 {'H': 2, 'O': 1}。

示例 2:

输入: 
formula = "Mg(OH)2"
输出: "H2MgO2"
解释: 
原子的数量是 {'H': 2, 'Mg': 1, 'O': 2}。

示例 3:

输入: 
formula = "K4(ON(SO3)2)2"
输出: "K4N2O14S4"
解释: 
原子的数量是 {'K': 4, 'N': 2, 'O': 14, 'S': 4}。

注意:

• 所有原子的第一个字母为大写，剩余字母都是小写。
• formula的长度在[1, 1000]之间。
• formula只包含字母、数字和圆括号，并且题目中给定的是合法的化学式。

题解

栈应用
用哈希表记录每个原子的数量。遇到括号时，我们要用栈去统计每个原子的数量。最后，在利用平衡二叉树set集合进行排序。详细过程见代码

代码

class Atom{
public:
    string atom;
    int time;
    Atom(string atom,int time){
        this->atom = atom;
        this->time = time;
    }
    bool operator < (const Atom a) const{
        return atom < a.atom;
    } 
};
class Solution {
public:
    bool isSmall(char c){		//所有原子的第一个字母是大写，其余字母为小写，因此我们需要将大写字母后的小写字母进行合并，作为一个整体。故需要判断是否为小写字母
        return c>='a'&&c<='z';
    }
    bool isNum(char c){			//判断是否为数字
        return c>='0'&&c<='9';
    }
    string countOfAtoms(string formula) {
        unordered_map<string,int> ans;		//记录每个原子的数目
        stack<string> sp;		//原子栈
        stack<int> num;			//对应的数量栈
        unordered_map<string,int> now;		//用于暂时存储原子数目，以方便嵌套括号时将原子在push栈中
        int i=0,len = formula.length();
        while(i < len){
            if(formula[i] == '('){		//遇到左括号
                sp.push("(");
                i++;
            }else if(formula[i] == ')'){		//遇到右括号，括号中间的这部分是一个整体
                i++;
                int j = i;
                while(j<len && isNum(formula[j]))   j++;		//找到数字代表的字符串
                int numNow;
                if(i == j)  numNow = 1;			//没有数字，则默认为1
                else{			//获取数字
                    numNow = stoi(formula.substr(i,j-i));
                    i = j;
                }    
                now.clear();		//需要清空暂存栈
                while(sp.top() != "("){		//括号中间的原子数量乘这个数
                    now[sp.top()] += num.top()*numNow;
                    sp.pop();
                    num.pop();
                }
                sp.pop();
                if(!sp.empty()){			//存在嵌套括号的情况，需要将暂存的原子及数量再push到栈中
                    unordered_map<string,int>::iterator iter = now.begin();
                    while(iter != now.end()){
                        sp.push((*iter).first);
                        num.push((*iter).second);
                        iter++;
                    }
                }else{		//栈为空，则没有嵌套括号的情况，只需要将暂存的原子数加到ans中
                    unordered_map<string,int>::iterator iter = now.begin();
                    while(iter != now.end()){
                        ans[(*iter).first] += (*iter).second;
                        iter++;
                    }
                }
            }else if(sp.empty()){		//没遇到括号的情况，则直接把原子数目加到ans中
                int j=i+1;
                while(j<len && isSmall(formula[j])) j++;		
                string nowY = formula.substr(i,j-i);		//获取原子
                i = j;
                j = i;
                while(j<len && isNum(formula[j]))   j++;		//获取数量
                if(i == j)  ans[nowY]++;		//没有数字，则默认为1
                else{
                    ans[nowY] += stoi(formula.substr(i,j-i));
                    i = j;
                }
            }else{			//栈中有原子，则说明出现括号，我们需要将获取的原子及数目push到栈中
                int j=i+1;
                while(j<len && isSmall(formula[j])) j++;
                string nowY = formula.substr(i,j-i);		//获取原子
                sp.push(nowY);
                i = j;
                j = i;
                while(j<len && isNum(formula[j]))   j++;		//获取数字
                if(i == j)  num.push(1);		//没有数字，默认为1
                else{		
                    num.push(stoi(formula.substr(i,j-i)));
                    i = j;
                }
            }
        }
        set<Atom> sortAtom;		//根据题意，要按照原子的字典序进行输出，故利用set集合进行排序
        unordered_map<string,int>::iterator iterMap = ans.begin();
        while(iterMap != ans.end()){
            sortAtom.insert(Atom((*iterMap).first,(*iterMap).second));
            iterMap++;
        }
        string ansStr;
        set<Atom>::iterator iter = sortAtom.begin();
        while(iter != sortAtom.end()){
            if((*iter).time == 1)
                ansStr +=  (*iter).atom;
            else 
                ansStr += (*iter).atom + to_string((*iter).time);
            iter++;
        }
        return ansStr;
    }
};

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-atoms
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。