feat: add bit&setment_tree

Author: sqmw

.DS_Store

@@ -1,141 +1,134 @@
-# LEETCODE
+# LEETCODE 刷题笔记
 
-- 做题换算 难 = 2 * 中等 == 4 * 简单
-    - 做到需要收费的时候每天 4 题及其以下
-- 变量定义域的使用按照C语言使用(更加规范)
-- 编写算法不仅需要保证性能，也需要保证代码的可读性
-- 160题附近开始收费，此时已经做完所有的数据结构一遍了(似乎还差图，但是树也是特殊的图)
-- 本人算法实现规则：
-    - 时间复杂度需要达到最低
-    - 空间复杂度不超过O(n)即可，对于空间复杂度的要求非必要不降低到O(1)
-- 本人变量命名
-    - des_XXX 表示目标值
-    - rec_f 表示递归/迭代函数
+## 一、刷题原则与规范
 
-## 数据结构&算法基础
+### 1. 刷题规则
+- 难度换算: 1道难题 = 2道中等题 = 6道简单题
+- 每日目标：做到需要收费的时候每天4题及其以下
+- 160题附近开始收费，此时已完成所有基础数据结构（除图外）
 
-- 数据结构和算法是核心
-    - 排序算法需要全部能够实现
-    - 需要会所有的图(线性表和二叉树都是特殊的图,字符串是特殊的线性表)
-    - 需要能够手动实现一个 hash
+### 2. 编码规范
+- 变量定义域按照C语言使用（更加规范）
+- 算法实现需同时保证性能和可读性
+- 变量命名规则：
+  - `des_XXX`: 表示目标值
+  - `rec_f`: 表示递归/迭代函数
 
-## 算法实现
+### 3. 算法实现标准
+- 时间复杂度：需要达到最低
+- 空间复杂度：不超过O(n)即可，非必要不降低到O(1)
 
-- 循环
-- 递归
+## 二、核心知识体系
 
-- 递归 == 循环 + 栈
-    - (因为递归本来就是通过栈和循环实现的)
-    - *`递归和循环的S、T一般相同`*
+### 1. 数据结构基础
+- 排序算法：需要全部掌握
+- 图论：包括线性表和二叉树（都是特殊的图）
+- 哈希：需要能够手动实现
 
-## 算法使用的数据结构
+### 2. 算法实现方式
+- 循环实现
+- 递归实现
+- 重要概念：递归 == 循环 + 栈
+  - *递归和循环的空间、时间复杂度一般相同*
+  - 递归本质是通过栈和循环实现
 
+### 3. 基础数据结构
 1. 线性表
-2. 字符串
+2. 字符串（特殊的线性表）
 3. 树
-    1. 线段树(segment tree)/树状数组(Binary Indexed Tree，BIT)
+   - 线段树(segment tree)
+   - 树状数组(Binary Indexed Tree，BIT)
 4. 图
 
-## 算法思想
+### 4. 核心算法思想
 
-1. 贪心算法(最长递增子序列)
+#### 4.1 贪心算法
+- 典型应用：最长递增子序列
 
-2. 动态规划
-    - 一般动态规划
-    - 记忆化动态规划
-        - Memoization(375)/记忆化搜索(从后往前看的递归动态规划/本质是动态规划的逆向思维 & 递归)
+#### 4.2 动态规划
+- 一般动态规划
+- 记忆化动态规划
+  - Memoization(375)
+  - 记忆化搜索（从后往前看的递归动态规划）
+- 动态规划本质：
+  - 数学归纳法（递推公式）
+  - f(x) = f(x - 1) + f(x - 2) + ...
 
-    - 动态规划的本质：
-        - 数学归纳法(递推公式)
-        - f(x) = f(x - 1) + f(x - 2) + ...(第n项的结果由前面的某m项决定)
+#### 4.3 回溯算法(216)
+```python
+if condition_if:
+    des_arr.append(path[:])
+else:
+    for condition_for:
+        path.append()
+        traceback()
+        path.pop()
+```
 
-3. traceback(216)
+#### 4.4 分治算法
 
-    ```
-    if condition_if:
-        des_arr.append(path[:])
-    else:
-        for condition_for:
-            path.append()
-            traceback()
-            path.pop()
-    ```
-
-4. divide-and-conquer algorithm
-
-### 贪心算法难题
+## 三、难题分类总结
 
+### 1. 贪心算法难题
 | 题号  | 时间复杂度      | 题目                             | 完成方法                |
 |-----|------------|--------------------------------|---------------------|
 | 300 | O(nlog(n)) | Longest Increasing Subsequence |                     |
-| 162 |            |                                |                     |
-| 179 |            |                                | (内置排序算法，想到但是不能排序出来) |
+| 162 |            |                                | 未证明可行性             |
+| 179 |            |                                | 内置排序算法，想到但不能排序出来   |
 | 334 | O(n)       | triplet                        | 两个数组最优置换            |
 
-- 未证明可行性:
-  162
-- 看答案做出题:
-    - 179(内置排序算法，想到但是不能排序出来)
-      ```
-        nums = [2, 1, 3, 4, 1, 2, 3, 4]
-        def cmp(x, y):
-            return x - y # -1 理解为 每次 x 取出最小的一个 x(java的比较函数就是这样)
-        nums.sort(key=functools.cmp_to_key(cmp))
-        print(nums)  # [1, 1, 2, 2, 3, 3, 4, 4]       
-      ```
-    - 322(换零钱问题,在这里需要使用记忆化搜索实现)
-    - 375(miniMax, 需要使用缓存方式来进行搜索)
-    - 395(分治最长子字符串所有字符数量都不小于k)
-
-### 回溯思想难题
-
-题目序号：39 78 90
-
-### 动态规划难题
+#### 特殊情况说明：
+- 179题排序示例：
+```python
+nums = [2, 1, 3, 4, 1, 2, 3, 4]
+def cmp(x, y):
+    return x - y # -1 理解为每次x取出最小的一个x
+nums.sort(key=functools.cmp_to_key(cmp))
+print(nums)  # [1, 1, 2, 2, 3, 3, 4, 4]       
+```
 
-题目序号：73,139,337(二叉树的动态规划), 392(使用动态规划来理解和做是难点)
+### 2. 回溯思想难题
+- 核心题目：39, 78, 90
 
-### 时间上面需要提升的题目
+### 3. 动态规划难题
+- 关键题目：73, 139, 337(二叉树的动态规划), 392(使用动态规划理解是难点)
 
+### 4. 需要优化的题目
 | 题目序号 | 题目描述                                            | 总结 |
 |------|-------------------------------------------------|----|
 | 105  | 需要加深二叉树 先序\|中序 遍历特性的理解                          | ?  |
 | 106  | 需要加深二叉树 中序\|后序 遍历特性的理解                          | ?  |
 | 130  | 广度优先遍历/二维数组                                     | ?  |
-| 307  | 线段树(segment tree)/树状数组(Binary Indexed Tree，BIT) | ?  |
+| 307  | 线段树/树状数组                                        | ?  |
 
-### 未做出来题目
-
-| 题目序号                          | 知识点       | 总数 |
+### 5. 未解决题目
+| 题目序号                          | 知识点       | 序号 |
 |-------------------------------|-----------|----|
-| 95(3) 、 96(3)[需要做出98题再来做这两题]  | 树的遍历      | 1  |
+| 95(3)、96(3)[需要做出98题再来做这两题]   | 树的遍历      | 1  |
 | 241                           | 和 95 一个类型 | 2  |
 | 292                           | NIM游戏和博弈论 | 3  |
-| 309(多个数组动态规划)                 | 股票买卖/要冷却  | 4  |
-| 310(图变树)[超时后看答案解出来的,类似找重心的过程] | 减节点/树的直径  | 5  |
-
-### bit manipulation(位运算)
+| 309                           | 股票买卖/要冷却  | 4  |
+| 310[超时后看答案解出来的,类似找重心的过程]      | 减节点/树的直径  | 5  |
 
-| 编号  | ... | ... | ... |
-|-----|-----|-----|-----|
-| 201 | ... | ... | ... |
+## 四、特殊专题
 
-### 其他
-
-#### 数学
+### 1. 位运算
+| 编号  | 知识点 |
+|-----|-----|
+| 201 | ... |
 
+### 2. 数学专题
 | 题目序号 | 题目知识                  |
 |------|-----------------------|
 | 204  | prime                 |
 | 279  | 四平方定理                 |
-| 372  | [372 super pow](#372) |
-
-- <span id="372">372 super pow</span>
-    - 涉及知识 (x * y) % m == ((x % m)*(y % m)) % m
-    - 该表达式可以分类讨论得以证明，具有递归累计效果
+| 372  | super pow             |
 
-#### 有趣的题目
+#### 372题重要知识点
+- (x * y) % m == ((x % m)*(y % m)) % m
+- 该表达式可以分类讨论证明，具有递归累计效果
 
+### 3. 有趣的题目
 | 题目序号 | 描述                                                    |
 |------|-------------------------------------------------------|
 | 205  | 同构字符串                                                 |
@@ -148,12 +141,14 @@
 | 287  | Floyd 数组重复数字判定/抽屉原理                                   |
 | 292  | NIM游戏、博弈论                                             |
 | 319  | 灯泡开关(brainteaser)                                     |
-| 380  | Insert Delete GetRandom O(1)[使用 hash 实现]              |
-| 496  | Next Greater Element I[stack & expression evaluation] |
+| 380  | Insert Delete GetRandom O(1)                          |
+| 496  | Next Greater Element I                                |
 
-#### 二进制知识点
+## 五、技巧总结
 
-| 操作        | 意义             |
-|-----------|----------------|
-| x&(x - 1) | 用来去除 x 的最右边的 1 |
+### 二进制操作技巧
+| 操作        | 意义                   |
+|-----------|----------------------|
+| x&(x - 1) | 用来去除 x 的最右边的 1       |
+| x&(-x)    | lowbit，也就是取出最低位代表的数字 |
 

.idea/leetcode.iml

@@ -0,0 +1,77 @@
+from collections import defaultdict
+from typing import List, Dict, Set
+
+
+class Solution:
+    def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:
+        """
+        计算除法表达式的结果
+        
+        Args:
+            equations: 表达式列表，每个表达式形如 ["a", "b"] 表示 a/b
+            values: 对应表达式的值
+            queries: 需要计算的查询列表
+            
+        Returns:
+            List[float]: 查询结果列表，如果无法计算则返回 -1.0
+            
+        Time: O(Q * (V + E)) 其中 Q 是查询数量，V 是变量数量，E 是方程数量
+        Space: O(V^2) 用于存储图的邻接表
+        """
+        # 构建图的邻接表
+        graph: Dict[str, Dict[str, float]] = defaultdict(dict)
+        for (dividend, divisor), value in zip(equations, values):
+            graph[dividend][divisor] = value
+            graph[divisor][dividend] = 1.0 / value
+
+        def dfs(start: str, target: str, visited: Set[str]) -> float:
+            """深度优先搜索计算结果"""
+            # 处理特殊情况
+            if start not in graph or target not in graph:
+                return -1.0
+            if start == target:
+                return 1.0
+            if target in graph[start]:
+                return graph[start][target]
+
+            visited.add(start)
+            # 遍历所有可能的路径
+            for next_node, value in graph[start].items():
+                if next_node not in visited:
+                    result = dfs(next_node, target, visited)
+                    if result != -1.0:
+                        # 这个充分利用了题目的条件，我的之前的代码更具有普适性
+                        return value * result
+            visited.remove(start)
+            return -1.0
+
+        # 处理所有查询
+        return [dfs(start, target, set()) for start, target in queries]
+
+
+def test_solution():
+    """测试用例"""
+    test_cases = [
+        (
+            [["a", "b"], ["c", "d"]],
+            [1.0, 1.0],
+            [["a", "c"], ["b", "d"], ["b", "a"], ["d", "c"]],
+            [-1.0, -1.0, 1.0, 1.0]
+        ),
+        (
+            [["a", "b"], ["b", "c"]],
+            [2.0, 3.0],
+            [["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"]],
+            [6.0, 0.5, -1.0, 1.0, -1.0]
+        )
+    ]
+    
+    solution = Solution()
+    for i, (equations, values, queries, expected) in enumerate(test_cases, 1):
+        result = solution.calcEquation(equations, values, queries)
+        assert result == expected, f"Test case {i} failed: expected {expected}, got {result}"
+        print(f"Test case {i} passed!")
+
+
+if __name__ == '__main__':
+    test_solution()