diff --git "a/1\350\264\252\345\277\203 \345\217\266\345\200\274\347\232\204\346\234\200\345\260\217\347\224\237\346\210\220\346\240\221.png" "b/1\350\264\252\345\277\203 \345\217\266\345\200\274\347\232\204\346\234\200\345\260\217\347\224\237\346\210\220\346\240\221.png"
deleted file mode 100644
index 4c7dcd6378df952474cb08dbf07abbe5546608b5..0000000000000000000000000000000000000000
Binary files "a/1\350\264\252\345\277\203 \345\217\266\345\200\274\347\232\204\346\234\200\345\260\217\347\224\237\346\210\220\346\240\221.png" and /dev/null differ
diff --git "a/2.\350\264\252\345\277\203\357\274\214\344\270\211\350\247\222\345\275\242\346\234\200\345\244\247\345\221\250\351\225\277.png" "b/2.\350\264\252\345\277\203\357\274\214\344\270\211\350\247\222\345\275\242\346\234\200\345\244\247\345\221\250\351\225\277.png"
deleted file mode 100644
index 04169b2a7f7593449ddc7ba88050fb494239bdb6..0000000000000000000000000000000000000000
Binary files "a/2.\350\264\252\345\277\203\357\274\214\344\270\211\350\247\222\345\275\242\346\234\200\345\244\247\345\221\250\351\225\277.png" and /dev/null differ
diff --git "a/3\345\233\236\346\272\257N\347\232\207\345\220\216.png" "b/3\345\233\236\346\272\257N\347\232\207\345\220\216.png"
deleted file mode 100644
index 70ba38e6f879d89e9865dce7566522eb72feec23..0000000000000000000000000000000000000000
Binary files "a/3\345\233\236\346\272\257N\347\232\207\345\220\216.png" and /dev/null differ
diff --git a/alg.md b/alg.md
deleted file mode 100644
index 97cec80b834d4fad19ee667d9f8bdf0c2dc87599..0000000000000000000000000000000000000000
--- a/alg.md
+++ /dev/null
@@ -1,300 +0,0 @@
-# 解题报告
-
-## 1.叶值的最小代价生成树（1130贪心）
-
-### 题目描述
-
-给你一个正整数数组 arr，考虑所有满足以下条件的二叉树：
-
-每个节点都有 0 个或是 2 个子节点。
-数组 arr 中的值与树的中序遍历中每个叶节点的值一一对应。
-每个非叶节点的值等于其左子树和右子树中叶节点的最大值的乘积。
-在所有这样的二叉树中，返回每个非叶节点的值的最小可能总和。这个和的值是一个 32 位整数。
-
-如果一个节点有 0 个子节点，那么该节点为叶节点。
-
-来源：力扣（LeetCode）1130
-
-### 思路分析
-
-该算法采用了贪心算法的思想，每次选择左右子节点中较小的那个值，保证了当前节点的值尽量小，从而使得所有非叶子节点的值的和最小。具体实现时，使用单调栈来维护当前节点的左子树，每次遍历到一个新的数时，将栈顶元素和当前数作为左右子节点，计算它们的乘积并加入结果中，然后将当前数压入栈中。如果当前数比栈顶元素小，则将栈顶元素和之后的节点组成新的左子树，直到栈顶元素比当前数大为止。最后，将栈中剩余的节点两两组成左右子节点，计算它们的乘积并加入结果中。
-
-其中mctFromLeafValues函数的作用是对于一个非空的整数数组arr，构建一颗二叉树，使得每个叶子节点的值为arr中的一个元素，并且每个非叶子节点的值为其左右子节点中较大值的乘积，求得所有可能的二叉树中，所有非叶子节点的值的和的最小值。
-函数采用单调栈的方法来处理，具体来说，维护一个单调递减的栈stack，将arr中的元素从左往右加入栈中。对于每个新元素num，如果栈顶元素stack[-1]比num小，就将栈顶元素取出，作为左右子节点中较小值，num作为较大值，计算它们的乘积，并加入到结果res中。这个过程相当于构建一颗二叉树中的一个子树，其中栈顶元素为左子节点，num为右子节点。因为我们要使得非叶子节点的值最小，所以应该让左右子节点的值尽量接近，这也是为什么要取较小值作为左子节点的原因。
-
-### 代码实现
-
-```python
-from random import randint
-def generate_data():
-    n = random.randint(2, 100)
-    arr = [random.randint(1, 100) for _ in range(n)]
-    return (arr, )
-from typing import List
-class Solution:
-    def mctFromLeafValues(self, arr: List[int]) -> int:
-        res = 0
-        stack = [float('inf')]
-        for num in arr:
-            while stack[-1] <= num:
-                mid = stack.pop()
-                res += mid * min(stack[-1], num)
-            stack.append(num)
-        while len(stack) > 2:
-            res += stack.pop() * stack[-1]
-        return res
-```
-
-## 数据测试
-
-为了测试算法的鲁棒性，我们需要生成一些随机的数据进行测试。生成数据的思路如下：
-
-1. 极端情况：输入为空数组，期望输出为0；输入只有一个元素，期望输出为0；
-
-2. 特殊情况：输入数组中所有元素都相等，期望输出为元素个数乘以该元素的值；输入数组按照升序或降序排列，期望输出为升序排列时的结果；
-
-3. 随机情况：随机生成不同长度的输入数组，每个元素随机取值，期望输出的结果可以通过暴力枚举得出，检查算法输出是否与暴力算法输出一致。
-
-4. 边界情况：输入数组的长度为2，期望输出为两个元素的乘积；输入数组的长度为3，期望输出为两个元素的乘积加上第三个元素的值；
-
-5. 各种组合情况：输入数组中既有奇数，又有偶数；输入数组中有正数和负数等。
-
-6. 我们可以通过构造一些特定的测试用例来测试该算法的正确性，例如：
-
-   输入[1,2,3,4,5]，期望输出 33，此时最优的构建方法是： 
-
-   ​    15
-   ​    / \
-      10  5
-      / \ 
-     6  4
-     / \ 
-    2  3
-
-   输入[3,2,5,4,1]，期望输出 45，此时最优的构建方法是： 
-
-   ​    27
-   ​    / \
-      15  12
-      / \ 
-     6  9
-     / \ 
-    3  2
-
-   输入[5,4,3,2,1]，期望输出 40，此时最优的构建方法是：
-
-   ​	 26
-   ​    / \
-      12  14
-      / \ 
-     4  8
-     / \ 
-    2  2
-
-   通过以上测试用例，我们可以验证该算法的正确性。
-
-   ## 测试示例
-
-   ​	下面是一个测试代码的例子：
-
-   ```python
-   def test():
-       solution = Solution()
-       for i in range(10):
-           arr, = generate_data()
-           res = solution.mctFromLeafValues(arr)
-           print("Test case ", i + 1, ":\narr = ", arr, "\nres = ", res, "\n")
-   if __name__ == "__main__":
-       test()
-   ```
-
-   
-
-   ![](C:\Users\XUZIY\Desktop\叶值代价生成树.png)
-
-### 复杂度分析
-
-- 该算法需要遍历整个输入数组，因此时间复杂度为O(n)。
-- 空间复杂度：每个数最多会被压入和弹出一次栈，因此空间复杂度也为O(n)。
-
-## 2.三角形的最大周长（976贪心）
-
-### 题目描述
-
-给定由一些正数（代表长度）组成的数组 nums ，返回 由其中三个长度组成的、面积不为零的三角形的最大周长 。如果不能形成任何面积不为零的三角形，返回 0。
-
-### 思路分析
-
-- 首先将数组 A 从大到小排序；
-- 然后从 A 的第一个元素开始往后遍历，对于 A 中的每一个元素，判断其和后面的两个元素是否可以构成三角形，若可以，则返回这三条边的周长；
-- 若遍历完整个数组都没有找到可以构成三角形的边，则返回 0。
-
-### 代码实现
-
-```python
-from random import randint
-def generate_data():
-    n = random.randint(3, 10000)
-    A = [random.randint(1, 10**6) for _ in range(n)]
-    return (A, )
-from typing import List
-class Solution:
-    class Solution:
-    def largestPerimeter(self, A: List[int]) -> int:
-        A.sort(reverse=True)
-        for i in range(len(A)-2):
-            if A[i]<A[i+1]+A[i+2]:
-                return A[i]+A[i+1]+A[i+2]
-        return 0
-```
-
-## 数据测试
-
-为了测试算法的鲁棒性，我们需要生成一些随机的数据进行测试。生成数据的思路如下：
-
-1. 先在 3 到 10000 之间随机生成一个长度 n，表示数组 A 的长度；
-2. 然后在 1 到 10^6 之间随机生成 n 个数，作为数组 A 的元素；
-3. 最后将 A 返回作为生成的测试数据。
-
-## 测试示例
-
-​	下面是一个测试代码的例子：
-
-```python
-def test():
-    solution = Solution()
-    for i in range(10):
-        A, = generate_data()
-        res = solution.largestPerimeter(A)
-        print("Test case ", i + 1, ":\nA = ", A, "\nres = ", res, "\n")
-if __name__ == "__main__":
-    test()
-```
-
-
-
-![](C:\Users\XUZIY\Desktop\三角形最大周长\4.贪心，三角形最大周长.png)
-
-### 复杂度分析
-
-- 算法函数的时间复杂度：
-
-  1. 对数组进行排序，时间复杂度为 O(nlogn)；
-
-  2. 然后需要遍历数组中的每个元素，时间复杂度为 O(n);
-
-  3. 在遍历过程中，需要对当前元素后面的两个元素进行判断，时间复杂度为 O(1)；
-
-     综上所述，算法函数的时间复杂度为 O(nlogn)。
-
-     - 数据生成函数的时间复杂度：
-
-  4. 生成一个随机数需要 O(1) 的时间复杂度；
-
-  5. 生成 n 个随机数的时间复杂度为 O(n)；
-
-## 3.N皇后（51回溯）
-### 题目描述
-
-按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
-
-n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
-
-给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
-
-每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
-
-来源：力扣（LeetCode）51
-
-### 思路分析
-1. 该回溯算法的解决思路是：对于每一行，遍历每一列，判断该位置是否可以放置皇后。如果可以放置，则将皇后放置在该位置，并递归到下一行；如果不行，则继续遍历下一列。如果当前行没有找到合适的位置，就返回上一行并回溯，将皇后从上一行的位置移除，并在上一行的下一列继续尝试。
-2. 为了快速判断某个位置是否可以放置皇后，该算法使用了三个集合 `cols`、`diag1`、`diag2`，分别表示已经占用的列、正斜线、反斜线。对于当前要尝试的位置 `(row, col)`，只需要判断 `col`、`row+col`、`row-col` 是否在上述集合中即可。如果都不在集合中，则该位置可以放置皇后。
-3. 在找到所有合法的摆放位置后，将结果保存在一个二维列表中，其中每一行表示一种摆放方式，用字符串表示，其中 Q 表示皇后，"." 表示空位置。
-
-### 代码实现
-
-```python
-import random
-import math
-from typing import List
-class Solution:
-    def solveNQueens(self, n: int) -> List[List[str]]:
-        # 初始化棋盘，全部填充为 .
-        board = [['.' for _ in range(n)] for _ in range(n)]
-        res = []
-        # 已占用的列、正斜线、反斜线
-        cols, diag1, diag2 = set(), set(), set()
-        def dfs(row):
-            # 如果已经遍历到最后一行，则将当前摆放情况加入结果集
-            if row == n:
-                res.append(["".join(row) for row in board])
-                return
-            # 遍历每一列
-            for col in range(n):
-                # 判断当前位置是否合法
-                if col not in cols and row + col not in diag1 and row - col not in diag2:
-                    # 如果当前位置合法，则将皇后放置在该位置，并更新已占用的列、正斜线、反斜线
-                    board[row][col] = 'Q'
-                    cols.add(col)
-                    diag1.add(row + col)
-                    diag2.add(row - col)
-                    # 递归到下一行
-                    dfs(row + 1)
-                    # 回溯，将皇后从该位置移除，并恢复已占用的列、正斜线、反斜线
-                    board[row][col] = '.'
-                    cols.remove(col)
-                    diag1.remove(row + col)
-                    diag2.remove(row - col)
-        dfs(0)
-        return res
-def generate_data():
-    n = random.randint(1, 10)
-    return n
-```
-
-## 数据测试
-
-数据生成函数 `generate_data()` 的思路很简单，只需要随机生成一个整数 `n`，表示棋盘的大小，即皇后的数量。该函数返回值即为 `n`。在测试时，会多次调用该函数，每次生成一个不同的 `n`。
-
-## 测试示例
-
-​	下面是一个测试代码的例子：
-
-```python
-def test_data(n):
-    s = Solution()
-    res = s.solveNQueens(n)
-    expected = math.factorial(n) if n <= 10 else None
-    if len(res) == expected:
-        print("test case passed: n = %d, num of solutions = %d" % (n, len(res)))
-    else:
-        print("test case failed: n = %d, num of solutions = %d, expected = %s" % (n, len(res), expected))
-if __name__ == "__main__":
-    for i in range(10):
-        n = generate_data()
-        print("testing case #%d: n = %d" % (i+1, n))
-        test_data(n)
-```
-
-![](C:\Users\XUZIY\Desktop\回溯N皇后.png)
-
-### 复杂度分析
-
-- 时间复杂度：***O(n^n)***,算法的时间复杂度主要取决于在回溯过程中遍历的次数。对于每一行，最多需要遍历 $n$ 列，因此总的遍历次数为***O(n^n)*** ，其中 n 表示棋盘的大小，即皇后的数量。
-- 空间复杂度：***O(n^n)***，需要常数个变量用于选取最大值，需要使用的空间取决于递归栈的深度。此外，对于每个合法的摆放位置，需要将结果保存在结果集中，因此空间复杂度也为***O(n^n)***。总的时间复杂度和空间复杂度都非常高，限制了算法的使用场景。
-
-## 心得体会
-
-在使用 Jupyter Notebook 写完这些道题目后，我对 Jupyter Notebook 的使用更加熟练了。Jupyter Notebook 是一个非常好用的交互式开发工具，可以轻松地将代码、文本、图片、公式等内容集成在一起，方便编写和展示。在编写算法代码时，我可以通过 Markdown 单元格编写算法思路分析和时间复杂度分析，使得代码更加易于理解。同时，我还可以在代码单元格中使用代码高亮、代码补全、代码调试等功能，提高了编写代码的效率。
-此外，我还使用 Jupyter Notebook 编写了数据生成函数和测试函数，并将它们封装成了一个完整的 Jupyter Notebook 工程文件块，方便测试和演示。这种方式比直接在终端中执行代码更加直观，可以看到每个测试用例的结果，方便进行调试和优化。
-总的来说，Jupyter Notebook 是一个非常好用的工具，特别适合编写和展示算法代码。它具有交互性强、可视化好、易于编写和展示等特点，可以提高编程效率和代码可读性。
-
-## 实验环境
-
-win10
-
-python3.11
-
-jupyter notebook
-
-git.
\ No newline at end of file
diff --git a/alg1.py b/alg1.py
deleted file mode 100644
index c2e979693982875d14ae28886451bf8a42ba7315..0000000000000000000000000000000000000000
--- a/alg1.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from typing import List
-class Solution:
-    def mctFromLeafValues(self, arr: List[int]) -> int:
-        res = 0
-        stack = [float('inf')]
-        for num in arr:
-            while stack[-1] <= num:
-                mid = stack.pop()
-                res += mid * min(stack[-1], num)
-            stack.append(num)
-        while len(stack) > 2:
-            res += stack.pop() * stack[-1]
-        return res
\ No newline at end of file
diff --git a/alg2.py b/alg2.py
deleted file mode 100644
index 5d90626948e5b8c37187c67b5907756ee65f0cd3..0000000000000000000000000000000000000000
--- a/alg2.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from typing import List
-class Solution:
-    def largestPerimeter(self, A: List[int]) -> int:
-        A.sort(reverse=True)
-        for i in range(len(A)-2):
-            if A[i]<A[i+1]+A[i+2]:
-                return A[i]+A[i+1]+A[i+2]
-        return 0
diff --git a/alg3.py b/alg3.py
deleted file mode 100644
index 64d083887b916e26824604249d18328edca4ce0e..0000000000000000000000000000000000000000
--- a/alg3.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import random
-import math
-from typing import List
-class Solution:
-    def solveNQueens(self, n: int) -> List[List[str]]:
-        # 初始化棋盘，全部填充为 .
-        board = [['.' for _ in range(n)] for _ in range(n)]
-        res = []
-        # 已占用的列、正斜线、反斜线
-        cols, diag1, diag2 = set(), set(), set()
-        def dfs(row):
-            # 如果已经遍历到最后一行，则将当前摆放情况加入结果集
-            if row == n:
-                res.append(["".join(row) for row in board])
-                return
-            # 遍历每一列
-            for col in range(n):
-                # 判断当前位置是否合法
-                if col not in cols and row + col not in diag1 and row - col not in diag2:
-                    # 如果当前位置合法，则将皇后放置在该位置，并更新已占用的列、正斜线、反斜线
-                    board[row][col] = 'Q'
-                    cols.add(col)
-                    diag1.add(row + col)
-                    diag2.add(row - col)
-                    # 递归到下一行
-                    dfs(row + 1)
-                    # 回溯，将皇后从该位置移除，并恢复已占用的列、正斜线、反斜线
-                    board[row][col] = '.'
-                    cols.remove(col)
-                    diag1.remove(row + col)
-                    diag2.remove(row - col)
-        dfs(0)
-        return res
\ No newline at end of file
diff --git a/fenzhi/1.png b/fenzhi/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..5f6530dbde50bf37e059b75a26ce6a729e5ccb09
Binary files /dev/null and b/fenzhi/1.png differ
diff --git a/fenzhi/2.png b/fenzhi/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c9d8a691d7e986745761a6c6f2634df444cf3651
Binary files /dev/null and b/fenzhi/2.png differ
diff --git a/fenzhi/alg.h b/fenzhi/alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6118a9c360495d0d50a29a66524fc7bbc696993
--- /dev/null
+++ b/fenzhi/alg.h
@@ -0,0 +1,34 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+#include"gen.h"
+using namespace std;
+
+class Solution {
+    int count_in_range(vector<int>& nums, int target, int lo, int hi) {
+        int count = 0;
+        for (int i = lo; i <= hi; ++i)
+            if (nums[i] == target)
+                ++count;
+        return count;
+    }
+    int majority_element_rec(vector<int>& nums, int lo, int hi) {
+        if (lo == hi)
+            return nums[lo];
+        int mid = (lo + hi) / 2;
+        int left_majority = majority_element_rec(nums, lo, mid);
+        int right_majority = majority_element_rec(nums, mid + 1, hi);
+        if (count_in_range(nums, left_majority, lo, hi) > (hi - lo + 1) / 2)
+            return left_majority;
+        if (count_in_range(nums, right_majority, lo, hi) > (hi - lo + 1) / 2)
+            return right_majority;
+        return -1;
+    }
+public:
+    int majorityElement(vector<int>& nums) {
+        return majority_element_rec(nums, 0, nums.size() - 1);
+    }
+};
+
+
diff --git a/fenzhi/alg.md b/fenzhi/alg.md
new file mode 100644
index 0000000000000000000000000000000000000000..0630e5cbf06ff82ac8fefdedd2c4344d159f1cbd
--- /dev/null
+++ b/fenzhi/alg.md
@@ -0,0 +1,91 @@
+## 多数元素
+
+#### 1 问题建模（描述）
+
+ 给定一个大小为 `n` 的数组 `nums` ，返回其中的多数元素。多数元素是指在数组中出现次数 **大于** `⌊ n/2 ⌋` 的元素。 
+
+示例：
+
+```
+输入：nums = [3,2,3]
+输出：3
+```
+
+```
+输入：nums = [2,2,1,1,1,2,2]
+输出：2
+```
+
+
+
+#### 2 数据生成（初始数据生成）
+
+```c++
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//生成范围在l~r的随机数 
+{
+	srand(time(0));  //设置时间种子
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//生成区间r~l的随机数 
+	}
+}
+```
+
+
+
+#### 3 算法设计（解决方法）
+
+如果数 a 是数组 nums 的众数，如果我们将 nums 分成两部分，那么 a 必定是至少一部分的众数。
+
+我们可以使用反证法来证明这个结论。假设 a 既不是左半部分的众数，也不是右半部分的众数，那么 a 出现的次数少于 l / 2 + r / 2 次，其中 l 和 r 分别是左半部分和右半部分的长度。由于 l / 2 + r / 2 <= (l + r) / 2，说明 a 也不是数组 nums 的众数，因此出现了矛盾。所以这个结论是正确的。
+
+这样以来，我们就可以使用分治法解决这个问题：将数组分成左右两部分，分别求出左半部分的众数 a1 以及右半部分的众数 a2，随后在 a1 和 a2 中选出正确的众数。
+
+```c++
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+#include"gen.h"
+using namespace std;
+
+class Solution {
+    int count_in_range(vector<int>& nums, int target, int lo, int hi) {
+        int count = 0;
+        for (int i = lo; i <= hi; ++i)
+            if (nums[i] == target)
+                ++count;
+        return count;
+    }
+    int majority_element_rec(vector<int>& nums, int lo, int hi) {
+        if (lo == hi)
+            return nums[lo];
+        int mid = (lo + hi) / 2;
+        int left_majority = majority_element_rec(nums, lo, mid);
+        int right_majority = majority_element_rec(nums, mid + 1, hi);
+        if (count_in_range(nums, left_majority, lo, hi) > (hi - lo + 1) / 2)
+            return left_majority;
+        if (count_in_range(nums, right_majority, lo, hi) > (hi - lo + 1) / 2)
+            return right_majority;
+        return -1;
+    }
+public:
+    int majorityElement(vector<int>& nums) {
+        return majority_element_rec(nums, 0, nums.size() - 1);
+    }
+};
+
+
+```
+
+
+
+#### 4 数据测试（测试截图）
+
+![2](C:%5CUsers%5C%E5%BF%83%E7%81%B5%E9%97%B4%E7%9A%84%E8%B7%B3%E8%B7%83%5CDesktop%5C4%5Cfenzhi%5C2.png)
+
+![1](C:%5CUsers%5C%E5%BF%83%E7%81%B5%E9%97%B4%E7%9A%84%E8%B7%B3%E8%B7%83%5CDesktop%5C4%5Cfenzhi%5C1.png)
\ No newline at end of file
diff --git a/fenzhi/gen.h b/fenzhi/gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b1e54d3245e3385385e56d2404080a2536d1cc3
--- /dev/null
+++ b/fenzhi/gen.h
@@ -0,0 +1,14 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//���ɷ�Χ��l~r������� 
+{
+	srand(time(0));  //����ʱ������
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//��������r~l������� 
+	}
+}
+
diff --git a/fenzhi/test.cpp b/fenzhi/test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b93e3abdebf9593eed067e1faf28e716446bf1d
--- /dev/null
+++ b/fenzhi/test.cpp
@@ -0,0 +1,17 @@
+#include"alg.h"
+#include"gen.h"
+#include<iostream>
+using namespace std;
+int main()
+{
+	int sum;
+	cin>>sum;
+	for(int i=0;i<sum;i++)
+	{
+		vector<int>  *a;
+		Random(a,50,0,100);
+		Solution A;
+		A.majorityElement(a);
+	}
+	return 0;
+}
diff --git a/gen1.py b/gen1.py
deleted file mode 100644
index d747c7c8047d9cf05ac0b8e7ebd02b757f06eed1..0000000000000000000000000000000000000000
--- a/gen1.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# 数据生成函数
-import random
-def generate_data():
-    n = random.randint(2, 100)
-    arr = [random.randint(1, 100) for _ in range(n)]
-    return (arr, )
-
-
-
diff --git a/gen2.py b/gen2.py
deleted file mode 100644
index d9ba82f3ef7281c513ba338ce041a2eb0767b990..0000000000000000000000000000000000000000
--- a/gen2.py
+++ /dev/null
@@ -1,7 +0,0 @@
-import random
-def generate_data():
-    n = random.randint(3, 100)
-    A = [random.randint(1, 10**6) for _ in range(n)]
-    return (A, )
-
-
diff --git a/gen3.py b/gen3.py
deleted file mode 100644
index 7b87fc08ef1926cb19244886314291a92b1787ec..0000000000000000000000000000000000000000
--- a/gen3.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def generate_data():
-    n = random.randint(1, 10)
-    return n
-
-
-
diff --git a/huisu/1.png b/huisu/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..f91ab1b226045bc71215388112d89edaf8a8099c
Binary files /dev/null and b/huisu/1.png differ
diff --git a/huisu/2.png b/huisu/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c85db95abf95aa043a69b1033dfce61e31b70895
Binary files /dev/null and b/huisu/2.png differ
diff --git a/huisu/alg.assets/1.png b/huisu/alg.assets/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..f91ab1b226045bc71215388112d89edaf8a8099c
Binary files /dev/null and b/huisu/alg.assets/1.png differ
diff --git a/huisu/alg.assets/2.png b/huisu/alg.assets/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c85db95abf95aa043a69b1033dfce61e31b70895
Binary files /dev/null and b/huisu/alg.assets/2.png differ
diff --git a/huisu/alg.h b/huisu/alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa2f4e4a71e0acd98d2e45f0b6a26833be773ea7
--- /dev/null
+++ b/huisu/alg.h
@@ -0,0 +1,35 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+#include"gen.h"
+using namespace std;
+
+class Solution {
+public:
+    void dfs(vector<int>& candidates, int target, vector<vector<int>>& ans, vector<int>& combine, int idx) {
+        if (idx == candidates.size()) {
+            return;
+        }
+        if (target == 0) {
+            ans.emplace_back(combine);
+            return;
+        }
+        // ֱ������
+        dfs(candidates, target, ans, combine, idx + 1);
+        // ѡ��ǰ��
+        if (target - candidates[idx] >= 0) {
+            combine.emplace_back(candidates[idx]);
+            dfs(candidates, target - candidates[idx], ans, combine, idx);
+            combine.pop_back();
+        }
+    }
+
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        vector<int> combine;
+        dfs(candidates, target, ans, combine, 0);
+        return ans;
+    }
+};
+
diff --git a/huisu/alg.md b/huisu/alg.md
new file mode 100644
index 0000000000000000000000000000000000000000..c19133c02fe08d69244dc77099b7e57f60f7f812
--- /dev/null
+++ b/huisu/alg.md
@@ -0,0 +1,101 @@
+## 组合总数
+
+#### 1 问题建模（描述）
+
+给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
+
+candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 
+
+对于给定的输入，保证和为 target 的不同组合数少于 150 个。
+
+示例：
+
+```
+输入：candidates = [2,3,6,7], target = 7
+输出：[[2,2,3],[7]]
+解释：
+2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
+7 也是一个候选， 7 = 7 。
+仅有这两种组合。
+
+```
+
+```
+输入: candidates = [2,3,5], target = 8
+输出: [[2,2,2,2],[2,3,3],[3,5]]
+```
+
+
+
+#### 2 数据生成（初始数据生成）
+
+```c++
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//生成范围在l~r的随机数 
+{
+	srand(time(0));  //设置时间种子
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//生成区间r~l的随机数 
+	}
+}
+```
+
+
+
+#### 3 算法设计（解决方法）
+
+1.以 target = 7 为 根结点 ，创建一个分支的时 做减法 ；
+
+2.每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 
+
+3.candidate 数组的每个元素的值；
+
+4.减到 0 或者负数的时候停止，即：结点 0 和负数结点成为叶子结点； 所有从根结点到结点 0 的路径（只能从上往下，没有回路）就是题目要找的一个结果。
+
+5.遇到这一类相同元素不计算顺序的问题，我们在搜索的时候就需要 **按某种顺序搜索**。具体的做法是：每一次搜索的时候设置 **下一轮搜索的起点**  即：从每一层的第 22 个结点开始，都不能再搜索产生同一层结点已经使用过的 `candidate` 里的元素。 
+
+
+
+
+
+```c++
+![1](1.pngclass Solution {
+public:
+    void dfs(vector<int>& candidates, int target, vector<vector<int>>& ans, vector<int>& combine, int idx) {
+        if (idx == candidates.size()) {
+            return;
+        }
+        if (target == 0) {
+            ans.emplace_back(combine);
+            return;
+        }
+        // 直接跳过
+        dfs(candidates, target, ans, combine, idx + 1);
+        // 选择当前数
+        if (target - candidates[idx] >= 0) {
+            combine.emplace_back(candidates[idx]);
+            dfs(candidates, target - candidates[idx], ans, combine, idx);
+            combine.pop_back();
+        }
+    }
+
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>> ans;
+        vector<int> combine;
+        dfs(candidates, target, ans, combine, 0);
+        return ans;
+    }
+};
+```
+
+
+
+#### 4 数据测试（测试截图）
+
+![1](alg.assets/1.png)
+
+![2](alg.assets/2.png)
\ No newline at end of file
diff --git a/huisu/gen.h b/huisu/gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b1e54d3245e3385385e56d2404080a2536d1cc3
--- /dev/null
+++ b/huisu/gen.h
@@ -0,0 +1,14 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//���ɷ�Χ��l~r������� 
+{
+	srand(time(0));  //����ʱ������
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//��������r~l������� 
+	}
+}
+
diff --git a/huisu/test.cpp b/huisu/test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca2add6ca7e5c2d5a4d8c98c7f6f3d98f14d543a
--- /dev/null
+++ b/huisu/test.cpp
@@ -0,0 +1,22 @@
+#include"alg.h"
+#include"gen.h"
+#include<iostream>
+using namespace std;
+int main()
+{
+    int sum;
+	cin>>sum;
+	for(int i=0;i<sum;i++)
+	{
+		vector<int>  *a;
+		Random(a,50,0,100);
+		int target=random(1,50);
+		vector<vector<int>> ans;
+		vector<int> combine;
+		 int idx=0;
+		Solution A;
+		A.(a,target *ans,*combine,idx);
+	}
+
+	return 0;
+}
diff --git a/huisu/test.exe b/huisu/test.exe
new file mode 100644
index 0000000000000000000000000000000000000000..334a37070763e5515a88a2110ded17cbdb7ad69a
Binary files /dev/null and b/huisu/test.exe differ
diff --git a/tanxin/1.png b/tanxin/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7780c7be1802e28b5de3cc5422346999166e85f
Binary files /dev/null and b/tanxin/1.png differ
diff --git a/tanxin/2.png b/tanxin/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..cf5f16f132a709382e423af531c28ad3a8409464
Binary files /dev/null and b/tanxin/2.png differ
diff --git a/tanxin/alg.assets/1.png b/tanxin/alg.assets/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7780c7be1802e28b5de3cc5422346999166e85f
Binary files /dev/null and b/tanxin/alg.assets/1.png differ
diff --git a/tanxin/alg.assets/2.png b/tanxin/alg.assets/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..cf5f16f132a709382e423af531c28ad3a8409464
Binary files /dev/null and b/tanxin/alg.assets/2.png differ
diff --git a/tanxin/alg.h b/tanxin/alg.h
new file mode 100644
index 0000000000000000000000000000000000000000..24300680ff242ac1ab23e1368f2f9b3019517b62
--- /dev/null
+++ b/tanxin/alg.h
@@ -0,0 +1,20 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+#include"gen.h"
+using namespace std;
+
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int k = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            if (i > k) return false;
+            k = max(k, i + nums[i]);
+        }
+        return true;
+    }
+};
+
+
diff --git a/tanxin/alg.md b/tanxin/alg.md
new file mode 100644
index 0000000000000000000000000000000000000000..240ed63d4dcee1c0e3403d02555eef1d5c772021
--- /dev/null
+++ b/tanxin/alg.md
@@ -0,0 +1,81 @@
+## 跳跃游戏
+
+#### 1 问题建模（描述）
+
+给定一个非负整数数组 `nums` ，你最初位于数组的 **第一个下标** 。
+
+数组中的每个元素代表你在该位置可以跳跃的最大长度。
+
+判断你是否能够到达最后一个下标。
+
+示例：
+
+```
+输入：nums = [2,3,1,1,4]
+输出：true
+解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
+```
+
+```
+输入：nums = [3,2,1,0,4]
+输出：false
+解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
+
+```
+
+
+
+#### 2 数据生成（初始数据生成）
+
+```c++
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//生成范围在l~r的随机数 
+{
+	srand(time(0));  //设置时间种子
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//生成区间r~l的随机数 
+	}
+}
+```
+
+
+
+#### 3 算法设计（解决方法）
+
+1.如果某一个作为 **起跳点** 的格子可以跳跃的距离是 3，那么表示后面 3 个格子都可以作为 **起跳点**
+2.可以对每一个能作为 **起跳点** 的格子都尝试跳一次，把 能跳到最远的距离 不断更新
+3.如果可以一直跳到最后，就成功了
+
+
+
+```c++
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+#include"gen.h"
+using namespace std;
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int k = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            if (i > k) return false;
+            k = max(k, i + nums[i]);
+        }
+        return true;
+    }
+};
+
+
+```
+
+
+
+#### 4 数据测试（测试截图）
+
+![2](alg.assets/2.png)![1](alg.assets/1.png)
diff --git a/tanxin/gen.h b/tanxin/gen.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b1e54d3245e3385385e56d2404080a2536d1cc3
--- /dev/null
+++ b/tanxin/gen.h
@@ -0,0 +1,14 @@
+#include<iostream>
+#include<cstdlib> 
+#include<ctime>
+#inclue <vector>
+using namespace std;
+
+void Random(vector<int> *a,int n,int l,int r)//���ɷ�Χ��l~r������� 
+{
+	srand(time(0));  //����ʱ������
+	for(int i=0;i<n;i++){
+		a[i]=rand()%(r-l+1)+l;//��������r~l������� 
+	}
+}
+
diff --git a/tanxin/test.cpp b/tanxin/test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9a5e081bfd84b00fefb61856ceed91a152d8e86a
--- /dev/null
+++ b/tanxin/test.cpp
@@ -0,0 +1,17 @@
+#include"alg.h"
+#include"gen.h"
+#include<iostream>
+using namespace std;
+int main()
+{
+	int sum;
+	cin>>sum;
+	for(int i=0;i<sum;i++)
+	{
+		vector<int>  *a;
+		Random(a,50,0,100);
+		Solution A;
+		A.canJump(a);
+	}
+	return 0;
+}
diff --git a/tanxin/test.exe b/tanxin/test.exe
new file mode 100644
index 0000000000000000000000000000000000000000..ffb276636aeee8b97f6e0087cc2f40fffc8d1dcc
Binary files /dev/null and b/tanxin/test.exe differ
diff --git a/test1.py b/test1.py
deleted file mode 100644
index e14a46961611324e2cc0c8855de4e4ce2d9e50fa..0000000000000000000000000000000000000000
--- a/test1.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gen
-import alg
-
-# 数据测试函数
-def test():
-    solution = Solution()
-    for i in range(10):
-        arr, = generate_data()
-        res = solution.mctFromLeafValues(arr)
-        print("Test case ", i + 1, ":\narr = ", arr, "\nres = ", res, "\n")
-test()
\ No newline at end of file
diff --git a/test2.py b/test2.py
deleted file mode 100644
index 8cef9bd7d6bb74f23477379536875f2bfeb7008d..0000000000000000000000000000000000000000
--- a/test2.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gen
-import alg
-# 数据测试函数
-def test():
-    solution = Solution()
-    for i in range(10):
-        A, = generate_data()
-        res = solution.largestPerimeter(A)
-        print("Test case ", i + 1, ":\nA = ", A, "\nres = ", res, "\n")
-if __name__ == "__main__":
-    test()
\ No newline at end of file
diff --git a/test3.py b/test3.py
deleted file mode 100644
index a1e7293616c3f8424dda0469352d5a0f9d26829e..0000000000000000000000000000000000000000
--- a/test3.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import gen
-import alg
-
-def test_data(n):
-    s = Solution()
-    res = s.solveNQueens(n)
-    expected = math.factorial(n) if n <= 10 else None
-    if len(res) == expected:
-        print("test case passed: n = %d, num of solutions = %d" % (n, len(res)))
-    else:
-        print("test case failed: n = %d, num of solutions = %d, expected = %s" % (n, len(res), expected))
-if __name__ == "__main__":
-    for i in range(10):
-        n = generate_data()
-        print("testing case #%d: n = %d" % (i+1, n))
-        test_data(n)
\ No newline at end of file