Leetcode 17 电话号码的字母组合 &22 括号生成

思路：用队列，相当于树的层次遍历

17.电话号码的字母组合

{a，b，c}

a出队列,ad,ae,af如、入队列{b，c，ad，ae，af}

以此类推

循环退出条件：电话数字遍历完毕

答案：当前在队列中的所有字符串

class Solution {
private:
	string map[10] = { "","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz" };
public:
	vector<string> letterCombinations(string digits) {
		vector<string> ans;
        if(digits.size()==0) return ans;
        
		vector<int> num;//剥离出每一个电话数字
		for (int i = 0; i < digits.size(); i++)
			num.push_back(digits[i]-'0');//千万注意char型到int型的转换

		queue<string> q;
		int k = 1;//记录匹配到了第几个数字
		for (int i = 0; i < map[num[0]].size(); i++)
		{
			string tmp;
			tmp.push_back(map[num[0]][i]);//注意string的元素map[i][j]是char型，要转换
			q.push(tmp);
		}
		int size = q.size();
		while (!q.empty() && k <num.size())
		{
			for (int i = 0; i < map[num[k]].size(); i++)
			{
				string s = q.front();//s一定要在里面定义，等于每一轮循环都初始化，否则影响后续
				s += map[num[k]][i];
				q.push(s);
			}
			q.pop();
			size--;
			if (size == 0)
			{
				size = q.size();
				k++;
			}
		}
		while (!q.empty())
		{
			ans.push_back(q.front());
			q.pop();
		}
		return ans;
	}

};

 

 

22 括号生成

class Solution {
private:
    struct Tnode{
        int value,lnum;
        string s;
        Tnode(int _value,int _lnum,string _s)
        {
            value=_value;//定义"("为1，")"为-1，value为括号字符串等价值
            lnum=_lnum;//左括号的个数
            s=_s;//括号字符串
        }
    };
public:
    vector<string> generateParenthesis(int n) {
        vector<string> ans;
        queue<Tnode> q;
        if(n==0) return ans;
        if(n==1) 
        {
            ans.push_back("()");
            return ans;
        }
        Tnode node(1,1,"(");
        q.push(node);
        int level=1;//二叉树的层次
        while(!q.empty()&&level<n*2)//level这里不取等号,因为在倒数第二层这里已经把所有根节点入队列了
        {
            int size=q.size();//计录该层节点个数
            Tnode node=q.front();
            q.pop();
            if(node.lnum<n)
            {//左括号
                Tnode tmp(node.value+1,node.lnum+1,node.s+"(");//左括号使得value+1
                q.push(tmp);
            }
            if(node.value>0) 
            {//右括号
                Tnode tmp(node.value-1,node.lnum,node.s+")");//右括号使得value-1
                q.push(tmp);
            }
            if(node.lnum==n&&node.value==0)//左括号达到n，且值value中和完毕
            {//一种情况组合完毕
                ans.push_back(node.s);
            }
            if((--size)==0){
                size=q.size();
                level++;
            }
        }
        return ans;
    }
};

 

看到一位大神用的递归，很简洁：

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<String>();
        generate(res, "", 0, 0, n);
        
        return res;
    }
        //count1统计“(”的个数，count2统计“)”的个数
    public void generate(List<String> res , String ans, int count1, int count2, int n){
        
        if(count1 > n || count2 > n) return;
        
        if(count1 == n && count2 == n)  res.add(ans);
 
        
        if(count1 >= count2){//保证了在整个递归过程中"("始终>=")"
            String ans1 = new String(ans);//记录原始ans
            generate(res, ans+"(", count1+1, count2, n);
            generate(res, ans1+")", count1, count2+1, n);//如果对于（）的情况再加）,下一次递归就会被pass
            
        }
    }

}