[dolphinscheduler-website] branch asf-site updated: Automated deployment: 1105f00a2ba1fd8aa80fd4a8c05a934fc738c003

[github-bot]

This is an automated email from the ASF dual-hosted git repository.

github-bot pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/dolphinscheduler-website.git


The following commit(s) were added to refs/heads/asf-site by this push:
     new 6f9f7f4  Automated deployment: 1105f00a2ba1fd8aa80fd4a8c05a934fc738c003
6f9f7f4 is described below

commit 6f9f7f47a1cf139182902e04e3bc96353687964d
Author: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
AuthorDate: Wed May 19 02:21:25 2021 +0000

    Automated deployment: 1105f00a2ba1fd8aa80fd4a8c05a934fc738c003
---
 build/{blog.c9ac780.js => blog.d8f06f4.js} |   2 +-
 en-us/blog/DAG.html                        |   8 +-
 en-us/blog/DAG.json                        |   2 +-
 en-us/blog/index.html                      |   2 +-
 zh-cn/blog/DAG.html                        | 169 +++++++++++++++++++++++++++++
 zh-cn/blog/DAG.json                        |   6 +
 zh-cn/blog/index.html                      |   4 +-
 7 files changed, 184 insertions(+), 9 deletions(-)

diff --git a/build/blog.c9ac780.js b/build/blog.d8f06f4.js
similarity index 94%
rename from build/blog.c9ac780.js
rename to build/blog.d8f06f4.js
index 0c80420..675167f 100644
--- a/build/blog.c9ac780.js
+++ b/build/blog.d8f06f4.js
@@ -1 +1 @@
-webpackJsonp([1],{1:function(e,t){e.exports=React},2:function(e,t){e.exports=ReactDOM},401:function(e,t,n){e.exports=n(402)},402:function(e,t,n){"use
 strict";function r(e){return e&&e.__esModule?e:{default:e}}function 
a(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a 
function")}function o(e,t){if(!e)throw new ReferenceError("this hasn't been 
initialised - super() hasn't been called");return!t||"object"!=typeof 
t&&"function"!=typeof t?e:t}function l(e,t){if("functi [...]
\ No newline at end of file
+webpackJsonp([1],{1:function(e,t){e.exports=React},2:function(e,t){e.exports=ReactDOM},401:function(e,t,n){e.exports=n(402)},402:function(e,t,n){"use
 strict";function r(e){return e&&e.__esModule?e:{default:e}}function 
a(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a 
function")}function o(e,t){if(!e)throw new ReferenceError("this hasn't been 
initialised - super() hasn't been called");return!t||"object"!=typeof 
t&&"function"!=typeof t?e:t}function l(e,t){if("functi [...]
\ No newline at end of file
diff --git a/en-us/blog/DAG.html b/en-us/blog/DAG.html
index 8ff3ba3..73a071e 100644
--- a/en-us/blog/DAG.html
+++ b/en-us/blog/DAG.html
@@ -23,7 +23,7 @@
 <p>The basic idea: first visit a starting vertex v in the graph, then from v, 
visit any vertex w~1~ that is adjacent to v and has not been visited, then 
visit any vertex w~2~ that is adjacent to w~1~ and has not been visited ...... 
Repeat the above process. When it is no longer possible to go down the graph, 
go back to the most recently visited vertex, and if it has adjacent vertices 
that have not been visited, continue the search process from that point until 
all vertices in the graph h [...]
 <h4>Example</h4>
 <p>In the diagram below, if the breadth first search (BFS) is used, the 
traversal is as follows: <code>1 2 5 3 4 6 7</code>. If the depth first search 
(DFS) is used, the traversal is as follows <code>1 2 3 4 5 6 7</code>.</p>
-<p><img 
src="https://github.com/QuakeWang/incubator-dolphinscheduler-website/blob/patch-1/img/DAG/DAG01.png?raw=true";
 alt="DAG01"></p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG01.png?raw=true";
 alt="DAG01"></p>
 <h3>Topological Sorting</h3>
 <p>The definition of topological ordering on Wikipedia is :</p>
 <p>For any Directed Acyclic Graph (DAG), the topological sorting is a linear 
sorting of all its nodes (there may be multiple such node sorts in the same 
directed graph). This sorting satisfies the condition that for any two nodes U 
and V in the graph, if there is a directed edge pointing from U to V, then U 
must appear ahead of V in the topological sorting.</p>
@@ -43,17 +43,17 @@
 <li>Repeat 1 and 2 until the current DAG graph is empty or there are no 
vertices of degree 0 in the current graph. The latter case indicates that a 
ring must exist in the directed graph.</li>
 </ol>
 <p><strong>For example, the following DAG graph :</strong></p>
-<p><img 
src="https://github.com/QuakeWang/incubator-dolphinscheduler-website/blob/patch-1/img/DAG/DAG02.png?raw=true";
 alt="DAG02"></p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG02.png?raw=true";
 alt="DAG02"></p>
 <p>In degree of node 1: 0, out degree: 2</p>
 <p>In degree of node 2: 1, out degree: 2</p>
 <p>In degree of node 3: 2, out degree: 1</p>
 <p>In degree of node 4: 2, out degree: 2</p>
 <p>In degree of node 5: 2, out degree: 0</p>
 <p><strong>Its topological sorting process is:</strong></p>
-<p><img 
src="https://github.com/QuakeWang/incubator-dolphinscheduler-website/blob/patch-1/img/DAG/DAG03.png?raw=true";
 alt="DAG03"></p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG03.png?raw=true";
 alt="DAG03"></p>
 <p>Therefore, the result of topological sorting is: {1,2,4,3,5}.</p>
 <p>If there is no node 2 —&gt; the arrow of node 4, then it is as follows:</p>
-<p><img 
src="https://github.com/QuakeWang/incubator-dolphinscheduler-website/blob/patch-1/img/DAG/DAG04.png?raw=true";
 alt="DAG04"></p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG04.png?raw=true";
 alt="DAG04"></p>
 <p>We can get its topological sort as: {1,2,4,3,5} or {1,4,2,3,5}, that is, 
for the same DAG graph, there may be multiple topological sort results .</p>
 <p>Topological sorting is mainly used to solve the dependency problem in 
directed graphs.</p>
 <p>**When talking about the implementation, it is necessary to insert the 
following : **</p>
diff --git a/en-us/blog/DAG.json b/en-us/blog/DAG.json
index 24d8153..2b87e21 100644
--- a/en-us/blog/DAG.json
+++ b/en-us/blog/DAG.json
@@ -1,6 +1,6 @@
 {
   "filename": "DAG.md",
-  "__html": "<h2>Big Data Workflow Task Scheduling - Directed Acyclic Graph 
(DAG) for Topological Sorting</h2>\n<h3>Reviewing the basics：</h3>\n<h4>Graph 
traversal：</h4>\n<p>A graph traversal is a visit to all the vertices in a graph 
once and only once, starting from a vertex in the graph and following some 
search method along the edges of the graph.</p>\n<p>Note : the tree is a 
special kind of graph, so tree traversal can actually be seen as a special kind 
of graph traversal.</p>\n<h4>T [...]
+  "__html": "<h2>Big Data Workflow Task Scheduling - Directed Acyclic Graph 
(DAG) for Topological Sorting</h2>\n<h3>Reviewing the basics：</h3>\n<h4>Graph 
traversal：</h4>\n<p>A graph traversal is a visit to all the vertices in a graph 
once and only once, starting from a vertex in the graph and following some 
search method along the edges of the graph.</p>\n<p>Note : the tree is a 
special kind of graph, so tree traversal can actually be seen as a special kind 
of graph traversal.</p>\n<h4>T [...]
   "link": "/dist/en-us/blog/DAG.html",
   "meta": {}
 }
\ No newline at end of file
diff --git a/en-us/blog/index.html b/en-us/blog/index.html
index c8ff32d..81c8d62 100644
--- a/en-us/blog/index.html
+++ b/en-us/blog/index.html
@@ -16,7 +16,7 @@
   <script 
src="//cdn.jsdelivr.net/npm/react-dom@15.6.2/dist/react-dom.min.js"></script>
   <script>window.rootPath = '';</script>
   <script src="/build/vendor.8fbfee8.js"></script>
-  <script src="/build/blog.c9ac780.js"></script>
+  <script src="/build/blog.d8f06f4.js"></script>
   <script>
     var _hmt = _hmt || [];
     (function() {
diff --git a/zh-cn/blog/DAG.html b/zh-cn/blog/DAG.html
new file mode 100644
index 0000000..c49bff9
--- /dev/null
+++ b/zh-cn/blog/DAG.html
@@ -0,0 +1,169 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, 
maximum-scale=1.0, user-scalable=no">
+  <meta name="keywords" content="DAG">
+  <meta name="description" content="DAG">
+  <title>DAG</title>
+  <link rel="shortcut icon" href="/img/favicon.ico">
+  <link rel="stylesheet" href="/build/vendor.c5ba65d.css">
+  <link rel="stylesheet" href="/build/blog.md.fd8b187.css">
+</head>
+<body>
+  <div id="root"><div class="blog-detail-page" data-reactroot=""><header 
class="header-container header-container-dark"><div class="header-body"><a 
href="/zh-cn/index.html"><img class="logo" src="/img/hlogo_white.svg"/></a><div 
class="search search-dark"><span class="icon-search"></span></div><span 
class="language-switch language-switch-dark">En</span><div 
class="header-menu"><img class="header-menu-toggle" 
src="/img/system/menu_white.png"/><div><ul class="ant-menu whiteClass 
ant-menu-li [...]
+<h3>回顾基础知识：</h3>
+<ul>
+<li>图的遍历</li>
+</ul>
+<p>​    图的遍历是指从图中的某一个顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。</p>
+<p>​    <strong>注意树是一种特殊的图，所以树的遍历实际上也可以看作是一种特殊的图的遍历</strong></p>
+<ul>
+<li>
+<p>图的遍历主要有两种算法</p>
+<ul>
+<li>
+<p>广度优先搜索（Breadth First Search，BFS）</p>
+<p>基本思想：首先访问起始顶点 v，接着由 v 出发，依次访问 v 的各个未访问过的邻接顶点 w1, w2 , … ,wi ，然后依次访问  w1, w2 
, … , w~i~  
的所有未被访问过的邻接顶点；再从这些访问过的顶点出发，访问它们所有未被访问过的邻接顶点，直至图中所有顶点都被访问过为止。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问过的顶点作为起始点，重复上述过程，直至图中所有的顶点都被访问到为止。</p>
+</li>
+<li>
+<p>深度优先搜索（Depth First Search，DFS）</p>
+<p>基本思想：首先访问图中某一起始顶点 v，然后由 v 出发，访问与 v 邻接且未被访问过的任一顶点 w1，再访问与 w1 邻接且未被访问的任一顶点 w2 
…… 
重复上述过程。当不能再继续向下访问时，依次退回到最近被访问的顶点，若它还有邻接顶点未被访问过，则从该点开始继续上述搜索过程，直至图中所有顶点均被访问过为止。</p>
+</li>
+</ul>
+</li>
+<li>
+<p>举例说明</p>
+<p>如下图，如果采用 广度优先搜索（BFS）遍历如下 <code>1 2 5 3 4 6 7</code>,如果采用深度优先搜索（DFS）遍历如下 
<code>1 2 3 4 5 6 7</code>。</p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG01.png?raw=true";
 alt="DAG01"></p>
+</li>
+</ul>
+<h3>拓扑排序(Topological Sorting)</h3>
+<p><strong>维基百科上拓扑排序的定义为</strong></p>
+<p>对于任何有向无环图 (Directed Acyclic Graph，DAG) 
而言，其拓扑排序为其所有结点的一个线性排序(同一个有向图可能存在多个这样的结点排序)。该排序满足这样的条件——对于图中的任意两个结点 U 和 
V，若存在一条有向边从 U 指向 V，则在拓扑排序中 U 一定出现在 V 前面。</p>
+<p><strong>通俗来讲：拓扑排序是一个有向无环图 (DAG) 的所有顶点的线性序列, 该序列必须满足两个条件</strong></p>
+<ul>
+<li>每个顶点出现且只出现一次。</li>
+<li>若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。</li>
+</ul>
+<p><strong>如何找出它的拓扑排序呢？这里说一种比较常用的方法：</strong></p>
+<p>在介绍这个方法之前有必要补充下有向图结点的入度 (indegree) 和出度 (outdegree) 
的概念。假设有向图中不存在起点和终点为同一结点的有向边，则：</p>
+<p>入度：设有向图中有一结点 V，其入度即为当前所有从其他结点出发，终点为 V 的的边的数目。也就是所有指向V的有向边的数目。</p>
+<p>出度：设有向图中有一结点 V，其出度即为当前所有起点为 V，指向其他结点的边的数目。也就是所有由 V 发出的边的数目。</p>
+<ol>
+<li>从 DAG 图中选择一个入度为 0 的顶点并输出。</li>
+<li>从图中删除该顶点和所有以它为起点的有向边。</li>
+<li>重复 1 和 2 直到当前的 DAG 图为空或当前图中不存在入度为 0 的顶点为止。后一种情况说明有向图中必然存在环。</li>
+</ol>
+<p><strong>例如下面这个 DAG 图：</strong></p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG02.png?raw=true";
 alt="DAG02"></p>
+<p>结点1的入度：0，出度：2</p>
+<p>结点2的入度：1，出度：2</p>
+<p>结点3的入度：2，出度：1</p>
+<p>结点4的入度：2，出度：2</p>
+<p>结点5的入度：2，出度：0</p>
+<p>它的拓扑排序流程为：<img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG03.png?raw=true";
 alt="DAG03"></p>
+<p>于是，得到拓扑排序后的结果是: {1,2,4,3,5} 。</p>
+<p>如果没有结点 2  —&gt; 结点 4 的这个箭头，那么如下：</p>
+<p><img 
src="https://github.com/apache/dolphinscheduler-website/blob/master/img/DAG/DAG04.png?raw=true";
 alt="DAG04"></p>
+<p>我们可以得到它的拓扑排序为：{1,2,4,3,5} 或者 {1,4,2,3,5} ，即对同一 DAG 图来说，它的拓扑排序结果可能存在多个。</p>
+<p>拓扑排序主要用来解决有向图中的依赖问题。</p>
+<p><strong>在讲到实现的时候，有必要插以下内容：</strong></p>
+<p>由此我们可以进一步得出一个改进的深度优先遍历或广度优先遍历算法来完成拓扑排序。以广度优先遍历为例，这一改进后的算法与普通的广度优先遍历唯一的区别在于我们应当保存每一个结点对应的入度，并在遍历的每一层选取入度为
 0 的结点开始遍历（而普通的广度优先遍历则无此限制，可以从该吃呢个任意一个结点开始遍历）。这个算法描述如下：</p>
+<ol>
+<li>初始化一个 Map 或者类似数据结构来保存每一个结点的入度。</li>
+<li>对于图中的每一个结点的子结点，将其子结点的入度加 1。</li>
+<li>选取入度为 0 的任意一个结点开始遍历，并将该节点加入输出。</li>
+<li>对于遍历过的每个结点，更新其子结点的入度：将子结点的入度减 1。</li>
+<li>重复步骤 3，直到遍历完所有的结点。</li>
+<li>如果无法遍历完所有的结点，则意味着当前的图不是有向无环图。不存在拓扑排序。</li>
+</ol>
+<p><strong>广度优先遍历拓扑排序的核心 Java 代码如下：</strong></p>
+<pre><code class="language-java"><span class="hljs-keyword">public</span> 
<span class="hljs-class"><span class="hljs-keyword">class</span> <span 
class="hljs-title">TopologicalSort</span> </span>{
+  <span class="hljs-comment">/**
+   * 判断是否有环及拓扑排序结果
+   *
+   * 有向无环图(DAG)才有拓扑(topological)排序
+   * 广度优先遍历的主要做法：
+   *    1、遍历图中所有的顶点，将入度为0的顶点入队列。
+   *    2、从队列中poll出一个顶点，更新该顶点的邻接点的入度(减1)，如果邻接点的入度减1之后等于0，则将该邻接点入队列。
+   *    3、一直执行第2步，直到队列为空。
+   * 如果无法遍历完所有的结点，则意味着当前的图不是有向无环图。不存在拓扑排序。
+   *
+   *
+   * <span class="hljs-doctag">@return</span> key返回的是状态, 如果成功(无环)为true, 失败则有环， 
value为拓扑排序结果(可能是其中一种)
+   */</span>
+  <span class="hljs-keyword">private</span> Map.Entry&lt;Boolean, 
List&lt;Vertex&gt;&gt; topologicalSort() {
+ <span class="hljs-comment">//入度为0的结点队列</span>
+    Queue&lt;Vertex&gt; zeroIndegreeVertexQueue = <span 
class="hljs-keyword">new</span> LinkedList&lt;&gt;();
+    <span class="hljs-comment">//保存结果</span>
+    List&lt;Vertex&gt; topoResultList = <span class="hljs-keyword">new</span> 
ArrayList&lt;&gt;();
+    <span class="hljs-comment">//保存入度不为0的结点</span>
+    Map&lt;Vertex, Integer&gt; notZeroIndegreeVertexMap = <span 
class="hljs-keyword">new</span> HashMap&lt;&gt;();
+
+    <span class="hljs-comment">//扫描所有的顶点,将入度为0的顶点入队列</span>
+    <span class="hljs-keyword">for</span> (Map.Entry&lt;Vertex, VertexInfo&gt; 
vertices : verticesMap.entrySet()) {
+      Vertex vertex = vertices.getKey();
+      <span class="hljs-keyword">int</span> inDegree = getIndegree(vertex);
+
+      <span class="hljs-keyword">if</span> (inDegree == <span 
class="hljs-number">0</span>) {
+        zeroIndegreeVertexQueue.add(vertex);
+        topoResultList.add(vertex);
+      } <span class="hljs-keyword">else</span> {
+        notZeroIndegreeVertexMap.put(vertex, inDegree);
+      }
+    }
+    
+ <span class="hljs-comment">//扫描完后，没有入度为0的结点，说明有环，直接返回</span>
+    <span class="hljs-keyword">if</span>(zeroIndegreeVertexQueue.isEmpty()){
+      <span class="hljs-keyword">return</span> <span 
class="hljs-keyword">new</span> AbstractMap.SimpleEntry(<span 
class="hljs-keyword">false</span>, topoResultList);
+    }
+
+    <span class="hljs-comment">//采用topology算法, 删除入度为0的结点和它的关联边</span>
+    <span class="hljs-keyword">while</span> 
(!zeroIndegreeVertexQueue.isEmpty()) {
+      Vertex v = zeroIndegreeVertexQueue.poll();
+      <span class="hljs-comment">//得到相邻结点</span>
+      Set&lt;Vertex&gt; subsequentNodes = getSubsequentNodes(v);
+
+      <span class="hljs-keyword">for</span> (Vertex subsequentVertex : 
subsequentNodes) {
+
+        Integer degree = notZeroIndegreeVertexMap.get(subsequentVertex);
+
+        <span class="hljs-keyword">if</span>(--degree == <span 
class="hljs-number">0</span>){
+          topoResultList.add(subsequentVertex);
+          zeroIndegreeVertexQueue.add(subsequentVertex);
+          notZeroIndegreeVertexMap.remove(subsequentVertex);
+        }<span class="hljs-keyword">else</span>{
+          notZeroIndegreeVertexMap.put(subsequentVertex, degree);
+        }
+
+      }
+    }
+
+    <span class="hljs-comment">//notZeroIndegreeVertexMap如果为空, 表示没有环</span>
+    AbstractMap.SimpleEntry resultMap = <span class="hljs-keyword">new</span> 
AbstractMap.SimpleEntry(notZeroIndegreeVertexMap.size() == <span 
class="hljs-number">0</span> , topoResultList);
+    <span class="hljs-keyword">return</span> resultMap;
+
+  }
+}
+</code></pre>
+<p><em>注意输出结果是该图的拓扑排序序列之一。</em></p>
+<p>每次在入度为 0 的集合中取顶点，并没有特殊的取出规则，取顶点的顺序不同会得到不同的拓扑排序序列(如果该图有多种排序序列)。</p>
+<p>由于输出每个顶点的同时还要删除以它为起点的边。如果图有 V 个顶点，E 条边，则一般该算法的时间复杂度为 O(V+E)。这里实现的算法最终 key 
返回的是状态, 如果成功(无环)为 true, 失败则有环， 无环时 value 
为拓扑排序结果(可能是其中一种)。注意输出结果是该图的拓扑排序序列之一。每次在入度为 0 
的集合中取顶点，并没有特殊的取出规则，取顶点的顺序不同会得到不同的拓扑排序序列(如果该图有多种排序序列)。</p>
+</section><footer class="footer-container"><div 
class="footer-body"><div><h3>联系我们</h3><h4>有问题需要反馈？请通过以下方式联系我们。</h4></div><div 
class="contact-container"><ul><li><img class="img-base" 
src="/img/emailgray.png"/><img class="img-change" src="/img/emailblue.png"/><a 
href="/zh-cn/community/development/subscribe.html"><p>邮件列表</p></a></li><li><img 
class="img-base" src="/img/twittergray.png"/><img class="img-change" 
src="/img/twitterblue.png"/><a 
href="https://twitter.com/dolphinschedule";><p>Twitt [...]
+  <script 
src="//cdn.jsdelivr.net/npm/react@15.6.2/dist/react-with-addons.min.js"></script>
+  <script 
src="//cdn.jsdelivr.net/npm/react-dom@15.6.2/dist/react-dom.min.js"></script>
+  <script>window.rootPath = '';</script>
+  <script src="/build/vendor.8fbfee8.js"></script>
+  <script src="/build/blog.md.57874be.js"></script>
+  <script>
+    var _hmt = _hmt || [];
+    (function() {
+      var hm = document.createElement("script");
+      hm.src = "https://hm.baidu.com/hm.js?4e7b4b400dd31fa015018a435c64d06f";;
+      var s = document.getElementsByTagName("script")[0];
+      s.parentNode.insertBefore(hm, s);
+    })();
+  </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/zh-cn/blog/DAG.json b/zh-cn/blog/DAG.json
new file mode 100644
index 0000000..8028e11
--- /dev/null
+++ b/zh-cn/blog/DAG.json
@@ -0,0 +1,6 @@
+{
+  "filename": "DAG.md",
+  "__html": 
"<h2>大数据工作流任务调度--有向无环图(DAG)之拓扑排序</h2>\n<h3>回顾基础知识：</h3>\n<ul>\n<li>图的遍历</li>\n</ul>\n<p>​
    图的遍历是指从图中的某一个顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。</p>\n<p>​    
<strong>注意树是一种特殊的图，所以树的遍历实际上也可以看作是一种特殊的图的遍历</strong></p>\n<ul>\n<li>\n<p>图的遍历主要有两种算法</p>\n<ul>\n<li>\n<p>广度优先搜索（Breadth
 First Search，BFS）</p>\n<p>基本思想：首先访问起始顶点 v，接着由 v 出发，依次访问 v 的各个未访问过的邻接顶点 w1, w2 
, … ,wi ，然后依次访问  w1, w2 , … , w~i~  
的所有未被访问过的邻接顶点；再从这些访问过的顶点出发，访问它们所有未被访问过的邻接顶点，直至图中所有顶点都被访问过为止。若此时图中尚有顶点未被访问，则
 另选图中一个未曾被访问过的 [...]
+  "link": "/dist/zh-cn/blog/DAG.html",
+  "meta": {}
+}
\ No newline at end of file
diff --git a/zh-cn/blog/index.html b/zh-cn/blog/index.html
index 49eb793..2333dfc 100644
--- a/zh-cn/blog/index.html
+++ b/zh-cn/blog/index.html
@@ -11,12 +11,12 @@
   <link rel="stylesheet" href="/build/blog.acc2955.css">
 </head>
 <body>
-  <div id="root"><div class="blog-list-page" data-reactroot=""><header 
class="header-container header-container-dark"><div class="header-body"><a 
href="/zh-cn/index.html"><img class="logo" src="/img/hlogo_white.svg"/></a><div 
class="search search-dark"><span class="icon-search"></span></div><span 
class="language-switch language-switch-dark">En</span><div 
class="header-menu"><img class="header-menu-toggle" 
src="/img/system/menu_white.png"/><div><ul class="ant-menu whiteClass 
ant-menu-ligh [...]
+  <div id="root"><div class="blog-list-page" data-reactroot=""><header 
class="header-container header-container-dark"><div class="header-body"><a 
href="/zh-cn/index.html"><img class="logo" src="/img/hlogo_white.svg"/></a><div 
class="search search-dark"><span class="icon-search"></span></div><span 
class="language-switch language-switch-dark">En</span><div 
class="header-menu"><img class="header-menu-toggle" 
src="/img/system/menu_white.png"/><div><ul class="ant-menu whiteClass 
ant-menu-ligh [...]
   <script 
src="//cdn.jsdelivr.net/npm/react@15.6.2/dist/react-with-addons.min.js"></script>
   <script 
src="//cdn.jsdelivr.net/npm/react-dom@15.6.2/dist/react-dom.min.js"></script>
   <script>window.rootPath = '';</script>
   <script src="/build/vendor.8fbfee8.js"></script>
-  <script src="/build/blog.c9ac780.js"></script>
+  <script src="/build/blog.d8f06f4.js"></script>
   <script>
     var _hmt = _hmt || [];
     (function() {