From 4aa20b3ef5fff53cf9c7073cfa5e29acd6a08e22 Mon Sep 17 00:00:00 2001
From: 46135621 <87229030+46135621@users.noreply.github.com>
Date: Thu, 20 Apr 2023 00:00:16 +0800
Subject: [PATCH 1/5] =?UTF-8?q?Update=204.2=E6=9C=BA=E5=99=A8=E5=AD=A6?=
 =?UTF-8?q?=E4=B9=A0=EF=BC=88AI=EF=BC=89=E5=BF=AB=E9=80=9F=E5=85=A5?=
 =?UTF-8?q?=E9=97=A8=EF=BC=88quick=20start=EF=BC=89.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...¹ ï¼ˆAI）快速入门（quick start）.md | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md b/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md
index ea935c9..5376fd1 100644
--- a/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md	
+++ b/4.人工智能/4.2机器学习（AI）快速入门（quick start）.md	
@@ -84,19 +84,19 @@
 
 ```python
 def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
-  price = 0<em>  # In my area, the average house costs $200 per sqft</em>
+  price = 0  # In my area, the average house costs $200 per sqft
   price_per_sqft = 200  if neighborhood == "hipsterton":
-   <em> # but some areas cost a bit more</em>
+    # but some areas cost a bit more
     price_per_sqft = 400  elif neighborhood == "skid row":
-   <em> # and some areas cost less</em>
-    price_per_sqft = 100  <em># start with a base price estimate based on how big the place is</em>
-  price = price_per_sqft * sqft  <em># now adjust our estimate based on the number of bedrooms</em>
+    # and some areas cost less
+    price_per_sqft = 100  # start with a base price estimate based on how big the place is
+  price = price_per_sqft * sqft  # now adjust our estimate based on the number of bedrooms
   if num_of_bedrooms == 0:
-    <em># Studio apartments are cheap</em>
+    # Studio apartments are cheap
     price = price — 20000
   else:
-   <em> # places with more bedrooms are usually</em>
-<em>    # more valuable</em>
+    # places with more bedrooms are usually
+    # more valuable
     price = price + (num_of_bedrooms * 1000) return price
 ```
 
@@ -212,9 +212,9 @@ def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
 ```python
 def estimate_house_sales_price(num_of_bedrooms, sqft, neighborhood):
  price = 0# a little pinch of this
- price += num_of_bedrooms * <strong>0.123</strong># and a big pinch of that
- price += sqft * <strong>0.41</strong># maybe a handful of this
- price += neighborhood * <strong>0.57</strong>
+ price += num_of_bedrooms * 0.123# and a big pinch of that
+ price += sqft * 0.41# maybe a handful of this
+ price += neighborhood * 0.57
  return price
 ```
 
@@ -328,10 +328,10 @@ print('y_pred=',y_test.data)
 请注�，我们的神�网络现在有了两个输出（而�仅仅是一个房�的价格）。第一个输出会预测图片是「8�的概率，而第二个则输出�是「8�的概率。概括地说，我们就�以��多���的输出，利用神�网络把�识别的物�进行分组。
 
 ```python
-<strong>model = Sequential([Dense(32, input_shape=(784,)), </strong>
-<strong>  Activation('relu'),Dense(10),Activation('softmax')])</strong># 你也�以通过 .add() 方法简�地添加层：<strong>  model = Sequential() </strong>
-<strong>  model.add(Dense(32, input_dim=784)) </strong>
-<strong>  model.add(Activation('relu'))# 激活函数，你�以�解为加上这个东西�以让他效果更好</strong>
+model = Sequential([Dense(32, input_shape=(784,)), 
+  Activation('relu'),Dense(10),Activation('softmax')])# 你也�以通过 .add() 方法简�地添加层：  model = Sequential() 
+  model.add(Dense(32, input_dim=784)) 
+  model.add(Activation('relu'))# 激活函数，你�以�解为加上这个东西�以让他效果更好
 ```
 
 虽然我们的神�网络�比上次大得多（这次有 324 个输入，上次�有 3 个�），但是现在的计算机一眨眼的功夫就能够对这几百个节点进行�算。当然，你的手机也�以�到。

From 5d962c0d4d36ced1ba32e33cd2e28c8bccb06ea7 Mon Sep 17 00:00:00 2001
From: 46135621 <985579956@qq.com>
Date: Thu, 20 Apr 2023 00:49:48 +0800
Subject: [PATCH 2/5] fix

---
 4.人工智能/4.3.1�索.md | 297 ++++++++--------------------------
 1 file changed, 69 insertions(+), 228 deletions(-)

diff --git a/4.人工智能/4.3.1�索.md b/4.人工智能/4.3.1�索.md
index bd4e1e1..775d015 100644
--- a/4.人工智能/4.3.1�索.md
+++ b/4.人工智能/4.3.1�索.md
@@ -47,16 +47,8 @@
 - 动作(Action)
 
   - 一个状��以�出的选择。更确切地说，动作�以定义为一个函数。当接收到状�
-    $$
-    s$$作为输入时，
-    $$
-
-    Actions(s)
-    $$
-    将返回�在状�
-    $$
-
-    s$$ 中执行的一组�作作为输出。
+    
+    $s$作为输入时，$Actions(s)$将返回�在状�$s$ 中执行的一组�作作为输出。
   - 例如，在一个数字�容�中，给定状�的�作是您�以在当��置中滑动方�的方�。
 
 ![](static/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png)
@@ -65,45 +57,15 @@
 
   - 对在任何状�下执行任何适用�作所产生的状�的�述。
   - 更确切地说，过渡模型�以定义为一个函数。
-  - 在接收到状�
-    $$
-    s$$和动作
-    $$
-
-    a
-    $$
-    作为输入时，
-    $$
-
-    Results(s，a)
-    $$
-    返回在状�
-    $$
-
-    s
-    $$
-    中执行动作
-    $$
-
-    a$$ 所产生的状�。
-  - 例如，给定数字�容�的特定�置（状�
-    $$
-    s$$），在任何方�上移动正方形（动作
-    $$
-
-    a$$）将导致谜题的新�置（新状�）。
+  - 在接收到状�$s$和动作$a$作为输入时，$Results(s，a)$返回在状�$s$中执行动作$a$ 所产生的状�。
+  - 例如，给定数字�容�的特定�置（状�$s$），在任何方�上移动正方形（动作$a$）将导致谜题的新�置（新状�）。
 
 ![](static/RKV2buJoroCV6SxiMUuct3dbnPU.png)
 
 - 状�空间(State Space)
 
   - 通过一系列的�作目标从�始状��达到的所有状�的集�。
-  - 例如，在一个数字�容�谜题中，状�空间由所有
-    $$
-    \frac{16!}{2}
-    $$
-
-    ��置，�以从任何�始状�达到。状�空间�以�视化为有�图，其中状�表示为节点，动作表示为节点之间的箭头。
+  - 例如，在一个数字�容�谜题中，状�空间由所有$\frac{16!}{2}$��置，�以从任何�始状�达到。状�空间�以�视化为有�图，其中状�表示为节点，动作表示为节点之间的箭头。
 
 ![](static/JdCqb2UI9ooWmdxk258cTIIznab.png)
 
@@ -130,11 +92,11 @@
   - 从�始状�到该节点的路径�本——path cost
 - 节点包�的信�使它们对于�索算法�常有用。
 
-它们包�一个状�，�以使用目标测试�检查该状�是�为最终状�。
+  它们包�一个状�，�以使用目标测试�检查该状�是�为最终状�。
 
-如果是，则�以将节点的路径�本与其他节点的路径代价进行比较，从而�以选择最佳解决方案。
+  如果是，则�以将节点的路径�本与其他节点的路径代价进行比较，从而�以选择最佳解决方案。
 
-一旦选择了节点，通过存储父节点和从父节点到当�节点的动作，就�以追溯从�始状�到该节点的�一步，而这一系列动作就是解决方案。
+  一旦选择了节点，通过存储父节点和从父节点到当�节点的动作，就�以追溯从�始状�到该节点的�一步，而这一系列动作就是解决方案。
 
 - 然而，节点�是一个数�结构——它们��索，而是�存信�。为了实际�索，我们使用了边域(frontier)，�“管��节点的机制。边域首先包�一个�始状�和一组空的已探索项目（探索集），然���以下�作，直到找到解决方案：
 
@@ -158,9 +120,9 @@
 
 边域从节点 A �始化开始
 
-1. �出边域中的节点 A，展开节点 A，将节点 B 添加到边域。
-2. �出节点 B，展开，添加......
-3. 到达目标节点，�止，返回解决方案
+a. �出边域中的节点 A，展开节点 A，将节点 B 添加到边域。
+b. �出节点 B，展开，添加......
+c. 到达目标节点，�止，返回解决方案
 
 ![](static/XmnObIGaUoF4ssxkgzUc4vTUnmf.png)
 
@@ -191,7 +153,7 @@
 
 ![](static/M2vZbA5hpoT9RExuAGwcBHF1nmh.png)
 
-- 代�实现
+  - 代�实现
 
 ```python
 def remove(self):
@@ -223,7 +185,7 @@ def remove(self):
 
 ![](static/PQeZbJv3Bom6NYxa6lccT084nFn.png)
 
-- 代�实现
+  - 代�实现
 
 ```python
 def remove(self):
@@ -240,37 +202,25 @@ def remove(self):
 - 广度优先和深度优先都是�知情的�索算法。也就是说，这些算法没有利用他们没有通过自己的探索获得的关于问题的任何知识。然而，大多数情况下，关于这个问题的一些知识实际上是�用的。例如，当人类进入一个路�时，人类�以看到哪�路沿�解决方案的大致方��进，哪�路没有。人工智能也�以这样�。一�考虑�外知识以试图�高性能的算法被称为知情�索算法。
 - 贪婪最佳优先�索(Greedy Best-First Search)
 
-  - 贪婪最佳优先�索扩展最接近目标的节点，如���函数
-    $$
-    h(n)
-    $$
-
-    所确定的。顾��义，该函数估计下一个节点离目标有多近，但�能会出错。贪婪最佳优先算法的效率�决于���函数的好�。例如，在迷宫中，算法�以使用���函数，该函数�赖于�能节点和迷宫末端之间的曼哈顿�离。曼哈顿�离忽略了墙�，并计算了从一个�置到目标�置需��上��下或�两侧走多少步。这是一个简�的估计，�以基于当��置和目标�置的
-    $$
-    (x，y)
-    $$
-
-    �标导出。
+  - 贪婪最佳优先�索扩展最接近目标的节点，如���函数$h(n)$所确定的。顾��义，该函数估计下一个节点离目标有多近，但�能会出错。贪婪最佳优先算法的效率�决于���函数的好�。例如，在迷宫中，算法�以使用���函数，该函数�赖于�能节点和迷宫末端之间的曼哈顿�离。曼哈顿�离忽略了墙�，并计算了从一个�置到目标�置需��上��下或�两侧走多少步。这是一个简�的估计，�以基于当��置和目标�置的$(x，y)$�标导出。
 
 ![](static/Pe3WbBuTjomWjfxd5Ryc3OPPnSd.png)
 
-- 然而，��的是�强调，与任何���算法一样，它�能会出错，并导致算法走上比其他情况下更慢的�路。�知情的�索算法有�能更快地�供一个更好的解决方案，但它比知情算法更��能这样。
+  - 然而，��的是�强调，与任何���算法一样，它�能会出错，并导致算法走上比其他情况下更慢的�路。�知情的�索算法有�能更快地�供一个更好的解决方案，但它比知情算法更��能这样。
 
 ![](static/HkvdbcEdmo6RtjxOqqic31XFnSh.png)
 
 ![](static/SU2DbQeN2oxs5ex3K3NcMaJfnch.png)
 
-- $$
-  A^*$$�索
-
-  - 作为贪婪最佳优先算法的一��展，$$A^*$$�索�仅考虑了从当��置到目标的估计�本$$h(n)$$，还考虑了直到当��置为止累积的�本$$g(n)$$。通过组�这两个值，该算法�以更准确地确定解决方案的�本并在旅途中优化其选择。该算法跟踪（到目�为止的路径�本+到目标的估计�本,$$g(n)+h(n)$$），一旦它超过了之��个选项的估计�本，该算法将放弃当�路径并返回到之�的选项，从而防止自己沿�$$h(n)$$错误地标记为最佳的�长而低效的路径�进。
-
-  - 然而，由于这�算法也�赖于���，所以它�赖它所使用的���。在�些情况下，它�能比贪婪的最佳第一�索甚至�知情的算法效率更低。对于最佳的$$A^*$$�索，���函数$$h(n)$$应该：
-
+- $A^*$�索
+  
+  - 作为贪婪最佳优先算法的一��展，$A^*$�索�仅考虑了从当��置到目标的估计�本$h(n)$，还考虑了直到当��置为止累积的�本$g(n)$。通过组�这两个值，该算法�以更准确地确定解决方案的�本并在旅途中优化其选择。该算法跟踪（到目�为止的路径�本+到目标的估计�本,$g(n)+h(n)$），一旦它超过了之��个选项的估计�本，该算法将放弃当�路径并返回到之�的选项，从而防止自己沿�$h(n)$错误地标记为最佳的�长而低效的路径�进。
+  
+  - 然而，由于这�算法也�赖于���，所以它�赖它所使用的���。在�些情况下，它�能比贪婪的最佳第一�索甚至�知情的算法效率更低。对于最佳的$A^*$�索，���函数$h(n)$应该：
+    
     - �接�，从未高估真实�本。
-
-    - 一致性，这�味�从新节点到目标的估计路径�本加上从先�节点转�到该新节点的�本应该大于或等于先�节点到目标的估计路径�本。用方程的形�表示，$$h(n)$$是一致的，如果对于�个节点$$n$$和�续节点$$n'$$，从$$n$$到$$n'$$的步长为$$c$$，满足$$h(n)≤h(n')+c$$。
-  $$
+    
+    - 一致性，这�味�从新节点到目标的估计路径�本加上从先�节点转�到该新节点的�本应该大于或等于先�节点到目标的估计路径�本。用方程的形�表示，$h(n)$是一致的，如果对于�个节点n$和�续节点n'$，从n$到$n'$的步长为c$，满足$h(n)≤h(n')+c$。
 
 ![](static/BbIiba1pwo3uI7x4k7QcwicznGc.png)
 
@@ -282,72 +232,45 @@ def remove(self):
 
 - �大��算法(Minimax)
 
-  - 作为对抗性�索中的一�算法，Minimax 将获胜�件表示为
-    $$
-    (-1)
-    $$
+  - 作为对抗性�索中的一�算法，Minimax 将获胜�件表示为$(-1)$表示为一方，$(+1)$表示为�一方。进一步的行动将�到这些�件的驱动，最�化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
+  
+    <img src="static/FYu3bQwCZofBgsxKDJiciTR7nzc.png" style="zoom:150%;" />
+  
+-  井字棋 AI 为例
+  
+    - $s_0$: �始状�（在我们的情况下，是一个空的3X3棋盘）
+    
+      ![](D:\MDnote\MDimage\WstnbmHwYoQauRxUQOCclz8Jngb-1681921487075.png)
 
-    表示为一方，
-    $$
-    (+1)
-    $$
-
-    表示为�一方。进一步的行动将�到这些�件的驱动，最�化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
-
-![](static/FYu3bQwCZofBgsxKDJiciTR7nzc.png)
-
-- 井字棋 AI 为例
-
-  - $$
-    s_0$$: �始状�（在我们的情况下，是一个空的3X3棋盘）
-    $$
-
-![](static/WstnbmHwYoQauRxUQOCclz8Jngb.png)
-
-```
-- $$Players(s)$$: 一个函数，在给定状�$$s$$的情况下，返回轮到哪个玩家（X或O）。
-```
-
-![](static/DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
-
-```
-- $$Actions(s)$$: 一个函数，在给定状�$$s$$的情况下，返回该状�下的所有�法动作（棋盘上哪些�置是空的）。
-```
-
-![](static/LuEzbLOaqox7yox5lXzcouWYnKc.png)
-
-```
-- $$Result(s, a)$$: 一个函数，在给定状�$$s$$和�作$$a$$的情况下，返回一个新状�。这是在状�$$s$$上执行动作$$a$$（在游�中移动）所产生的棋盘。
-```
-
-![](static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
-
-```
-- $$Terminal(s)$$: 一个函数，在给定状�$$s$$的情况下，检查这是�是游�的最�一步，�是�有人赢了或打�平手。如果游�已结�，则返回True，�则返回False。
-```
-
-![](static/EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
-
-```
-- $$Utility(s)$$: 一个函数，在给定终端状�s的情况下，返回状�的效用值：$$-1�0或1$$。
-```
+    - $$Players(s)$$: 一个函数，在给定状�$$s$$的情况下，返回轮到哪个玩家（X或O）。
+    
+      ![](D:\MDnote\MDimage\DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
+    
+    - $Actions(s)$: 一个函数，在给定状�$$s$$的情况下，返回该状�下的所有�法动作（棋盘上哪些�置是空的）。
+    
+      ![](D:\MDnote\MDimage\LuEzbLOaqox7yox5lXzcouWYnKc.png)
+    
+    - $Result(s, a)$: 一个函数，在给定状�$$s$$和�作$$a$$的情况下，返回一个新状�。这是在状�$$s$$上执行动作$$a$$（在游�中移动）所产生的棋盘。
+    
+      ![](D:\MDnote\MDimage\AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
+    
+    - $Terminal(s)$: 一个函数，在给定状�$$s$$的情况下，检查这是�是游�的最�一步，�是�有人赢了或打�平手。如果游�已结�，则返回True，�则返回False。
+    
+      ![](D:\MDnote\MDimage\EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
+    
+    - $Utility(s)$: 一个函数，在给定终端状�s的情况下，返回状�的效用值：$$-1�0或1$$。
+    
+      
 
 ![](static/UcpAbpWtJoHb5Wx6ycrcG2ZZnIe.png)
 
 - 算法的工作原�：
 
-  - 该算法递归地模拟从当�状�开始直到达到终端状�为止�能�生的所有游�状�。�个终端状�的值为
-    $$
-    (-1)�0或(+1)
-    $$
-
-    。
+  - 该算法递归地模拟从当�状�开始直到达到终端状�为止�能�生的所有游�状�。�个终端状�的值为$(-1)$�$0$或$(+1)$。
 
 ![](static/DN3mb0lbno2AHvx2M0JcrTvtnYf.png)
 
-```
-- 根�轮到�的状�，算法�以知�当�玩家在最佳游�时是�会选择导致状�值更低或更高的动作。
-```
+  - 根�轮到�的状�，算法�以知�当�玩家在最佳游�时是�会选择导致状�值更低或更高的动作。
 
 通过这�方�，在最�化和最大化之间交替，算法为�个�能的动作产生的状�创建值。举一个更具体的例�，我们�以想象，最大化的玩家在�一个回�都会问：“如果我采�这个行动，就会产生一个新的状�。如果最�化的玩家�挥得最好，那么该玩家�以采�什么行动�达到最低值？�
 
@@ -361,102 +284,30 @@ def remove(self):
 
 - 具体算法：
 
-  - 给定状� $$s$$
+  - 给定状� $s$
 
-    - 最大化玩家在
-      $$
-      Actions(s)
-      $$
+    - 最大化玩家在$$Actions(s)$$中选择动作$$a$$，该动作产生$$Min-value(Result(s,a))$$ 的最高值。
+    - 最�化玩家在$$Actions(s)$$中选择动作$$a$$，该动作产生$$Max-value(Result(s,a))$$ 的最�值。
 
-      中选择动作
-      $$
-      a$$，该动作产生
-      $$
-
-      Min-value(Result(s,a))$$ 的最高值。
-    - 最�化玩家在
-      $$
-      Actions(s)
-      $$
-
-      中选择动作
-      $$
-      a$$，该动作产生
-      $$
-
-      Max-value(Result(s,a))$$ 的最�值。
   - Function Max-Value(state):
-
-    - $$
-      v=-\infty
-      $$
-    - if 
-      $$
-      Terminal(state)
-      $$
-
-      :
-
-      - return 
-        $$
-        Utility(state)
-        $$
-    - for 
-      $$
-      action
-      $$
-
-       in 
-      $$
-      Actions(state)
-      $$
-
-      :
-
-      - $$
-        v = Max(v, Min-Value(Result(state, action)))
-        $$
+    - $$v=-\infty$$
+    - if $$Terminal(state)$$:
+      - return $$Utility(state)$$
+    - for $$action$$ in $$Actions(state)$$:
+      - $$v = Max(v, Min-Value(Result(state, action)))$$
     - return $$v$$
   - Function Min-Value(state):
-
-    - $$
-      v=\infty
-      $$
-    - if 
-      $$
-      Terminal(state)
-      $$
-
-      :
-
-      - return 
-        $$
-        Utility(state)
-        $$
-    - for 
-      $$
-      action
-      $$
-
-       in 
-      $$
-      Actions(state)
-      $$
-
-      :
-
-      - $$
-        v = Min(v, Max-Value(Result(state, action)))
-        $$
+    - $$v=\infty$$
+    - if $$Terminal(state)$$:
+      - return $$Utility(state)$$
+    - for $$action$$ in $$Actions(state)$$:
+      - $$v = Min(v, Max-Value(Result(state, action)))$$
     - return $$v$$
 
 �会�解递归？也许你需�看看这个：[阶段二:递归�作](https://hdu-cs-lecture-notes.feishu.cn/wiki/wikcnwIRBW8rXspHQvigmYXZSWd)
 
-- $$
-  \alpha$$-$$\beta$$剪�(Alpha-Beta Pruning)
-
+- $$\alpha$$-$$\beta$$剪�(Alpha-Beta Pruning)
   - 作为一�优化Minimax的方法，Alpha-Beta剪�跳过了一些明显�利的递归计算。在确定了一个动作的价值�，如果有�步��表明接下�的动作�以让对手获得比已�确定的动作更好的分数，那么就没有必�进一步调查这个动作，因为它肯定比之�确定的动作�利。
-
   - 这一点最容易用一个例��说明：最大化的玩家知�，在下一步，最�化的玩家将试图获得最低分数。�设最大化玩家有三个�能的动作，第一个动作的值为4。然�玩家开始为下一个动作生�值。��到这一点，如果当�玩家�出这个动作，玩家会生�最�化者动作的值，并且知�最�化者会选择最低的一个。然而，在完�最�化器所有�能动作的计算之�，玩家会看到其中一个选项的值为3。这�味�没有�由继续探索最�化玩家的其他�能行动。尚未赋值的动作的值无关紧�，无论是10还是（-10）。如果该值为10，则最�化器将选择最低选项3，该选项已�比预先设定的4差。如果尚未估价的行动结果是（-10），那么最�化者将选择（-10）这一选项，这对最大化者�说更加�利。因此，在这一点上为最�化者计算�外的�能动作与最大化者无关，因为最大化玩家已�有了一个明确的更好的选择，其值为4。
   $$
 
@@ -464,15 +315,5 @@ def remove(self):
 
 - 深度�制的�大��算法(Depth-Limited Minimax)
 
-  - 总共有
-    $$
-    255168
-    $$
-
-    个�能的井字棋游�，以�有
-    $$
-    10^{29000}
-    $$
-
-    个�能的国际象棋中游�。到目�为止，最�最大算法需�生�从�个点到<strong>终端�件</strong>的所有�设游�状�。虽然计算所有的井字棋游�状�对现代计算机�说并�是一个挑战，但目�用�计算国际象棋是��能的。
-  - 深度�制的 Minimax 算法在�止之��考虑预先定义的移动次数，而从未达到终端状�。然而，这��许获得�个动作的精确值，因为�设的游�还没有结�。为了解决这个问题，深度�制 Minimax �赖于一个评估函数，该函数从给定状�估计游�的预期效用，或者���说，为状�赋值。例如，在国际象棋游�中，效用函数会将棋盘的当��置作为输入，�试评估其预期效用（基于�个玩家拥有的棋��其在棋盘上的�置），然�返回一个正值或负值，表示棋盘对一个玩家对�一个玩家的有利程度。这些值�以用�决定正确的�作，并且评估函数越好，�赖它的 Minimax 算法就越好。
+  - 总共有$$255168$$个�能的井字棋游�，以�有$$10^{29000}$$个�能的国际象棋中游�。到目�为止，最�最大算法需�生�从�个点到<strong>终端�件</strong>的所有�设游�状�。虽然计算所有的井字棋游�状�对现代计算机�说并�是一个挑战，但目�用�计算国际象棋是��能的。
+  - 深度�制的 Minimax 算法在�止之��考虑预先定义的移动次数，而从未达到终端状�。然而，这��许获得�个动作的精确值，因为�设的游�还没有结�。为了解决这个问题，深度�制 Minimax �赖于一个评估函数，该函数从给定状�估计游�的预期效用，或者���说，为状�赋值。例如，在国际象棋游�中，效用函数会将棋盘的当��置作为输入，�试评估其预期效用（基于�个玩家拥有的棋��其在棋盘上的�置），然�返回一个正值或负值，表示棋盘对一个玩家对�一个玩家的有利程度。这些值�以用�决定正确的�作，并且评估函数越好，�赖它的 Minimax 算法就越好。
\ No newline at end of file

From c90da867a3ff232634321a08f553c1ab127720f1 Mon Sep 17 00:00:00 2001
From: 46135621 <87229030+46135621@users.noreply.github.com>
Date: Thu, 20 Apr 2023 01:00:02 +0800
Subject: [PATCH 3/5] =?UTF-8?q?Update=204.3.1=E6=90=9C=E7=B4=A2.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 4.人工智能/4.3.1�索.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/4.人工智能/4.3.1�索.md b/4.人工智能/4.3.1�索.md
index 775d015..04386b0 100644
--- a/4.人工智能/4.3.1�索.md
+++ b/4.人工智能/4.3.1�索.md
@@ -46,9 +46,7 @@
 
 - 动作(Action)
 
-  - 一个状��以�出的选择。更确切地说，动作�以定义为一个函数。当接收到状�
-    
-    $s$作为输入时，$Actions(s)$将返回�在状�$s$ 中执行的一组�作作为输出。
+  - 一个状��以�出的选择。更确切地说，动作�以定义为一个函数。当接收到状�$s$作为输入时，$Actions(s)$将返回�在状�$s$ 中执行的一组�作作为输出。
   - 例如，在一个数字�容�中，给定状�的�作是您�以在当��置中滑动方�的方�。
 
 ![](static/MpgrbCjtDo1NlLxVyL1cMH6FnAg.png)
@@ -316,4 +314,4 @@ def remove(self):
 - 深度�制的�大��算法(Depth-Limited Minimax)
 
   - 总共有$$255168$$个�能的井字棋游�，以�有$$10^{29000}$$个�能的国际象棋中游�。到目�为止，最�最大算法需�生�从�个点到<strong>终端�件</strong>的所有�设游�状�。虽然计算所有的井字棋游�状�对现代计算机�说并�是一个挑战，但目�用�计算国际象棋是��能的。
-  - 深度�制的 Minimax 算法在�止之��考虑预先定义的移动次数，而从未达到终端状�。然而，这��许获得�个动作的精确值，因为�设的游�还没有结�。为了解决这个问题，深度�制 Minimax �赖于一个评估函数，该函数从给定状�估计游�的预期效用，或者���说，为状�赋值。例如，在国际象棋游�中，效用函数会将棋盘的当��置作为输入，�试评估其预期效用（基于�个玩家拥有的棋��其在棋盘上的�置），然�返回一个正值或负值，表示棋盘对一个玩家对�一个玩家的有利程度。这些值�以用�决定正确的�作，并且评估函数越好，�赖它的 Minimax 算法就越好。
\ No newline at end of file
+  - 深度�制的 Minimax 算法在�止之��考虑预先定义的移动次数，而从未达到终端状�。然而，这��许获得�个动作的精确值，因为�设的游�还没有结�。为了解决这个问题，深度�制 Minimax �赖于一个评估函数，该函数从给定状�估计游�的预期效用，或者���说，为状�赋值。例如，在国际象棋游�中，效用函数会将棋盘的当��置作为输入，�试评估其预期效用（基于�个玩家拥有的棋��其在棋盘上的�置），然�返回一个正值或负值，表示棋盘对一个玩家对�一个玩家的有利程度。这些值�以用�决定正确的�作，并且评估函数越好，�赖它的 Minimax 算法就越好。

From 1d6a296af38e0b333e1a4c6ea6e444245f286f37 Mon Sep 17 00:00:00 2001
From: camera-2018 <2907618001@qq.com>
Date: Thu, 20 Apr 2023 01:08:59 +0800
Subject: [PATCH 4/5] =?UTF-8?q?fix:=204.3.1=20=E5=9B=BE=E7=89=87=E8=B7=AF?=
 =?UTF-8?q?=E5=BE=84=E4=B8=8D=E6=AD=A3=E7=A1=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .vitepress/cache/deps/_metadata.json |  6 +++---
 4.人工智能/4.3.1�索.md        | 14 +++++++-------
 package-lock.json                    |  2 +-
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.vitepress/cache/deps/_metadata.json b/.vitepress/cache/deps/_metadata.json
index 5094116..ea8fe0c 100644
--- a/.vitepress/cache/deps/_metadata.json
+++ b/.vitepress/cache/deps/_metadata.json
@@ -1,11 +1,11 @@
 {
-  "hash": "37427fdc",
-  "browserHash": "93d17c76",
+  "hash": "6fdfc41b",
+  "browserHash": "128697d0",
   "optimized": {
     "vue": {
       "src": "../../../node_modules/vue/dist/vue.runtime.esm-bundler.js",
       "file": "vue.js",
-      "fileHash": "87e80f21",
+      "fileHash": "6266fb14",
       "needsInterop": false
     }
   },
diff --git a/4.人工智能/4.3.1�索.md b/4.人工智能/4.3.1�索.md
index 04386b0..9a3fa19 100644
--- a/4.人工智能/4.3.1�索.md
+++ b/4.人工智能/4.3.1�索.md
@@ -38,7 +38,7 @@
 
   - 智能主体在其环境中的�置。
   - 例如，在一个数字�容�谜题中，一个状�是所有数字排列在棋盘上的任何一�方�。
-  - �始状�(Initial State）
+  - �始状�（Initial State）
 
     - �索算法开始的状�。在导航应用程�中，这将是当��置。
 
@@ -238,23 +238,23 @@ def remove(self):
   
     - $s_0$: �始状�（在我们的情况下，是一个空的3X3棋盘）
     
-      ![](D:\MDnote\MDimage\WstnbmHwYoQauRxUQOCclz8Jngb-1681921487075.png)
+      ![](static/WstnbmHwYoQauRxUQOCclz8Jngb.png)
 
     - $$Players(s)$$: 一个函数，在给定状�$$s$$的情况下，返回轮到哪个玩家（X或O）。
     
-      ![](D:\MDnote\MDimage\DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
+      ![](static/DKzTbJSZMoc1UkxT9KOcIHqvnob.png)
     
     - $Actions(s)$: 一个函数，在给定状�$$s$$的情况下，返回该状�下的所有�法动作（棋盘上哪些�置是空的）。
     
-      ![](D:\MDnote\MDimage\LuEzbLOaqox7yox5lXzcouWYnKc.png)
+      ![](static/LuEzbLOaqox7yox5lXzcouWYnKc.png)
     
     - $Result(s, a)$: 一个函数，在给定状�$$s$$和�作$$a$$的情况下，返回一个新状�。这是在状�$$s$$上执行动作$$a$$（在游�中移动）所产生的棋盘。
     
-      ![](D:\MDnote\MDimage\AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
+      ![](static/AdOVbwCGhoVcWVx21TMcdhbDnIg.png)
     
     - $Terminal(s)$: 一个函数，在给定状�$$s$$的情况下，检查这是�是游�的最�一步，�是�有人赢了或打�平手。如果游�已结�，则返回True，�则返回False。
     
-      ![](D:\MDnote\MDimage\EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
+      ![](static/EOfJbvoUMogVT8xsrTxcl5ugnrk.png)
     
     - $Utility(s)$: 一个函数，在给定终端状�s的情况下，返回状�的效用值：$$-1�0或1$$。
     
@@ -302,7 +302,7 @@ def remove(self):
       - $$v = Min(v, Max-Value(Result(state, action)))$$
     - return $$v$$
 
-�会�解递归？也许你需�看看这个：[阶段二:递归�作](https://hdu-cs-lecture-notes.feishu.cn/wiki/wikcnwIRBW8rXspHQvigmYXZSWd)
+�会�解递归？也许你需�看看这个：[阶段二:递归�作](../3.%E7%BC%96%E7%A8%8B%E6%80%9D%E7%BB%B4%E4%BD%93%E7%B3%BB%E6%9E%84%E5%BB%BA/3.6.4.2%E9%98%B6%E6%AE%B5%E4%BA%8C%EF%BC%9A%E9%80%92%E5%BD%92%E6%93%8D%E4%BD%9C.md)
 
 - $$\alpha$$-$$\beta$$剪�(Alpha-Beta Pruning)
   - 作为一�优化Minimax的方法，Alpha-Beta剪�跳过了一些明显�利的递归计算。在确定了一个动作的价值�，如果有�步��表明接下�的动作�以让对手获得比已�确定的动作更好的分数，那么就没有必�进一步调查这个动作，因为它肯定比之�确定的动作�利。
diff --git a/package-lock.json b/package-lock.json
index e3ceb6a..7f99a68 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,5 +1,5 @@
 {
-  "name": "srt-wiki",
+  "name": "hdu-cs-wiki-cww",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

From b17c99064c3216bae151fff4b724bae682b0c5c1 Mon Sep 17 00:00:00 2001
From: camera-2018 <2907618001@qq.com>
Date: Thu, 20 Apr 2023 01:22:09 +0800
Subject: [PATCH 5/5] fix: 4.3.1 html tag

---
 4.人工智能/4.3.1�索.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/4.人工智能/4.3.1�索.md b/4.人工智能/4.3.1�索.md
index 9a3fa19..503e98a 100644
--- a/4.人工智能/4.3.1�索.md
+++ b/4.人工智能/4.3.1�索.md
@@ -232,7 +232,7 @@ def remove(self):
 
   - 作为对抗性�索中的一�算法，Minimax 将获胜�件表示为$(-1)$表示为一方，$(+1)$表示为�一方。进一步的行动将�到这些�件的驱动，最�化的一方试图获得最低分数，而最大化的一方则试图获得最高分数。
   
-    <img src="static/FYu3bQwCZofBgsxKDJiciTR7nzc.png" style="zoom:150%;" />
+    ![](static/FYu3bQwCZofBgsxKDJiciTR7nzc.png)
   
 -  井字棋 AI 为例