diff --git a/alg.h b/alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..31ec4e537ce2e72aeae7f88bd3531754af621631
--- /dev/null
+++ b/alg.h
@@ -0,0 +1,25 @@
+#pragma once
+#include<iostream>
+#include<cstring>
+#include<vector>
+using namespace std;
+class Solution {
+public:
+	vector<string> generateParenthesis(int n) {
+		if (n == 0) return {};
+		if (n == 1) return { "()" };
+		vector<vector<string>> dp(n + 1);
+		dp[0] = { "" };
+		dp[1] = { "()" };
+		for (int i = 2; i <= n; i++) {
+			for (int j = 0; j < i; j++) {
+				for (string p : dp[j])
+					for (string q : dp[i - j - 1]) {
+						string str = "(" + p + ")" + q;
+						dp[i].push_back(str);
+					}
+			}
+		}
+		return dp[n];
+	}
+};
\ No newline at end of file
diff --git a/alg.md b/alg.md
index 182f5f0cec5280388431ec0d87f25fbc237eb692..37733fd3fb047da3b745779c9a5ae3f02097623c 100644
--- a/alg.md
+++ b/alg.md
@@ -1,78 +1,135 @@
-# 三角形最小路径
+## 括号生成
 
-## 生成数据的思路
+### 题目描述：
 
-	rand()产生随机种子，以此产生随机数。将num[][]初始化为0，再将数组各元素替换成生成的随机数。
+数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
 
-```python
-int num[5][5] = { 0 };
-	while (num[4][4] == 0)
-	{
-		srand((int)time(0));
-		for (int i = 0; i < 5; i++)
-			for (int j = 0; j <5; j++)
+ 示例 1：
 
-			{
-				int a = (rand() % 100) + 1;
-				num[i][j] = a;
-			}
-	}
-	cout << "生成随机三角形：" << endl;
-	for (int i = 0; i < 5; i++)
-	{
-		for (int j = 0; j < 5; j++)
-			if (i >= j)
-				cout << num[i][j] << ' ';
-		cout << endl;
-	}
-```
+输入：n = 3
+输出：["((()))","(()())","(())()","()(())","()()()"]
+
+示例 2：
 
+输入：n = 1
+输出：["()"]
 
+### 解题思路：
 
-## 思路
+#### 要点：
 
-- 我们用 f[i][j] 表示从三角形顶部走到位置 (i,j) 的最小路径和。这里的位置 (i,j) 指的是三角形中第 i 行第 j 列（均从 0 开始编号）的位置。
+​        首先，什么是动态规划？在此题中，动态规划的思想类似于数学归纳法，当知道所有 i<n 的情况时，我们可以通过某种算法算出 i=n 的情况。
 
-  由于每一步只能移动到下一行「相邻的节点」上，因此要想走到位置 (i,j)，上一步就只能在位置 (i−1,j−1) 或者位置 (i−1,j)。我们在这两个位置中选择一个路径和较小的来进行转移，状态转移方程为：f[i][j]=min(f[i−1][j−1],f[i−1][j])+c[i][j]
+​       本题最核心的思想是，考虑 i=n 时相比 n-1 组括号增加的那一组括号的位置。
 
-  其中 c[i][j] 表示位置 (i,j) 对应的元素值。
+#### 具体实现：
 
-  注意第 i 行有 i+1 个元素，它们对应的 j 的范围为 j=i 时，上述状态转移方程中有一些项是没有意义的。例如当 j=0 时，f[i−1][j−1] 没有意义，因此状态转移方程为：f[i][0]=f[i−1][0]+c[i][0]
+​       简单来说，在求N个括号的排列组合时，把第N种情况（也就是N个括号排列组合）视为单独拿一个括号E出来，剩下的N-1个括号分为两部分，P个括号和Q个括号，P+Q=N-1，然后这两部分分别处于括号E内和括号E的右边，各自进行括号的排列组合。
 
-  即当我们在第 i 行的最左侧时，我们只能从第 i−1 行的最左侧移动过来。当 j=i 时，f[i−1][j] 没有意义，因此状态转移方程为：f[i][i]=f[i−1][i−1]+c[i][i]
+​       由于我们是一步步计算得到N个括号的情况的，所以小于等于N-1个括号的排列组合方式我们是已知的（用合适的数据结构存储，方便后续调用，且在存储时可利用特定数据结构实现题目某些要求，如排序，去重等），且P+Q=N-1，P和Q是小于等于N-1的，所以我们能直接得到P个和Q个括号的情况，进而得到N个括号的结果！
 
-  即当我们在第 i 行的最右侧时，我们只能从第 i−1 行的最右侧移动过来。
+​        这个算法主要的基点就是将排列组合的情况分为了括号内和括号外这两种情况，且仅存在两种情况！至于为什么，原因在于算法的前提是单独拿出来的括号E的左边在N个括号所有排列组合情况中都是处于最左边，所以不存在括号位于括号E的左边的情况。
 
-  最终的答案即为 f[n−1][n−1] 中的最小值，其中 n 是三角形的行数。
+​        因此，N-1个括号（拿出了括号E）仅可能分布于括号E内和括号E外，分为两种子情况讨论！ 这种思想还可以应用于其他类似的题的求解中，即怎样合理高效的利用前面步骤的计算结果得出当前步骤结果，从而得出最终结果。
 
+### 代码：
 
-```python
-def minimumTotal(self, triangle: List[List[int]]) -> int:
-        n = len(triangle)
-        f = [[0] * n for _ in range(n)]
-        f[0][0] = triangle[0][0]
+#### gen.   //生成随机数
 
-        for i in range(1, n):
-            f[i][0] = f[i - 1][0] + triangle[i][0]
-            for j in range(1, i):
-                f[i][j] = min(f[i - 1][j - 1], f[i - 1][j]) + triangle[i][j]
-            f[i][i] = f[i - 1][i - 1] + triangle[i][i]
-        
-        return min(f[n - 1])
+```c++
+#pragma once
+#include<iostream>
+#include <cstdlib>
+#include <ctime>
+using namespace std;
+class Ratime {
+   
+public:
+    int rat() {
+        srand(time(nullptr)); // 用当前时间作为种子
+        int min = 1, max = 3;
+        int randomValue;
+       // randomValue= (rand() % (max - min)) + min;//范围[min,max)
+        randomValue = (rand() % (max - min + 1)) + min;//范围[min,max]
+        //randomValue = (rand() % (max - min)) + min + 1;//范围(min,max]
+        return randomValue;
+       }
+    
+};
+```
 
+#### alg. //生成括号
+
+```c++
+#pragma once
+#include<iostream>
+#include<cstring>
+#include<vector>
+using namespace std;
+class Solution {
+public:
+	vector<string> generateParenthesis(int n) {
+		if (n == 0) return {};
+		if (n == 1) return { "()" };
+		vector<vector<string>> dp(n + 1);
+		dp[0] = { "" };
+		dp[1] = { "()" };
+		for (int i = 2; i <= n; i++) {
+			for (int j = 0; j < i; j++) {
+				for (string p : dp[j])
+					for (string q : dp[i - j - 1]) {
+						string str = "(" + p + ")" + q;
+						dp[i].push_back(str);
+					}
+			}
+		}
+		return dp[n];
+	}
+};
+```
 
+#### test.//数据测试
+
+```c++
+#include"main.h"//生成括号
+#include"range.h"//生成随机数
+int main()
+{
+	//引用定义
+	Solution example;
+	vector<string> ans;
+	Ratime sum;
+
+	//生成随机数
+	int ram=sum.rat();
+	cout << ram << endl;
+	
+
+	ans=example.generateParenthesis(ram);
+	
+	//对生成的括号进行输出
+	cout << "[";
+	for (int i = 0;i < ans.size();i++)
+	{
+		if (i != 0)
+			cout << ",";
+		cout << ans[i];
+	}
+	cout << "]";
+	return 0;
+}
 ```
 
-**复杂度分析**
 
-时间复杂度：O(n^2)
-其中 n 是三角形的行数。
 
-空间复杂度：O（n^2)
-我们需要一个 n∗n 的二维数组存放所有的状态。
+### 复杂度分析：
+
+​        我们的复杂度分析依赖于理解generateParenthesis(n)中有多少个元素。这个分析超出了文本的范畴，但事实证明这是第n个卡特兰属1/n+1(2n  n)，这是由4^n/(n*n^(1/2))渐近界定的。
 
+#### 时间复杂度：
 
+​        O(4^n/n^(1/2))，在回溯过程中，每个答案需要O(n)的时间复制到答案数组中。
 
-## 测试结果
+#### 空间复杂度：
 
-![屏幕截图 2023-04-25 211755](C:\Users\崔\Pictures\Screenshots\屏幕截图 2023-04-25 211755.png)
\ No newline at end of file
+​        O(n)，除了答案数组之外，我们所需要的空间取决于递归栈的深度，每一层递归函数都需要O(1)的空间，最多递归2n层，因此空间复杂度为O(n)。
\ No newline at end of file
diff --git a/alg.py b/alg.py
deleted file mode 100644
index e3b6f8f17d1922662bf61df23c5c4f014b3c3a37..0000000000000000000000000000000000000000
--- a/alg.py
+++ /dev/null
@@ -1,13 +0,0 @@
-class Solution:
-    def minimumTotal(self, triangle: List[List[int]]) -> int:
-        n = len(triangle)
-        f = [[0] * n for _ in range(n)]
-        f[0][0] = triangle[0][0]
-
-        for i in range(1, n):
-            f[i][0] = f[i - 1][0] + triangle[i][0]
-            for j in range(1, i):
-                f[i][j] = min(f[i - 1][j - 1], f[i - 1][j]) + triangle[i][j]
-            f[i][i] = f[i - 1][i - 1] + triangle[i][i]
-        
-        return min(f[n - 1])
\ No newline at end of file
diff --git a/gen.h b/gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..97b618c996d638759a83f45952be3882be0882b5
--- /dev/null
+++ b/gen.h
@@ -0,0 +1,19 @@
+#pragma once
+#include<iostream>
+#include <cstdlib>
+#include <ctime>
+using namespace std;
+class Ratime {
+   
+public:
+    int rat() {
+        srand(time(nullptr)); // �õ�ǰʱ����Ϊ����
+        int min = 1, max = 3;
+        int randomValue;
+       // randomValue= (rand() % (max - min)) + min;//��Χ[min,max)
+        randomValue = (rand() % (max - min + 1)) + min;//��Χ[min,max]
+        //randomValue = (rand() % (max - min)) + min + 1;//��Χ(min,max]
+        return randomValue;
+       }
+    
+};
\ No newline at end of file
diff --git a/gen.py b/gen.py
deleted file mode 100644
index c4bca9f99ff1eeabba57c1165a6254f2c0cff992..0000000000000000000000000000000000000000
--- a/gen.py
+++ /dev/null
@@ -1,20 +0,0 @@
-int num[5][5] = { 0 };
-	while (num[4][4] == 0)
-	{
-		srand((int)time(0));
-		for (int i = 0; i < 5; i++)
-			for (int j = 0; j <5; j++)
-
-			{
-				int a = (rand() % 100) + 1;
-				num[i][j] = a;
-			}
-	}
-	cout << "生成随机数组：" << endl;
-	for (int i = 0; i < 5; i++)
-	{
-		for (int j = 0; j < 5; j++)
-			if (i >= j)
-				cout << num[i][j] << ' ';
-		cout << endl;
-	}
\ No newline at end of file
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52f3fcf6e0eb6a0d942cbfbe7eb0cfbef58983a5
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,27 @@
+#include"main.h"//��������
+#include"range.h"//���������
+int main()
+{
+	//���ö���
+	Solution example;
+	vector<string> ans;
+	Ratime sum;
+
+	//���������
+	int ram=sum.rat();
+	cout << ram << endl;
+	
+
+	ans=example.generateParenthesis(ram);
+	
+	//�����ɵ����Ž������
+	cout << "[";
+	for (int i = 0;i < ans.size();i++)
+	{
+		if (i != 0)
+			cout << ",";
+		cout << ans[i];
+	}
+	cout << "]";
+	return 0;
+}
\ No newline at end of file
diff --git a/test.py b/test.py
deleted file mode 100644
index 70a76db77fb7fe924cbbf94ea9b974e008e72a0b..0000000000000000000000000000000000000000
--- a/test.py
+++ /dev/null
@@ -1,6 +0,0 @@
-输入
-[[2],[3,4],[6,5,7],[4,1,8,3]]
-输出
-11
-预期结果
-11
\ No newline at end of file