From dc9c36edd1f25adb3100f841a60fe644a7138e9b Mon Sep 17 00:00:00 2001 From: SuperHotDogCat Date: Tue, 23 Apr 2024 20:44:13 +0900 Subject: [PATCH 1/4] phase1 --- generate_parentheses/phase1.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 generate_parentheses/phase1.py diff --git a/generate_parentheses/phase1.py b/generate_parentheses/phase1.py new file mode 100644 index 0000000..41dc159 --- /dev/null +++ b/generate_parentheses/phase1.py @@ -0,0 +1,31 @@ +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + valid_parentheses = [] + under_processing_parentheses = ["("] + while under_processing_parentheses: + current_parenthesis = under_processing_parentheses.pop() + open_bracket_count = current_parenthesis.count("(") + closed_bracket_count = current_parenthesis.count(")") + + add_parentheses = [] + if closed_bracket_count == open_bracket_count: + # closed_bracket_count == open_bracket_countな状態でclosed_bracketを追加するとinvalidな状態になる + add_parentheses.append(current_parenthesis + "(") + elif open_bracket_count == n: + # open_bracketを使い切ったら文字列の長さが2*nになるまでclosed_bracketを追加 + add_parentheses.append(current_parenthesis + ")") + else: + # それ以外はどのbracketを使い切ってもvalidな状態になりえる途中経過状態になる + add_parentheses.append(current_parenthesis + "(") + add_parentheses.append(current_parenthesis + ")") + + for add_parenthesis in add_parentheses: + if len(add_parenthesis) == 2*n: + # terminate + valid_parentheses.append(add_parenthesis) + + else: + # 追加 + under_processing_parentheses.append(add_parenthesis) + + return valid_parentheses \ No newline at end of file From 2fab7e05c3062b5b23eab4c11725fbab1a98f1fc Mon Sep 17 00:00:00 2001 From: SuperHotDogCat Date: Wed, 24 Apr 2024 01:18:53 +0900 Subject: [PATCH 2/4] phase2 --- generate_parentheses/phase2.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 generate_parentheses/phase2.py diff --git a/generate_parentheses/phase2.py b/generate_parentheses/phase2.py new file mode 100644 index 0000000..1c65778 --- /dev/null +++ b/generate_parentheses/phase2.py @@ -0,0 +1,30 @@ +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + valid_parentheses = [] + under_processing_parentheses = [("", n, n)] #initial state + + while under_processing_parentheses: + current_parentheses, remain_open_bracket_count, remain_close_bracket_count = under_processing_parentheses.pop() + if remain_open_bracket_count == 0 and remain_close_bracket_count == 0: + valid_parentheses.append(current_parentheses) + continue + + if 0 < remain_open_bracket_count: + under_processing_parentheses.append((current_parentheses + "(", remain_open_bracket_count - 1, remain_close_bracket_count)) + if remain_open_bracket_count < remain_close_bracket_count: + under_processing_parentheses.append((current_parentheses + ")", remain_open_bracket_count, remain_close_bracket_count - 1)) + + return valid_parentheses + +""" +phase1と同じようにvalidな状態から終了状態までの遷移グラフを追うようなコードにした + +Reference: +https://github.com/ryoooooory/LeetCode/pull/6/files +refactoredSolution2.javaが近いのかなと感じた。 + +https://github.com/shining-ai/leetcode/pull/53/files +再帰で解く解き方も確かにできますね。level4のコードが綺麗ですし, 僕のphase1のコードで感じていた +add_parenthesisとadd_parenthesesを複数形と単数系で区別するのはなんだか認知負荷がかかるなあという思いがあったのでとても参考になりました。 + +""" \ No newline at end of file From a7e1e3feffa96ab2df5b4fdfd241199c764b4ba8 Mon Sep 17 00:00:00 2001 From: SuperHotDogCat Date: Wed, 24 Apr 2024 01:19:11 +0900 Subject: [PATCH 3/4] phase3 --- generate_parentheses/phase3.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 generate_parentheses/phase3.py diff --git a/generate_parentheses/phase3.py b/generate_parentheses/phase3.py new file mode 100644 index 0000000..73468e1 --- /dev/null +++ b/generate_parentheses/phase3.py @@ -0,0 +1,20 @@ +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + valid_parentheses = [] # 有効な答えを格納するコンテナ + under_processing_parentheses = [("", n, n)] # stack + while under_processing_parentheses: + current_parentheses, remain_open_bracket_count, remain_close_bracket_count = under_processing_parentheses.pop() + + if remain_open_bracket_count == 0 and remain_close_bracket_count == 0: + valid_parentheses.append(current_parentheses) + continue + + if 0 < remain_open_bracket_count: + # 使える(があるときはいつ加えてもvalidなparenthesesになる + under_processing_parentheses.append((current_parentheses + "(", remain_open_bracket_count - 1, remain_close_bracket_count)) + + if remain_open_bracket_count < remain_close_bracket_count: + #　remain_open_bracket_count < remain_close_bracket_count の時だけvalidなparenthesesが作れる + under_processing_parentheses.append((current_parentheses + ")",remain_open_bracket_count, remain_close_bracket_count - 1)) + + return valid_parentheses \ No newline at end of file From 5d816196c53fa5b50d94063569f2007662a3e841 Mon Sep 17 00:00:00 2001 From: SuperHotDogCat Date: Thu, 25 Apr 2024 01:38:37 +0900 Subject: [PATCH 4/4] =?UTF-8?q?=E7=8A=B6=E6=85=8B=E3=82=92=E6=A0=BC?= =?UTF-8?q?=E7=B4=8D=E3=81=99=E3=82=8B=E5=A4=89=E6=95=B0=E3=82=92=E5=B0=91?= =?UTF-8?q?=E3=81=AA=E3=81=8F=E3=81=99=E3=82=8B=E3=82=A2=E3=83=97=E3=83=AD?= =?UTF-8?q?=E3=83=BC=E3=83=81=E3=81=A8=E5=86=8D=E5=B8=B0=E3=83=90=E3=83=BC?= =?UTF-8?q?=E3=82=B8=E3=83=A7=E3=83=B3=E3=81=AE=E8=BF=BD=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- generate_parentheses/phase4.py | 38 ++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 generate_parentheses/phase4.py diff --git a/generate_parentheses/phase4.py b/generate_parentheses/phase4.py new file mode 100644 index 0000000..1726344 --- /dev/null +++ b/generate_parentheses/phase4.py @@ -0,0 +1,38 @@ +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + # 状態を格納する変数を少なくするアプローチ + valid_parentheses = [] # 有効な答えを格納するコンテナ + under_processing_parentheses = [""] # stack + while under_processing_parentheses: + current_parentheses = under_processing_parentheses.pop() + + if current_parentheses.count("(") == n and current_parentheses.count(")") == n: + valid_parentheses.append(current_parentheses) + continue + + if current_parentheses.count("(") < n: + # 使える(があるときはいつ加えてもvalidなparenthesesになる + under_processing_parentheses.append(current_parentheses + "(") + + if current_parentheses.count(")") < current_parentheses.count("("): + under_processing_parentheses.append(current_parentheses + ")") + + return valid_parentheses + +# 再帰で書く場合 + +class Solution: + def generateParenthesis(self, n: int) -> List[str]: + def _generate_valid_parentheses(current_parenthesis: str, n: int)->List[str]: + if current_parenthesis.count("(") == n and current_parenthesis.count(")") == n: + return [current_parenthesis] + + valid_parentheses = [] + if current_parenthesis.count("(") < n: + valid_parentheses += _generate_valid_parentheses(current_parenthesis + "(", n) + if current_parenthesis.count(")") < current_parenthesis.count("("): + valid_parentheses += _generate_valid_parentheses(current_parenthesis + ")", n) + + return valid_parentheses + + return _generate_valid_parentheses("", n) \ No newline at end of file