如果你熟悉 Shell 编程,那么一定了解过花括号展开,它可以用来生成任意字符串。
花括号展开的表达式可以看作一个由 花括号、逗号 和 小写英文字母 组成的字符串,定义下面几条语法规则:
- 如果只给出单一的元素
x
,那么表达式表示的字符串就只有"x"
。R(x) = {x}
- 例如,表达式
"a"
表示字符串"a"
。 - 而表达式
"w"
就表示字符串"w"
。
- 例如,表达式
- 当两个或多个表达式并列,以逗号分隔,我们取这些表达式中元素的并集。
R({e_1,e_2,...}) = R(e_1) ∪ R(e_2) ∪ ...
- 例如,表达式
"{a,b,c}"
表示字符串"a","b","c"
。 - 而表达式
"{{a,b},{b,c}}"
也可以表示字符串"a","b","c"
。
- 例如,表达式
- 要是两个或多个表达式相接,中间没有隔开时,我们从这些表达式中各取一个元素依次连接形成字符串。
R(e_1 + e_2) = {a + b for (a, b) in R(e_1) × R(e_2)}
- 例如,表达式
"{a,b}{c,d}"
表示字符串"ac","ad","bc","bd"
。
- 例如,表达式
- 表达式之间允许嵌套,单一元素与表达式的连接也是允许的。
- 例如,表达式
"a{b,c,d}"
表示字符串"ab","ac","ad"
。 - 例如,表达式
"a{b,c}{d,e}f{g,h}"
可以表示字符串"abdfg", "abdfh", "abefg", "abefh", "acdfg", "acdfh", "acefg", "acefh"
。
- 例如,表达式
给出表示基于给定语法规则的表达式 expression
,返回它所表示的所有字符串组成的有序列表。
假如你希望以「集合」的概念了解此题,也可以通过点击 “显示英文描述” 获取详情。
示例 1:
输入:expression = "{a,b}{c,{d,e}}" 输出:["ac","ad","ae","bc","bd","be"]
示例 2:
输入:expression = "{{a,z},a{b,c},{ab,z}}" 输出:["a","ab","ac","z"] 解释:输出中 不应 出现重复的组合结果。
提示:
1 <= expression.length <= 60
expression[i]
由'{'
,'}'
,','
或小写英文字母组成- 给出的表达式
expression
用以表示一组基于题目描述中语法构造的字符串
方法一:递归
我们设计一个递归函数
对于表达式
否则,我们从位置
最后,我们将集合
时间复杂度约为
class Solution:
def braceExpansionII(self, expression: str) -> List[str]:
def dfs(exp):
j = exp.find('}')
if j == -1:
s.add(exp)
return
i = exp.rfind('{', 0, j - 1)
a, c = exp[:i], exp[j + 1:]
for b in exp[i + 1: j].split(','):
dfs(a + b + c)
s = set()
dfs(expression)
return sorted(s)
class Solution {
private TreeSet<String> s = new TreeSet<>();
public List<String> braceExpansionII(String expression) {
dfs(expression);
return new ArrayList<>(s);
}
private void dfs(String exp) {
int j = exp.indexOf('}');
if (j == -1) {
s.add(exp);
return;
}
int i = exp.lastIndexOf('{', j);
String a = exp.substring(0, i);
String c = exp.substring(j + 1);
for (String b : exp.substring(i + 1, j).split(",")) {
dfs(a + b + c);
}
}
}
class Solution {
public:
vector<string> braceExpansionII(string expression) {
dfs(expression);
return vector<string>(s.begin(), s.end());
}
private:
set<string> s;
void dfs(string exp) {
int j = exp.find_first_of('}');
if (j == string::npos) {
s.insert(exp);
return;
}
int i = exp.rfind('{', j);
string a = exp.substr(0, i);
string c = exp.substr(j + 1);
stringstream ss(exp.substr(i + 1, j - i - 1));
string b;
while (getline(ss, b, ',')) {
dfs(a + b + c);
}
}
};
func braceExpansionII(expression string) []string {
s := map[string]struct{}{}
var dfs func(string)
dfs = func(exp string) {
j := strings.Index(exp, "}")
if j == -1 {
s[exp] = struct{}{}
return
}
i := strings.LastIndex(exp[:j], "{")
a, c := exp[:i], exp[j+1:]
for _, b := range strings.Split(exp[i+1:j], ",") {
dfs(a + b + c)
}
}
dfs(expression)
ans := make([]string, 0, len(s))
for k := range s {
ans = append(ans, k)
}
sort.Strings(ans)
return ans
}
function braceExpansionII(expression: string): string[] {
const dfs = (exp: string) => {
const j = exp.indexOf('}');
if (j === -1) {
s.add(exp);
return;
}
const i = exp.lastIndexOf('{', j);
const a = exp.substring(0, i);
const c = exp.substring(j + 1);
for (const b of exp.substring(i + 1, j).split(',')) {
dfs(a + b + c);
}
};
const s: Set<string> = new Set();
dfs(expression);
return Array.from(s).sort();
}