From 21e0b64e00f1b310ba50419f72d2f825c0ec5fd6 Mon Sep 17 00:00:00 2001
From: rockhugoo <40551806+rockhugoo@users.noreply.github.com>
Date: Thu, 8 Nov 2018 11:56:46 +0800
Subject: [PATCH] edit for running

add variable define:
seen = set()
need_visited = ['A']
comment:
#seen.add(city)
---
 2018-autumn/.ipynb                            | 708 +++++++++++++++++
 .../.ipynb_checkpoints/.ipynb-checkpoint      | 708 +++++++++++++++++
 ...-01-An Introduction to AI-checkpoint.ipynb | 713 ++++++++++++++++++
 .../Lecture-01-An Introduction to AI.ipynb    | 130 ++--
 4 files changed, 2196 insertions(+), 63 deletions(-)
 create mode 100644 2018-autumn/.ipynb
 create mode 100644 2018-autumn/.ipynb_checkpoints/.ipynb-checkpoint
 create mode 100644 2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb

diff --git a/2018-autumn/.ipynb b/2018-autumn/.ipynb
new file mode 100644
index 0000000..0eadea0
--- /dev/null
+++ b/2018-autumn/.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar = \"\"\"\n",
+    "sentence = adj noun verb adv noun2\n",
+    "adj = adj_single adj_single 的 | null\n",
+    "adj_single = 漂亮  | 蓝色 | 好看\n",
+    "adv = 安静地 | 静静\n",
+    "noun = 猫 | 女人 | 男人\n",
+    "verb = adv 看着 | adv 坐着 \n",
+    "noun2 = 桌子 | 皮球 \n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_grammar(grammar_str, split='='):\n",
+    "    grammar_pattern = {}\n",
+    "    for line in grammar_str.split('\\n'):\n",
+    "        if not line: continue\n",
+    "        stmt, expr = line.split(split)\n",
+    "        grammar_pattern[stmt.strip()] = [e.split() for e in expr.split('|')]\n",
+    "    return grammar_pattern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate(grammar_pattern, target):\n",
+    "    if target not in grammar_pattern: return target\n",
+    "    \n",
+    "    expr = random.choice(grammar_pattern[target])\n",
+    "    \n",
+    "    tokens = [generate(grammar_pattern, e) for e in expr]\n",
+    "    \n",
+    "    return ''.join([t for t in tokens if t != 'null'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar_pattern = build_grammar(grammar)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'漂亮蓝色的女人安静地坐着静静皮球'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate(grammar_pattern, 'sentence')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A simple solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def adj(): return random.choice('漂亮 | 蓝色 | 好看'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun(): return  random.choice('猫 | 女人 | 男人'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def verb(): return random.choice('看着 | 坐着 '.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun2(): return random.choice('桌子 | 皮球'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sentence(): return ''.join([adj(), noun(), verb(), noun2()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'漂亮  女人 看着 桌子 '"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sentence()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Search Based Intelligence"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BSF 广度搜索 DFS 深度优先搜索"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### BFS Breadth First Search \n",
+    "### DFS Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph = {\n",
+    "    'A' :'B B B C', \n",
+    "    'B' : 'A C', \n",
+    "    'C' : 'A B D E',\n",
+    "    'D' : 'C',\n",
+    "    'E' : 'C F',\n",
+    "    'F' : 'E'\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k in graph:\n",
+    "    graph[k] = set(graph[k].split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'元素' in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "2\n",
+      "10\n",
+      "6\n",
+      "5\n",
+      "4\n",
+      "8\n",
+      "1\n",
+      "7\n",
+      "元素\n",
+      "100000\n",
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split()):\n",
+    "    print(element)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'A': {'B', 'C'},\n",
+       " 'B': {'A', 'C'},\n",
+       " 'C': {'A', 'B', 'D', 'E'},\n",
+       " 'D': {'C'},\n",
+       " 'E': {'C', 'F'},\n",
+       " 'F': {'E'}}"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L = [0, 1, 2, 3, 4, 5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Breadth First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : A\n",
+      "   I am looking at : B\n",
+      "   I am looking at : C\n",
+      "   I am looking at : D\n",
+      "   I am looking at : E\n",
+      "   I am looking at : F\n"
+     ]
+    }
+   ],
+   "source": [
+    "seen = set()\n",
+    "need_visited = ['A']\n",
+    "while need_visited:\n",
+    "    node = need_visited.pop(0)\n",
+    "    if node in seen: continue\n",
+    "    print('   I am looking at : {}'.format(node))\n",
+    "    need_visited += graph[node]\n",
+    "    \n",
+    "    seen.add(node)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph_long = {\n",
+    "    '1': '2 7',\n",
+    "    '2': '3', \n",
+    "    '3': '4', \n",
+    "    '4': '5', \n",
+    "    '5': '6 10', \n",
+    "    '7': '8',\n",
+    "    '6': '5',\n",
+    "    '8': '9',\n",
+    "    '9': '10', \n",
+    "    '10': '5 11', \n",
+    "    '11': '12',\n",
+    "    '12': '11',\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for n in graph_long: graph_long[n] = graph_long[n].split()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repetition is the mother of evil."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search(graph, concat_func):\n",
+    "    seen = set()\n",
+    "    need_visited = ['1']   \n",
+    "    \n",
+    "    while need_visited:\n",
+    "        node = need_visited.pop(0)\n",
+    "        if node in seen: continue\n",
+    "        print('   I am looking at : {}'.format(node))\n",
+    "        seen.add(node)\n",
+    "        new_discoveried = graph[node]        \n",
+    "        need_visited = concat_func(new_discoveried, need_visited)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def treat_new_discover_more_important(new_discoveried, need_visited):\n",
+    "    return new_discoveried + need_visited\n",
+    "\n",
+    "def treat_already_discoveried_more_important(new_discoveried, need_visited):\n",
+    "    return need_visited + new_discoveried"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import partial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dfs = partial(search, concat_func=treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "dfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bfs = partial(search, concat_func=treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "bfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mapping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BJ = 'Beijing'\n",
+    "SZ = 'Shenzhen'\n",
+    "GZ = 'Guangzhou'\n",
+    "WH = 'Wuhan'\n",
+    "HLG = 'Heilongjiang'\n",
+    "NY = 'New York City'\n",
+    "CM = 'Chiangmai'\n",
+    "SG = 'Singapore'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = {\n",
+    "    BJ : {SZ, GZ, WH, HLG, NY}, \n",
+    "    GZ : {WH, BJ, CM, SG},\n",
+    "    SZ : {BJ, SG},\n",
+    "    WH : {BJ, GZ},\n",
+    "    HLG : {BJ},\n",
+    "    CM : {GZ},\n",
+    "    NY : {BJ}\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = networkx.Graph(air_route)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "networkx.draw(air_route, with_labels=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search_desitination(graph, start, destination):\n",
+    "    pathes = [[start]]\n",
+    "    seen = set()\n",
+    "    choosen_pathes = []\n",
+    "    while pathes:\n",
+    "        path = pathes.pop(0)\n",
+    "        froniter = path[-1]\n",
+    "        if froniter in seen: continue\n",
+    "        # get new lines\n",
+    "        \n",
+    "        for city in graph[froniter]:\n",
+    "            new_path = path + [city]\n",
+    "            pathes.append(new_path)\n",
+    "            if city == destination: return new_path\n",
+    "        \n",
+    "        #seen.add(city)\n",
+    "    return choosen_pathes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_route(cities): return ' ✈️ -> '.join(cities)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Singapore ✈️ -> Guangzhou ✈️ -> Beijing ✈️ -> Heilongjiang'"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "draw_route(search_desitination(air_route, SG, HLG))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2018-autumn/.ipynb_checkpoints/.ipynb-checkpoint b/2018-autumn/.ipynb_checkpoints/.ipynb-checkpoint
new file mode 100644
index 0000000..0eadea0
--- /dev/null
+++ b/2018-autumn/.ipynb_checkpoints/.ipynb-checkpoint
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar = \"\"\"\n",
+    "sentence = adj noun verb adv noun2\n",
+    "adj = adj_single adj_single 的 | null\n",
+    "adj_single = 漂亮  | 蓝色 | 好看\n",
+    "adv = 安静地 | 静静\n",
+    "noun = 猫 | 女人 | 男人\n",
+    "verb = adv 看着 | adv 坐着 \n",
+    "noun2 = 桌子 | 皮球 \n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_grammar(grammar_str, split='='):\n",
+    "    grammar_pattern = {}\n",
+    "    for line in grammar_str.split('\\n'):\n",
+    "        if not line: continue\n",
+    "        stmt, expr = line.split(split)\n",
+    "        grammar_pattern[stmt.strip()] = [e.split() for e in expr.split('|')]\n",
+    "    return grammar_pattern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate(grammar_pattern, target):\n",
+    "    if target not in grammar_pattern: return target\n",
+    "    \n",
+    "    expr = random.choice(grammar_pattern[target])\n",
+    "    \n",
+    "    tokens = [generate(grammar_pattern, e) for e in expr]\n",
+    "    \n",
+    "    return ''.join([t for t in tokens if t != 'null'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar_pattern = build_grammar(grammar)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'漂亮蓝色的女人安静地坐着静静皮球'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate(grammar_pattern, 'sentence')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A simple solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def adj(): return random.choice('漂亮 | 蓝色 | 好看'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun(): return  random.choice('猫 | 女人 | 男人'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def verb(): return random.choice('看着 | 坐着 '.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun2(): return random.choice('桌子 | 皮球'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sentence(): return ''.join([adj(), noun(), verb(), noun2()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'漂亮  女人 看着 桌子 '"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sentence()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Search Based Intelligence"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BSF 广度搜索 DFS 深度优先搜索"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### BFS Breadth First Search \n",
+    "### DFS Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph = {\n",
+    "    'A' :'B B B C', \n",
+    "    'B' : 'A C', \n",
+    "    'C' : 'A B D E',\n",
+    "    'D' : 'C',\n",
+    "    'E' : 'C F',\n",
+    "    'F' : 'E'\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k in graph:\n",
+    "    graph[k] = set(graph[k].split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'元素' in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3\n",
+      "2\n",
+      "10\n",
+      "6\n",
+      "5\n",
+      "4\n",
+      "8\n",
+      "1\n",
+      "7\n",
+      "元素\n",
+      "100000\n",
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split()):\n",
+    "    print(element)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'A': {'B', 'C'},\n",
+       " 'B': {'A', 'C'},\n",
+       " 'C': {'A', 'B', 'D', 'E'},\n",
+       " 'D': {'C'},\n",
+       " 'E': {'C', 'F'},\n",
+       " 'F': {'E'}}"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L = [0, 1, 2, 3, 4, 5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Breadth First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : A\n",
+      "   I am looking at : B\n",
+      "   I am looking at : C\n",
+      "   I am looking at : D\n",
+      "   I am looking at : E\n",
+      "   I am looking at : F\n"
+     ]
+    }
+   ],
+   "source": [
+    "seen = set()\n",
+    "need_visited = ['A']\n",
+    "while need_visited:\n",
+    "    node = need_visited.pop(0)\n",
+    "    if node in seen: continue\n",
+    "    print('   I am looking at : {}'.format(node))\n",
+    "    need_visited += graph[node]\n",
+    "    \n",
+    "    seen.add(node)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph_long = {\n",
+    "    '1': '2 7',\n",
+    "    '2': '3', \n",
+    "    '3': '4', \n",
+    "    '4': '5', \n",
+    "    '5': '6 10', \n",
+    "    '7': '8',\n",
+    "    '6': '5',\n",
+    "    '8': '9',\n",
+    "    '9': '10', \n",
+    "    '10': '5 11', \n",
+    "    '11': '12',\n",
+    "    '12': '11',\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for n in graph_long: graph_long[n] = graph_long[n].split()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repetition is the mother of evil."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search(graph, concat_func):\n",
+    "    seen = set()\n",
+    "    need_visited = ['1']   \n",
+    "    \n",
+    "    while need_visited:\n",
+    "        node = need_visited.pop(0)\n",
+    "        if node in seen: continue\n",
+    "        print('   I am looking at : {}'.format(node))\n",
+    "        seen.add(node)\n",
+    "        new_discoveried = graph[node]        \n",
+    "        need_visited = concat_func(new_discoveried, need_visited)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def treat_new_discover_more_important(new_discoveried, need_visited):\n",
+    "    return new_discoveried + need_visited\n",
+    "\n",
+    "def treat_already_discoveried_more_important(new_discoveried, need_visited):\n",
+    "    return need_visited + new_discoveried"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import partial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dfs = partial(search, concat_func=treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "dfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bfs = partial(search, concat_func=treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "bfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mapping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BJ = 'Beijing'\n",
+    "SZ = 'Shenzhen'\n",
+    "GZ = 'Guangzhou'\n",
+    "WH = 'Wuhan'\n",
+    "HLG = 'Heilongjiang'\n",
+    "NY = 'New York City'\n",
+    "CM = 'Chiangmai'\n",
+    "SG = 'Singapore'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = {\n",
+    "    BJ : {SZ, GZ, WH, HLG, NY}, \n",
+    "    GZ : {WH, BJ, CM, SG},\n",
+    "    SZ : {BJ, SG},\n",
+    "    WH : {BJ, GZ},\n",
+    "    HLG : {BJ},\n",
+    "    CM : {GZ},\n",
+    "    NY : {BJ}\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = networkx.Graph(air_route)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "networkx.draw(air_route, with_labels=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search_desitination(graph, start, destination):\n",
+    "    pathes = [[start]]\n",
+    "    seen = set()\n",
+    "    choosen_pathes = []\n",
+    "    while pathes:\n",
+    "        path = pathes.pop(0)\n",
+    "        froniter = path[-1]\n",
+    "        if froniter in seen: continue\n",
+    "        # get new lines\n",
+    "        \n",
+    "        for city in graph[froniter]:\n",
+    "            new_path = path + [city]\n",
+    "            pathes.append(new_path)\n",
+    "            if city == destination: return new_path\n",
+    "        \n",
+    "        #seen.add(city)\n",
+    "    return choosen_pathes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_route(cities): return ' ✈️ -> '.join(cities)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Singapore ✈️ -> Guangzhou ✈️ -> Beijing ✈️ -> Heilongjiang'"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "draw_route(search_desitination(air_route, SG, HLG))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb b/2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb
new file mode 100644
index 0000000..394cf64
--- /dev/null
+++ b/2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb	
@@ -0,0 +1,713 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar = \"\"\"\n",
+    "sentence = adj noun verb adv noun2\n",
+    "adj = adj_single adj_single 的 | null\n",
+    "adj_single = 漂亮  | 蓝色 | 好看\n",
+    "adv = 安静地 | 静静\n",
+    "noun = 猫 | 女人 | 男人\n",
+    "verb = adv 看着 | adv 坐着 \n",
+    "noun2 = 桌子 | 皮球 \n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_grammar(grammar_str, split='='):\n",
+    "    grammar_pattern = {}\n",
+    "    for line in grammar_str.split('\\n'):\n",
+    "        if not line: continue\n",
+    "        stmt, expr = line.split(split)\n",
+    "        grammar_pattern[stmt.strip()] = [e.split() for e in expr.split('|')]\n",
+    "    return grammar_pattern"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate(grammar_pattern, target):\n",
+    "    if target not in grammar_pattern: return target\n",
+    "    \n",
+    "    expr = random.choice(grammar_pattern[target])\n",
+    "    \n",
+    "    tokens = [generate(grammar_pattern, e) for e in expr]\n",
+    "    \n",
+    "    return ''.join([t for t in tokens if t != 'null'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "grammar_pattern = build_grammar(grammar)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'漂亮蓝色的女人安静地坐着静静皮球'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate(grammar_pattern, 'sentence')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A simple solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def adj(): return random.choice('漂亮 | 蓝色 | 好看'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun(): return  random.choice('猫 | 女人 | 男人'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def verb(): return random.choice('看着 | 坐着 '.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def noun2(): return random.choice('桌子 | 皮球'.split('|'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sentence(): return ''.join([adj(), noun(), verb(), noun2()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' 蓝色 猫  坐着  皮球'"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sentence()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Search Based Intelligence"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## BSF 广度搜索 DFS 深度优先搜索"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### BFS Breadth First Search \n",
+    "### DFS Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 219,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph = {\n",
+    "    'A' :'B B B C', \n",
+    "    'B' : 'A C', \n",
+    "    'C' : 'A B D E',\n",
+    "    'D' : 'C',\n",
+    "    'E' : 'C F',\n",
+    "    'F' : 'E'\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 245,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for k in graph:\n",
+    "    graph[k] = set(graph[k].split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 230,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 230,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "'元素' in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 229,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "元素\n",
+      "2\n",
+      "1\n",
+      "100000\n",
+      "9\n",
+      "4\n",
+      "3\n",
+      "8\n",
+      "6\n",
+      "7\n",
+      "5\n",
+      "10\n"
+     ]
+    }
+   ],
+   "source": [
+    "for element in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split()):\n",
+    "    print(element)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 216,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'A': {'B', 'C'},\n",
+       " 'B': {'A', 'C'},\n",
+       " 'C': {'A', 'B', 'D', 'E'},\n",
+       " 'D': {'C'},\n",
+       " 'E': {'C', 'F'},\n",
+       " 'F': {'E'}}"
+      ]
+     },
+     "execution_count": 216,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 234,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "L = [0, 1, 2, 3, 4, 5]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Breadth First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 209,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : A\n",
+      "   I am looking at : C\n",
+      "   I am looking at : B\n",
+      "   I am looking at : D\n",
+      "   I am looking at : E\n",
+      "   I am looking at : F\n"
+     ]
+    }
+   ],
+   "source": [
+    "while need_visited:\n",
+    "    node = need_visited.pop(0)\n",
+    "    if node in seen: continue\n",
+    "    print('   I am looking at : {}'.format(node))\n",
+    "    need_visited += graph[node]\n",
+    "    \n",
+    "    seen.add(node)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Deep First Search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 287,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "graph_long = {\n",
+    "    '1': '2 7',\n",
+    "    '2': '3', \n",
+    "    '3': '4', \n",
+    "    '4': '5', \n",
+    "    '5': '6 10', \n",
+    "    '7': '8',\n",
+    "    '6': '5',\n",
+    "    '8': '9',\n",
+    "    '9': '10', \n",
+    "    '10': '5 11', \n",
+    "    '11': '12',\n",
+    "    '12': '11',\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 288,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for n in graph_long: graph_long[n] = graph_long[n].split()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Repetition is the mother of evil."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 283,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search(graph, concat_func):\n",
+    "    seen = set()\n",
+    "    need_visited = ['1']   \n",
+    "    \n",
+    "    while need_visited:\n",
+    "        node = need_visited.pop(0)\n",
+    "        if node in seen: continue\n",
+    "        print('   I am looking at : {}'.format(node))\n",
+    "        seen.add(node)\n",
+    "        new_discoveried = graph[node]        \n",
+    "        need_visited = concat_func(new_discoveried, need_visited)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 298,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def treat_new_discover_more_important(new_discoveried, need_visited):\n",
+    "    return new_discoveried + need_visited\n",
+    "\n",
+    "def treat_already_discoveried_more_important(new_discoveried, need_visited):\n",
+    "    return need_visited + new_discoveried"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 289,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 290,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "search(graph_long, treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 291,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import partial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 294,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dfs = partial(search, concat_func=treat_new_discover_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 295,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 9\n"
+     ]
+    }
+   ],
+   "source": [
+    "dfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 296,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bfs = partial(search, concat_func=treat_already_discoveried_more_important)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 297,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   I am looking at : 1\n",
+      "   I am looking at : 2\n",
+      "   I am looking at : 7\n",
+      "   I am looking at : 3\n",
+      "   I am looking at : 8\n",
+      "   I am looking at : 4\n",
+      "   I am looking at : 9\n",
+      "   I am looking at : 5\n",
+      "   I am looking at : 10\n",
+      "   I am looking at : 6\n",
+      "   I am looking at : 11\n",
+      "   I am looking at : 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "bfs(graph_long)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mapping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 299,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BJ = 'Beijing'\n",
+    "SZ = 'Shenzhen'\n",
+    "GZ = 'Guangzhou'\n",
+    "WH = 'Wuhan'\n",
+    "HLG = 'Heilongjiang'\n",
+    "NY = 'New York City'\n",
+    "CM = 'Chiangmai'\n",
+    "SG = 'Singapore'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 318,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = {\n",
+    "    BJ : {SZ, GZ, WH, HLG, NY}, \n",
+    "    GZ : {WH, BJ, CM, SG},\n",
+    "    SZ : {BJ, SG},\n",
+    "    WH : {BJ, GZ},\n",
+    "    HLG : {BJ},\n",
+    "    CM : {GZ},\n",
+    "    NY : {BJ}\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 301,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 319,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "air_route = networkx.Graph(air_route)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 304,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 320,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAFCCAYAAADL3BUJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XlYVVX3wPEvIiQICoIKooJaGplTihMqmBOjs6g5QWBp9WqZldabQxO/cihLrV5B0Jw1hxIQZ8UyxcxZ0xIRQaYUFBlk2L8/rl4hB0CBy7A+z+MD955z9l6Xp1jsffZZW08ppRBCCCFEuVFN1wEIIYQQoiBJzkIIIUQ5I8lZCCGEKGckOQshhBDljCRnIYQQopyR5CyEEEKUM5KchRBCiHJGkrMQQghRzkhyFkIIIcoZSc5CCCFEOSPJWQghhChnJDkLIYQQ5YwkZyGEEKKckeQshBBClDOSnIUQQohyRpKzEEIIUc5IchZCCCHKmeq6DkCIMpeYCMHBcOIEpKZC7drQujX4+EDdurqOTggh0FNKKV0HIUSZiIwEf38IC9O8zsy8d8zICJQCV1eYPh0cHHQToxBCIMlZVBXffgtTp0JGhiYJP4yeniZRz50LEyeWXXxCCJGPTGuLyu9uYk5PL/xcpTTnTZ2qeS0JWgihA7IgTFRukZFFT8z53UnQOxctws7OrkRCyc3NxcTEhMuXL5dIe0KIykuSsyg1dnZ21KtXj1u3bmnfCwgIwNnZudT6HD16ND4+Pvfe8PdnX3o6FsDV4jaWkQFr1hTrktjYWHx8fLCysqJWrVrY29sze/ZsMjIy0NfXJy0tjcaNG2tjnTVrVnGjEkJUAZKcRanKzc1lwYIFZdbfggULCAsLY8eOHZCYSGZoKOOBeYB1MdvKUQoOHYK8vCKdn5ycTJcuXcjJyeHQoUPcuHGDbdu2kZSUxMWLF4v7UYQQVZgkZ1Gq3nnnHebOnUtKSsoDj587d44+ffpQp04dWrRowbp16wCIiorCzMyMvDuJcfz48dSrV0973ZgxY/jqq6/ua8/CwoJvvvmGV155hVv/+x+zc3JoBnjfOZ4JTEKTqG2AKcDtO8d2AnbAZ4AVMB40C8TS0rTtf/nllzz//PPExcXd1/fcuXOxsLBg+fLl2NraAmBra8vChQtp2bIlOTk56OnpcenSJRYvXszatWv57LPPMDExYdCgQfj7+zN8+PACbb722mu8/fbbD/npCiEqLSVEKbG1tVU7duxQgwYNUh988IFSSqklS5YoJycnpZRSaWlpqmHDhmrp0qUqOztbHT16VFlYWKjTp08rpZRq1KiROnLkiFJKqebNm6smTZqoM2fOaI8dPXr0oX0PHjxYedrYqDqgLmuWeSkFajqoLqASQSWA6ghq1p1jO0Dp3zknC1T6nfdsa9ZUSin14Ycfqvbt26vk5OQH9tm+fXv10UcfPTSm7OxsBaioqCillFKjRo1SM2fO1B6PiYlRNWvWVKmpqUoppbKyslSdOnXUsWPHCvlJCyEqGxk5i1L30Ucf8c0335CUlFTg/a1bt2JnZ4ePjw/Vq1enXbt2DBkyhPXr1wPg5OTEvn37iI+PB2Do0KHs27ePqKgobty4QZs2bR7a5+LFi9kdH88MoFG+91cCs4C6QD1gBvBDvuPV7xw3BIzuvKfy8pg8eTL79u1j9+7dWFhYPLDPf/75B2vr4k6e39OwYUO6dOnCjz/+CEBoaCg2NjaP/JxCiMpJkrModc8//zweHh783//9X4H3o6OjOXToEGZmZtp/K1eu1CZjJycn9u7dy/79++nRowfOzs7s27ePffv20b17d6pVe/h/vvXr18eyRg1a/uv9OMA232tbIDb/dWgSc37/ZGcTEBDABx98QK1atR7ap4WFBVevFnvZWQHjxo1jxYoVAKxYsYIxY8Y8UXtCiIpJkrMoE7Nnz2bJkiXExt5LhY0aNcLJyYmUlBTtv7S0NL799ltAk5wjIiLYu3cvTk5OdOvWjV9++YV9+/bh5ORUeKeGhmBgUOCtBkB0vteX0dx7vkvvAW1Ympry008/MXr0aH777beHdte7d282bdqEKmJdHz29+3pj8ODB/P7775w+fZqwsDBGjRpVpLaEEJWLJGdRJp5++mmGDx/O119/rX3Pw8OD8+fP88MPP5CdnU12djaRkZGcPXsWgGeeeQYjIyNWrFiBk5MTtWrVon79+vz4449FS84mJve9NRL4CEgGkoCPgdGPakMpMDGhV69eLF++nAEDBnDkyJEHnjp16lSSk5Px8fHRPst85coVJk+ezOnTp+87v379+vet4jY2NmbQoEGMHDkSR0dHGjRoUPjnFEJUOpKcRZmZMWNGgWeeTU1N2b59O2vWrKFBgwZYWVnx3nvvkZWVpT3HyckJCwsLGjVqpH2tlOKFF14ovMNq1aBjR82K6ztmAm2A54HWQCdg+sOu19ODTp007QAuLi4sWbIEDw8Pjh07dt/plpaWHDx4EAAHBwdMTU3p06cPlpaWNG3a9L7z/fz8OH78OObm5gwdOlT7/rhx4zh58qRMaQtRhUltbVG5RUaCs3PxK4QBeUZGVNu/Hzp0KPm4HuHixYu0bt2ahIQEatasWaZ9CyHKBxk5i8rNwUGziYWxcbEuu21gwIdGRvxpalpKgT1YXl4e8+fP56WXXpLELEQVJhtfiMrv7uYVxdiVynDuXJ6uUQMnJye2bNlCp06dSj3M1NRUbGxssLOzIzw8vNT7E0KUXzKtLaqOI0c0+zmHhmqScEbGvWN393N2c9Ps53xnKnvr1q34+PiwfPlyXF1ddRS4EKKqkeQsqp6kJAgOhpMn4fp1MDeHVq3A2xvq1r3v9IMHDzJo0CA+//xzxo0bV+bhCiGqHknOQhTB2bNncXV1ZeLEibz77rsPfEZZCCFKiiRnIYooNjYWFxcXevXqxfz58x9ZoUwIIZ6EJGchiuH69esMGDAAGxsbgoODeeqpp3QdkhCiEpI//YUoBnNzc8LDw8nMzMTDw4ObN2/qOiQhRCUkyVmIYjIyMmLDhg00bdoUZ2dnEhISdB2SEKKSkeQsxGPQ19fnu+++w9PTE0dHR/7++29dhySEqESkCIkQj0lPT49Zs2ZhZWVF9+7d2bp1a9FqfgshRCFkQZgQJWDjxo1MmDCBVatW0bt3b12HI4So4GRaW4gSMHjwYDZs2MCoUaNYs2aNrsMRQlRwMq0tRAnp0aMHO3fuxM3Njfj4eN58801dhySEqKBkWluIEhYdHY2LiwsDBgzA399fqomJ4klM1JSXPXECUlOhdm1o3Rp8fB5YXlZUTpKchSgFycnJeHh40KJFCwICAjAwMNB1SKK8i4zUbMwSFqZ5nZl579jdjVlcXTUbszg46CZGUWYkOQtRSm7duoWXlxdKKdavXy/7M4uH+/bbYm1pyty597ZCFZWSLAgTopTUrFmTzZs3U69ePXr16kVycrKuQxLl0d3EnJ7+6MQMmuPp6Zrzv/22bOITOiHJWYhSZGBgQFBQED179qRbt25ER0frOiRRCoKDg+nWrVvxL4yMvJeYiyM9nVmTJjFa9hivtCQ5C1HK9PT08Pf3Z+LEiTg6OnLixAldhyQe04EDB+jatSu1a9emTp06ODo6EhkZ+fgN+vtrprIfR04OnD79+H2Lck0epRKijEyePJn69evTu3dv1q9fj5OTk65DEsVw48YNPDw8+Pbbb/Hy8uL27dtEREQ8/s5kiYmaxV9PsuwnNhaSkmQVdyUkI2chytCIESNYvXo1w4YNY+PGjboORxTD+fPnARg5ciT6+voYGRnRt29fWrdurT1n6tSpmJub06RJE8LurroGUlNT8fX1xdraGhsbG/773/+Su3QpAMFAN2AqYA40Ae5eeRAwyfevBmCXL6bbenqMdXHB1NSUli1bcuTIEe2xuLg4hgwZQt26dWnSpAlff/219tisWbPw8vJi7NixD7xW6J4kZyHKWK9evdi2bRtvvPEG38qingqjefPm6OvrM27cOMLCwrh+/XqB44cOHaJFixYkJyfz7rvv4uvry92HYby9valevTp//fUXf/zxB9u3bydg0ybt41KHgBZAMvAu4AsooAuQduffdaATMDJfnz/l5jLCzIyUlBT69+/PG2+8AUBeXh6enp60adOG2NhYdu3axVdffUV4ePi9a3/6iREjRtx3rSgnlBBCJ/766y/VrFkzNWPGDJWXl6frcEQRnDlzRo0bN07Z2NgofX195enpqeLj41VQUJBq1qyZ9rxbt24pQF29elXFx8crQ0NDlZ6erj2+atUq5WxhoRSoIFDNNJPbSoG6pcnL6mq+9xSoCaDcQeXeeT0TVC9QysNDKaXU6dOnVY0aNZRSSv3222+qUaNGBWL/7LPPlLe3t1JKqZkzZ6pevXppj+W/VpQPcs9ZCB1p1qwZv/zyi7bc56JFi6heXf6XLM/s7e0JDg4G4Ny5c4wePZo333yTfv36YWVlpT3P2NgYgLS0NK5du0Z2djbW1tba43l5eTSqdm/i8t6VYHzna1q+974H9qIZYeef7rQCMDfX9pmZmUlOTg7R0dHExcVhZmamPTc3N5fu3bvfu/Zf8d69Vv4bLB9kWlsIHapfvz579+7l4sWLDB06lIzHXbkrytyzzz6Lt7c3p06deuR5jRo14qmnniI5OZmUlBRSUlJITU0lbMwYbuvrF9pPBPAhsAWo9e+D+vrQqtUD+2zSpIm2v5SUFG7evEloaGhRP57QMUnOQuiYqakpISEhGBsb07dv3/vuZYry4dy5c8ybN48rV64AEBMTw+rVq+ncufMjr7O2tqZv3768/fbbXLp0iS+//JIWLVrQd/16qhVSdz0G8AKWA80fdIJS4O1939sdO3bE1NSUzz//nIyMDHJzczl16tSTPfYlypQkZyHKAUNDQ1asWEGHDh3o3r27NgGI8sPU1JRDhw7RqVMnatasSefOnXn++eeZN2/eI6/Ly8vD29ubkJAQmjZtynvvvYdSihnz51Pd05NHPUi1C0gAhnJvxXbL/CfY2DzwMSp9fX22bt3KsWPHaNKkCZaWlvj5+ZGamlrcjy10RGprC1GOKKWYO3cuCxcuZNu2bdjb2+s6JPGYLl++TFBQEEFBQdSpUwdfX19eeuklzO/cIwa4tH499YYPx/hxfg0bG8O+fdChQwlGLcoLGTkLUY7o6enxzjvv8PHHH9OzZ08OHjyo65BEMWRlZbF+/XpcXFxo164diYmJbNy4kaNHj/L6668XSMy//fYbnf/zH46NHq1JtMVhbKzZ/EISc6Uly/KEKIfGjh1L3bp16d+/P0FBQXh4eOg6JPEIp0+fJjAwkBUrVtCyZUv8/PzYtGkTRkZGDzw/JCQEHx8fli1bRldXV+jSRXalEgXItLYQ5dihQ4cYMGAA/v7++Pj46Dockc/NmzdZu3YtgYGBREdH4+3tzcsvv8zTTz/9yOuCgoJ4//332bx5M506dbp34MgRTa3t0FBNEs6/cv/ufs5ubpr9nGXEXOlJchainPvzzz9xcXFh/PjxTJ8+Hb1CVviK0qOU4uDBgwQGBrJx40acnJzw8/PDxcWl0OeDlVL4+/uzZMkStm3bRosWLR58YlISBAfDyZNw/brmOeZWrTSrsqWGdpUhyVmICiAuLg5XV1d69OjBV199hX4Rno8VJScxMZEffviBwMBAcnNz8fX1ZezYsQUKeTxKbm4ub775Jvv37ycsLIwGDRqUcsSiopPkLEQFkZKSwsCBA6lXrx4//PDD4++GJIokNzdXUwM7IIBdu3YxcOBAfH196datW7FmL7KyshgzZgxJSUls3ryZ2rVrl2LUorKQ5CxEBZKZmcno0aO5du0amzZtkl/0pSAqKoqlS5cSHByMtbU1vr6+jBgx4rF+1qmpqQwcOBBLS0t++OEHatSoUQoRi8pIHqUSogKpUaMGa9eu5dlnn8XZ2Zn4+Hhdh1QpZGZmsnr1anr37o2DgwM3btwgJCSEw4cP8+qrrz5WYr569SpOTk60bNmSNWvWSGIWxSIjZyEqIKUUn3zyCUFBQYSHh/PMM8/oOqQK6fjx4wQGBrJq1SratWuHr68vAwcOfOJEev78eVxcXPDz85NFfOKxyHPOQlRAenp6fPjhh1hZWdGjRw9+/vlnOsjjNUWSmprK6tWrCQwMJD4+npdffpkjR45gZ2dXIu0fPnyYAQMG8Omnn/Lyyy+XSJui6pGRsxAV3JYtW/Dz82PlypX07dtX1+GUS0opIiIiCAwMZMuWLfTp0wdfX1/69OlToivfw8LCGDt2rBSOEU9MkrMQlcCBAwcYMmQI8+fPZ9SoUboOp9yIj49n2bJlBAYGUr16dfz8/BgzZgx1S+F54eXLl/Puu++yadMmunTpUuLti6pFprWFqAS6devG7t27cXV1JSEhgSlTpug6JJ3JyckhLCyMgIAA9u/fz5AhQ1i2bBmdO3culXu/SinmzJnDokWL2LNnj2xWIkqEjJyFqERiYmLo168fbm5ufPHFF1SrVnUeyLhw4QJLly5l2bJl2NnZ4evri5eXF6ampqXWZ15eHlOmTGHXrl1s27YNGxubUutLVC2SnIWoZK5du4aHhwfNmjVj6dKlGBgY6DqkUpORkcGPP/5IQEAAZ86cYcyYMfj6+vLcc8+Vet9ZWVmMGzeOuLg4tmzZUmDHKSGelCRnISqh9PR0hg8fTnZ2Nhs2bMDExETXIZWoo0ePEhAQwNq1a+nYsSN+fn54enpiaGhYJv3fuHGDwYMHU7t2bVauXCnPMIsSV3XmvISoQoyNjdm0aRM2Nja8+OKLJCUl6TqkJ3b9+nUWLlxIu3btGDx4MFZWVvzxxx+EhYUxZMiQMkvM8fHxODs788wzz7Bu3TpJzKJUSHIWopKqXr06AQEB9O3bF0dHR6KionQdUrHl5eWxe/duRo0aRZMmTfjll1+YM2cOFy9eZMaMGTRu3LhM47lw4QKOjo4MGjSIxYsXywYkotTIam0hKjE9PT0++eQTrKys6NatGyEhIbRt21bXYRUqNjaW4OBgli5dSs2aNfHz8+Prr7/GwsJCZzEdOXIET09PPvroI8aPH6+zOETVIMlZiCrgjTfeoH79+vTt25e1a9fSs2dPXYd0n+zsbLZu3UpgYCC//vorXl5erFmzhg4dOui8/OX27dsZPXo0S5YsYcCAATqNRVQNsiBMiCpkz549DB8+nEWLFjFs2DBdhwPAuXPnCAwM5IcffqB58+b4+voydOhQatasqevQAFi5ciVTpkxh48aNODo66jocUUXIyFmIKqRnz55s374dDw8PEhMTef3113USx61bt1i/fj0BAQH8/fffjB07ln379tGiRQudxPMw8+bNY8GCBezevZuWLVvqOhxRhcjIWYgqKCoqin79+uHl5cXHH39cJtPGSikiIyMJCAhgw4YNODo64ufnh5ubW7l7FjsvL4933nmHbdu2sW3bNho1aqTrkEQVIyNnIaqguyuf3d3duXr1Kt9//z3Vq5fOr4Pk5GRWrFhBYGAgGRkZ+Pr6curUKRo0aFAq/T2p27dv4+PjQ3R0NBEREdSpU0fXIYkqSEbOQlRhaWlpDB06FENDQ9asWYOxsXGJtJuXl8fOnTsJDAwkPDwcT09PfH196dGjR7kuKXrz5k2GDBmCkZERa9aswcjISNchiSpKkrMQVdzt27fx9fXl77//ZuvWrU80Urx8+TJBQUEEBQVhYWGBr68vL730EmZmZiUYcelISEjA3d2dF154gcWLF5faTIIQRVF+/4QVQpQJQ0NDli1bhqOjI926dSMmJqZY12dlZbF+/XpcXFxo164dSUlJbNq0id9//53XXnutQiTmv//+G0dHR9zd3Ut1il+IopL/AoUQVKtWjTlz5mBlZYWjoyNhYWGFrk4+ffo0gYGBrFixgueffx5fX182bdpU4aaCjx49ioeHBzNmzGDChAm6DkcIQJKzECKft99+GysrK1588cUHPtd78+ZN1qxZQ2BgIDExMXh7e3Pw4EGaNWumo4ifzM6dO3nppZf4/vvvGTRokK7DEUJL7jkLIe4THh7O6NGjCQwMxNPTk4MHDxIQEMCmTZtwdnbGz8+Pfv36Vejp39WrV/Pmm2+yYcMGunfvrutwhChAkrMQ4oHCw8MZNmwYNWvWpFatWvj5+TF27Fjq16+v69Ce2Jdffsn8+fMJCwvj+eef13U4Qtyn4v7ZK4Qocbm5uYSHhxMYGMiuXbvo06cPBw8eZNSoUUydOlXnNa6fVF5eHtOmTePnn3/ml19+KfNdrYQoKknOQgiioqJYunQpwcHBNGjQAF9fX4KCgqhVqxbx8fG4uroSHx/PN998U2G3SczOzsbX15e//vqLAwcO6HSHKyEKI9PaQlRRmZmZbNq0icDAQI4fP86oUaPw9fWlVatW951748YNBg4cSJ06dVixYgU1atTQQcSP726xFQMDA9auXVtixVaEKC2SnIWoYo4fP05gYCCrVq3ihRdewNfXl4EDB/LUU0898rqsrCzGjh1LQkICmzdvrhDPLwMkJSXh7u5Oq1at5BlmUWFIchaivEhMhOBgOHECUlOhdm1o3Rp8fKBu3SdqOjU1ldWrVxMQEEBiYiI+Pj74+PhgZ2dXrHby8vKYPHky+/fvJywsrNzWx77r4sWLuLi4MHz4cD766KMKf89cVB2SnIXQtchI8PeHsDDN68zMe8eMjEApcHWF6dPBwaHIzSqliIiIICAggJ9++ok+ffrg5+dH7969n+i+sVIKf39/lixZwrZt28rdNo93/fHHH3h4ePD+++/rbGtMIR6XJGchdOnbb2HqVMjI0CThh9HT0yTquXNh4sRHNnn16lWWLVvG0qVLMTAwwM/Pj9GjR1P3CUff/7Z06VLef/99tmzZQqdOnUq07Se1e/duRowYweLFixk6dKiuwxGi+JQQQjcWL1bK2FgpTVou2j9jY811/5Kdna22bNmi+vfvr8zMzJSfn586ePCgysvLK9WP8PPPPytLS0sVGhpaqv0Ux5o1a1TdunXVnj17dB2KEI9NRs5CPKaVK1eybNkytm/fXvyLIyPB2RnS04t/rbEx7NsHHTpw4cIFli5dyrJly2jSpAm+vr54eXlhYmJS/HYf08GDBxk4cCBz5sxh7NixZdbvg3z99dd88cUXhISE0KZNG53GIsSTkOQsRCEOHDjAu+++y+nTp9HX18fe3p6vvvoKh2Lc/73P4MGwefOjp7IfQunpcbl9e8bVrMnZs2cZM2YMvr6+2NvbP348T+js2bO4uLjwxhtv6KRYiVKK999/n40bNxIeHl7shW5ClDeSnIV4hBs3btC4cWO+/fZbvLy8uH37NhEREVhZWdG6devHazQxEWxtCy78Kqbb1aoRvmQJ/UaPxtDQsMjX5eTklNqjRFeuXMHFxYW+ffsyd+5cqlUrmx1ps7OzGT9+POfOnWPr1q1YWlqWSb9ClCbZz1mIRzh//jwAI0eORF9fHyMjI/r27Uvr1q0JDg6mW7du2nP19PT47rvveOaZZzAzM+P111/n7t++ubm5vP3221haWtLk2WdZmJODHpBz59ogwB4wBZoC3+eLYS/QEPgMsATsgPX6+nj+8w+GhoakpqYyduxY6tati62tLZ988gl5eXkABAcH4+joyFtvvYWFhQWzZs0CNIu57O3tMTc3p1+/fkRHRz/xz6phw4ZEREQQGRnJ6NGjuX379hO3WZhbt24xcOBAkpKS2LVrlyRmUWlIchbiEZo3b46+vj7jxo0jLCyM69evP/L8rVu3EhkZyYkTJ1i3bh3h4eEALFmyhLCwMI4dO8bRXr3YnJNT4Lp6wFbgBppE/RZwNN/xeCAZiAWWAa9kZ/PngQMA/Oc//yE1NZWLFy+yb98+li9fTlBQkPbaQ4cO0bRpUxISEvjggw/YsmULn332GRs3biQpKYnu3bszcuTIJ/o53WVubs727dtJT0/H3d2dmzdvlki7D5KcnEyvXr2oV68emzdvpmbNmqXWlxBlTndr0YSoGM6cOaPGjRunbGxslL6+vvL09FTx8fEqKChIOTo6as8DVEREhPb1sGHDlL+/v1JKqZ49e6rvvvtOc8DDQ+0ABajsh6zKHgDqqzvf7wGlDyot3/FhoD5q3lzl5OQoAwMDdfr0aW2/3333nXJyclJKKRUUFKQaNWpU4PO4uLiogIAA7evc3FxlZGSkLl26VGI/s+zsbPXKK6+o9u3bq/j4+BJr966oqCjVokULNX369FJfkS6ELsjIWYhC2NvbExwczJUrVzh16hRxcXG8+eabDzzXyspK+72xsTFpaWkAxMXF0ahRI82B2rVp9K/rwoDOQB3ADAhFM1K+yxzIPy60BeLQjB6zs7OxtbW9d8zWltjYWO1rbb93REdHM3nyZMzMzDAzM6NOnToopQpc86SqV6/Od999h7u7O46Ojvz9998l1vbx48fp1q0br7/+Op999plU/RKVkiRnIYrh2Wefxdvbm1OnThXrOmtra65cuaJ50bo1MQYG2mNZwBBgKpAApABuaIbWd10HbuV7fVlfnwZ2dlhaWmJgYFDgnvHly5exsbHRvv538mrUqBHff/89KSkp2n8ZGRl07dq1WJ+pMHp6esyePZupU6fSvXt3jh49+uATExPhiy9g9Gjw9NR8/eILSEq679S9e/fSp08f5s+fz3/+858SjVeI8kSSsxCPcO7cOebNm6dNrDExMaxevZrOnTsXqx0vLy8WLFhAbGwsKYMG8XlurvbYbTQJui6aPVzDgAc9OT3zzrkRwNbcXIbNnIm+vj5eXl588MEH3Lx5k+joaObPn8/o0aMfGsuECRPw9/fn9OnTgKbu9vr164v1eYpjwoQJLFy4EBcXF3bt2nXvQGSk5pEyW1uYORNWroStWzVfZ82Cxo01xyMjAdiwYQNeXl6sWbMGLy+vUotXiPJAtmcR4hFMTU05dOgQ8+fPJyUlBTMzMzw8PJgzZw4bN24scjvjx4/n/PnztG7dmlq1ajGpZUv2njyJPpoV2l8DXmiStCfQ/1/XW6GZ2m4AGAPfdejAs3dGut988w3/+c9/aNq0KTVq1GCM2QEtAAAgAElEQVT8+PG8/PLLD41l0KBBpKWlMWLECKKjo6lduzZ9+vRh2LBhRf/BFNPgwYOxsLBg2LBhfP3114y4fv3RZUszMjRfN2+G8HD2enoyOSKC7du307Zt21KLU4jyQp5zFkIHwhYsYMJbbxFdhP/99gKjgSt338hXIayiOXHiBKt69ODj9HQMsrOLfF26nh7ps2dj+eGHpRidEOWHTGsLUQYyMjIIDQ0lJyeH2NhYZq9ezSBnZ02iLYZ04LdhwypkYgZonZXFZ7dvY5CdTQSQfz+rlmj+EAHNM91++Y4ZK4Xl//0fHDlSRpEKoVuSnIUoA0opZs6cibm5Oe3atcPe3p6PNm/W7DJlbKzZdaowxsakzpiB1+7dLFq0qPSDLiI7OzuMjIwwMTHB3Nwcd3d3YmJiHnyyvz/V7lRG6w78me/QacD5zvfvAwH/vjYjQ7O1phBVgExrC6FrR45okk5oqCZJ373fCvf2c3Zz0+zn3KEDly5dok+fPvj4+DB9+nSdP0pkZ2dHQEAAvXv3JjMzk9dee41r166xefPmgieWQNlSatSAy5ehhLe/FKK8kZGzELrWoQP8+KMm6cyeDWPGgIeH5uvs2Zr3f/xRO5VtZ2fH/v37Wb16Ne+99x7l6e/rGjVqMHToUM6cOQNAVlYWU6dOpXHjxtRv1owJ2dnc/dNjL5qypHfZATvvfD8LzX12gEuAHprKaI2zsrC0s+PTTz/VXpeRkcG4ceMwNzfH3t6eL774goYN87csRMUjq7WFKC/q1oV33inSqdbW1uzbtw9XV1cmTJjA4sWL0dfXL+UAC5eens7atWu1j5pNmzaNv//+m2PHjmEwcSIvrVvHR8DjTE4fAP5UivM9e9Lxo48YPHgw9vb2zJ49m0uXLnHx4kVu3bqFm5tbSX4kIXRCRs5CVFB16tRh586dXLhwgdGjR5NdjNXPJW3gwIGYmZlRu3ZtduzYwZtvvklMTIy2Sti6deuI++MP3gfWPGYfMwEjoI2eHm3atOH48eMArFu3jvfffx9zc3MaNmzIpEmTSuhTCaE7MnIWogIzNTUlNDQULy8vBg0axPr16zEyMiq1/m7fvk18fDxxcXFcvXqVq1evkpKSQrdu3ahWrRqxsbFcunSJ9u3bU7duXTIzM3njjTeoVq0ahjk5VANyC+3lwbSFUc3NMb5588GlUbm/XKkQFZEkZyEquBo1avDjjz/i7e2Nq6srP/30E7Vq1SpWG5mZmdpke/XqVW3yzZ+E4+LiuHHjBvXq1cPa2poGDRpgbW0NaOqP9+rVS/t+69atWbhwId7e3ly4cEFTTvSLLzSVwJ5gQViGnh5hf/3FtbQ07ZaUd0ujPvfccwAPXykuRAUiq7WFqCTy8vJ4/fXX+f333wkLC8PCwoL09PQHJtl/f3/r1i2srKywtrYukHj//b2lpeV997bzr9ZWSvHTTz8xZMgQjh8/zv/+9z+uXr3KwoULqQfENm7Mqaws+nF/cRU7NI9P9UazIOwvYAWaBWFNgGygmqEhC999lxnffENmZia9evXi9u3bpKWlERoaqt2qMjk5+V4tcyEqIBk5C1EB3bx584HJNjU1lYSEBBo0aIChoSHZ2dkPTLb29vYF3q9Tpw7Vqj3+EhRPT0/09fXR09PD1taWZcuW0bJlSz7//HM++ugjOnfuTHJyMjYGBky8k5wfRzUPDyZ9/DEbIyIYNGgQ1tbWbN68mYiICCwtLTEzM2PAgAHs27fvsT+LEOWBjJyFKCeUUty4caPQUe7Vq1fJzc194Oj27teQkBA2b97Mrl27aNq0qa4/2j2RkeDsDOnp9x1qjGak3ONh1z6ibGleXh5HjhwhNDSUoKAgYmNjGThwIO7u7ri6uhbYylOIikCSsxClTCnF9evXC024cXFx6OvrP3Ja+e73tWrVKrT4yOLFi/H39yc8PFx7P7Zc+PZbzaYX+RJ0Eprk/Oedr/cxNtZUU5s48b5DV69e5eLFi3Tp0oULFy7g7u7OuHHjaNSoEaGhoezYsYNmzZrh5uaGu7s7HTp0KBePnQnxKJKchXhMSin++eefIo10a9SoUej9XGtra0xNTUs0xhUrVjB16lS2bt1Kh/JUj/tugs7IIFIp+gCvAF/8+zw9PU2VtIckZoDo6Gjc3d2JiorCzMyMESNG4O/vj6GhIQDZ2dn8+uuvhISEEBoaSmJiIi4uLri5udGvXz/Mzc1L85MK8VgkOQvxL3l5eSQlJRU6yk1ISKBmzZqFjnKtra0xLuYGFyVpy5YtjB8/ng0bNtCjx0MnjcveI8qWZhsYoHJzMRw4UFu2tKRcunSJsLAwQkJC2L9/P23atMHd3R03NzdatWql83KoQoAkZ1GF5OTkkJiYWOgoNyEhATMzs0cm3AYNGmBlZUWNGjV0/bGKZNeuXYwcOZLg4ODyV0ErKQmCg+HkSbh+HczNudW0Ka3nz+doTAy1a9cuta4zMjLYu3cvoaGhhISEkJ2drZ3+fvHFFzExMSm1voV4FEnOosLLzs4mISHhkc/nXr16leTkZOrUqVPoSNfKyko7JVqZ/PbbbwwYMIBvvvkGLy8vXYdTqCFDhtCvXz9eeeWVMulPKcWff/6pnf4+fPgwXbt21Sbrp59+ukziEAIkOYtyLCsri/j4+EJHuteuXaNu3bqFLqSqV68eBgYGuv5YOnXixAlcXV2ZPXs2fn5+hV+gQ1u3buXTTz/l4MGDOun/xo0b7Ny5U5usTU1NtdPfPXr04KmnntJJXKJqkOQsytzdalSFLaS6W43q348J/fv7evXqyerbYrhw4QJ9+vRh0qRJTJkyRdfhPFROTg6NGjVi9+7d2Nvb6zSWvLw8jh8/rk3Up0+fpmfPntpHtWQXLFHSJDn/W2Ki5v7XiROQmgq1a0Pr1uDjI3vIFuLWrVtFelwoPT1dW43qUSNdS0vLJyqMIR4uJiaGPn364OXlxezZs8vtIqh3330XPT09Pv/8c12HUkBycjLh4eGEhIQQHh5Oo0aNtNPfnTp1onp1qe8knowk57siIzUrR8PCNK/z1/+9u+G9q6tm5aiDg25i1JG71agelHDzv5eVlVWklcsWFhblNhlUJYmJifTr148ePXrw5Zdflss/hM6ePUuvXr24fPlyuU14OTk5HDp0SLuoLCYmhr59++Lu7o6LiwuWlpa6DlFUQJKcocAzlzzqx1GEZy4rCqUUqampRRrpKqWKVBjDzMxMkm4Fk5KSgoeHB8888wxLliwplwmwc+fOfPjhh7i7u+s6lCK5cuUKYWFhhIaGsnv3bp577jntqLpdu3by/4gokkqTnD/77DMuXrxIQEAAly5dokmTJmRnZxf+y+YB1YoKdadaUcTzz+Pn58eff/4JQMuWLVm0aBHOzs6P/0Ge0N1qVEUpjFG9evVCR7kNGjTA1NRUfqFUYrdu3WLw4MGYmJiwatWqcrfQ6fvvv2fHjh1s2LBB16EUW1ZWFhEREdp71Tdv3sTV1RV3d3d69+5d7N3DRNVRaZJzfkVOzo+o81uoR9T5LQ15eXn8888/hY5y4+PjtdWoHlV72draWp7hFFpZWVmMGjWKmzdvsnHjRmrWrKnrkLRSU1OxtbXlr7/+qvBTxH/99Zd2+vvXX3/FwcFBuwL82WeflT+ChVbVTs6DB8PmzY+eyn4YPT0YNAh+/PHxA+VeNarCRroJCQmYmJgUqQSkLqtRiYorJyeH8ePHc/78eUJCQjAzM9N1SFqjRo2iU6dOTJo0SdehlJhbt26xa9cubbI2MDDQTn87OztjZGSk6xCFLqkKyNLSUtnZ2akFCxZo35s5c6YaNWqUUkqpqKgoBajs7GyllFKxsbHK09NTmZubq2bNmqn//e9/SiUkKFWjhpoJahioMaBMQD0HKlKTrpUC9TuotneODQXlBeqDO8f2GBgoG2trbQy2trZqx44dSimlfvnlF/XCCy8oExMTZW5urpydndV///tf9corryhPT08FqNq1aytA6enpKQsLC9W3b1/l7e2tpk2bpnr27KlMTU2VtbW1mjVrVoHPI0Rpyc3NVZMmTVJt27ZVCQkJug5Ha8eOHapt27a6DqPU5OXlqRMnTih/f3/VvXt3ZWpqqtzd3dWiRYvUpUuXdB2e0IHytzyzCGJjY9m1axdfffUV4eHhhZ4/YsQIGjZsSFxcHBs2bOD9999n93//qz3+EzACSAH6A2/cef82MAjwBq4BI4FN+drNVYrb168zY8YMxo8fT2JiIhMmTMDa2poePXoQFRVFs2bNaNOmDX/88QeHDh2ibdu2vPzyywC0b9+ehIQELl26hJ6eHm+99RZBQUHY2toSHx/PmTNnOH36NBEREU/8MxOiKKpVq8ZXX31F//796d69OzExMboOCYCePXvyzz//cOzYMV2HUir09PRo1aoV06ZNY//+/URHRzNmzBh+++03OnToQMuWLXn33XfZu3cv2dnZug5XlIEKmZwNDQ1p2rQp48ePZ82aNY88NyYmhl9++YXPP/+cGjVq0LZtW/z8/Fi+a5f2calugBugD4wBjt+59jcgB5gEGACDgY752tbPyYHsbKpVq0aHDh0wNTXlrbfe4siRI2RmZnLt2jWOHTvGnj17mDVrFjVr1mTixIkMHDgQgNmzZ1OvXj0aN25Mz549tb941q1bx+TJk2nYsCHm5uZMmzathH5yQhROT0+P2bNn8+qrr9K9e3cuXLig65DQ19dn3LhxBAUF6TqUMmFubs7w4cNZvnw58fHxLF26FCMjI6ZOnUq9evUYNmwYwcHBxMfH6zpUUUoqZHI2MzPDzMyMzz77jISEhEeeGxcXR506dQpsxWdra0vsjRva1/m3YTcGMtEk5TjABsi/RKPRv9o3NDBg1qxZvPrqqxgZGdGiRQtsbGy4ePEiHh4eWFlZUatWLd5//32Sk5MLXJt/A3hjY2PS0tK0MTdqdK+n/N8LUVamTJnCf//7X5ydnTlx4oSuw8Hb25tVq1Zx+/ZtXYdSpvT19enUqROzZ8/myJEjnD17Fjc3N0JCQrC3t8fBwYGZM2dy+PBh8vLydB2uKCEVMjmnpKSQkpLCzZs3CQ0NfeS5DRo04Nq1a9y8eVP73uXLl7EpwiMM1kAskH+52H2TfA8p3DBx4kSeffZZLly4wI0bN/jss89QRVx4Zm1tzZUrV+71WU6mFkXV4+fnx5dffkmfPn347bffdBpLs2bNeO655/j55591GoeuWVlZ4ePjw/r160lMTGTOnDmkp6fj4+ODlZUV48aNY+3atVy/fl3XoYonUCGTc0ZGBrm5uZw6dYrIyMhHntuoUSO6du3K9OnTyczM5MSJEwQGBjL6xRehkO3+uqCZ6l6IZiS9BTic/wRDQ3jIRgo3b96kVq1amJiYcO7cOb799tsifz4vLy8WLFhAbGwsKSkp5a50oahavLy8CAoKon///uzcuVOnsfj4+FSZqe2iMDAwwNnZmTlz5nD69GkOHz5Mp06dWL58OY0bN6ZHjx58/vnnnDx5ssiDA1E+VMjk3KRJEywtLfHz8yM1NbXQ81evXs2lS5do0KABgwYNYvbs2fT+9NNCrzMENgKBgBmwAvAAtCUalNI87/wAc+fOZdWqVZiamjJ+/HiGDx9epM8GMH78ePr27Uvr1q1p164dbm5uVK9eXTZ3EDrj5ubGhg0beOmll9iyZYvO4hg6dCgHDhzg6tWrOouhPLOzs+O1114jJCSExMREpk2bRkxMDP3798fW1pYJEybw888/c+vWLV2HKgpRKZ9zLrLHeM65EzAB8NHTY7ejI36xsVy8eLHUQgQICwtjwoQJREdHl2o/QhTm999/x8PDgzlz5jB69GidxPDyyy/z7LPP8u677+qk/4pIKcW5c+e0lcoiIyNxdHTUPlfdrFkzXYco/qVCjpxLzPTpmlrZj7APiEczrb0MOAG4ABgZcapTJ5o0aVLiYWVkZBAaGkpOTg6xsbHMnj2bQYMGlXg/QhRX+/bt2bVrF9OnT2fx4sU6ieHu1HZVHlcUl56eHvb29kydOpXdu3cTGxvL+PHjOX78ON26daNFixZMmTKFnTt3kpWVpetwBVV95AyF1tb+H/AhcAtoCvgD7sbGTO7YkZ8uXWLZsmX06NGjRENKT0/HycmJc+fOYWRkhLu7OwsWLJA6vKLciIqKonfv3vj5+TF9+vQy7VspRfPmzfnhhx/o3LlzmfZdGeXl5XHs2DHtqPrMmTO8+OKLuLm54ebmho2Nja5DrJIkOUOV3JVKiCcVFxdH37598fDwwN/fv0zrQn/66adcvnyZ77//vsz6rCqSkpIK7FXduHFj3N3dtXtVy9qXsiHJ+a4jRzT7OYeGapJwRsa9Y3f3c3Zz00yFl9FmF0KUd//88w8uLi60b9+eRYsWldkv7piYGNq0acOVK1eklnwpysnJ4bffftPW/46NjaVfv364ubnh4uKChYWFrkOstCQ5/1tSEgQHw8mTcP06mJtDq1bg7Q116+o6OiHKnRs3btC/f39sbGwIDg7G4CGPF5a0fv36MXbsWEaNGlUm/QnNXtWhoaGEhoayZ88eWrZsqd1Vq23btrKrVgmS5CyEeGIZGRkMGzYMPT091q1bVyY7Kq1Zs4aAgACdP3tdVWVlZbF//37tveq0tDTtfeo+ffoUqMooik+SsxCiRGRnZzN27FgSEhLYsmVLqf9yzszMxMbGhqNHj2Jra1uqfYnCXbhwQTv9ffDgQTp27KgdVbdo0UJG1cUkyVkIUWJyc3N57bXX+OOPPwgLCyv1e5KvvfYa1tbWfPjhh6XajyietLQ07V7VoaGhGBoaahO1s7MzNQqpzigkOQshSphSivfee4+wsDC2b9+OtbV1qfUVGRnJiBEjuHDhAtUeUude6JZSipMnT2qnv48fP46Tk5O2AErjxo11HWK5JMlZCFHilFL4+/uzdOlSduzYUSrFeu7206pVKxYtWoSTk1Op9CFK1rVr19i+fTshISFs27aN+vXra0fVXbt2LbMFheWdJGchRKlZuHAhn3/+Odu3b8fe3r5U+pg3bx4nT54kODi4VNoXpSc3N5fIyEjtveqLFy/Sp08f3N3dcXFxoX79+qXXeWKi5smcEycgNRVq14bWrcHHp1w8mSPJWQhRqpYvX857773H1q1bad++fYm3n5CQQIsWLYiJiZEVwhXc1atX2bZtGyEhIezcuZPmzZtrp7/bt29fMrcuIiM1NS3CwjSvMzPvHbtb08LVVVPTwsHhyft7TJKchRClbtOmTbz66qv8+OOPdO/evcTbHzBgAAMGDODll18u8baFbty+fZtffvlFO6r+559/cHV1xc3Njb59+2JmZlb8RitQNUhJzkKIMrFz505GjhzJ8uXLcXV1LdG2N2/ezLx584iIiCjRdkX5ERUVpU3UERERvPDCC9p71S1btiz8Ua1C9lF4IGNjnSVoSc5CiDJz8OBBBg4cyMKFCxk2bFiJtZudnU3Dhg05cOAAzzzzTIm1K8qn9PR09uzZo03WSint9HfPnj2pWbNmwQsiI8HZ+YGJORgIAA48rDNjY9i3r8zLNsuzB0KIMtOlSxe2b9/O5MmTWbp0aYm1a2BgwKhRo2RRWBWxYMECFi5cyKJFi4iKiiIsLIwNGzYwbtw4rKyscHV15ZtvvsHOzo41a9Zo7jHn3y+hODIyNNeXMUnOQogy1aZNG/bu3cvs2bP58ssvS6xdHx8fli1bRm5ubom1KcqnHj168Ouvv5Kbm4uenh7m5ubUrFkTAwMDoqOj8fX15ZdffiE6Opq506aR/dNPj77H/ChKaTZESkoq2Q9RCEnOQogy17x5cyIiIvjuu++YNWsWJXF3rVWrVlhZWUmt7SrAwcGB7Oxsjh07BkBERAQ9e/akRYsWREVFMXToUAYPHkyzZs34xtkZw9xccvJd74xmKju/qYA50AQIy/d+EGCflYVpw4Y0bdq0wDale/fupWHDhsybN4969ephbW1NUFBQiXxGSc5CCJ1o3Lgx+/fvZ/Pmzbz11lvk5eU9cZs+Pj4l9stRlF+GhoZ06tSJ/fv3A7B//366d+9Ot27dCrzXo0cPrFNSCm3vENACSAbeBXyBu38u1gO2KsUNLy+CgoJ46623OHr0qPba+Ph4UlNTiY2NJTAwkNdff53r168/8WeU5CyE0Jn69euzZ88eDh8+jJ+fHzk5OYVf9AgjR45k27ZtJfLLUZRvTk5O2kQcERFB9+7d6d69e4H3nJyc4ObNQtuyBcYD+sA44CqQcOeYO9AM0EtJwcnJib59+xZ4KsDAwIAZM2ZgYGCAm5sbJiYm/Pnnn0/8+SQ5CyF0ytzcnO3btxMTE8OIESPIysp67Lbq1KlDv379WL16dQlGKMqjHj16cODAAa5du0ZSUhLPPPMMXbt25ddff+XatWucOnUKGxsbLhdh5GyV73vjO1/T7nwNAzoDdbZvx8zMjNDQUJKTk7XnW1hYUL169XvXGxuTlpbGk5LkLITQORMTE7Zu3UpeXh4DBgzg1q1bj92WTG1XDV26dCE1NZUlS5bg6OjIlStX2LVrFwAdO3ZEKcX48eM5dWeVdv6HqOKL2EcWMASYamhIwuzZpKSk4ObmViJrJAojyVkIUS489dRTrFu3jvr169OvXz9SU1Mfq50+ffoQFxfHqVOnSjhCUV5cv36dAwcOYGVlxcyZM9m+fTvt2rUjICAAW1tb/vnnHwYNGkRUVBSv7d2LDbACyAWWAn8XsZ/baBJ0XaD6yy9rd1orC5KchRDlRvXq1QkKCqJdu3b07NmTxMTEYrehr6/P2LFjZfRcSWRkZHDw4EEWLFjA6NGjad68OY0bN+aTTz7B2tqarKwsVq5cSWJiIiEhIUydOpWUlBT69u2raaBePZZ06cIcwAI4DXQtYt+mwNeAl54e5s2bs2rVKvr3718aH/M+UiFMCFHuKKWYMWMG69evZ+fOnTRs2LBY158/f57u3btz5coV2YKwAsnNzeXMmTMcPnyYyMhIDh8+zLlz57C3t8fBwYGOHTvi4OCAvb19gfu8hXpEhbBC6ahCWDE+nRBClA09PT0+/vhjateuTffu3dm+fXuxynI2b96cp59+mtDQUAYMGFCKkYrHpZTi0qVLHD58WJuM//jjDxo0aKBNxN7e3rRp0wYjI6Mn68zBQVMj+3Fra5dxYgYZOQshyrklS5Ywa9Ystm3bRqtWrYp8XUBAAFu3bmXz5s2lGJ0oqsTERCIjI7Uj4sOHD2NoaEjHjh21/9q3b4+5uXnpBSG7UgkhRMlZs2YNkydPZsuWLXTu3LlI19y4cYPGjRtz/vx56tWrV8oRivzS0tL4/fffCyTilJQUHBwcCkxP29jYlH1wR45oamWHhmqScP6a23f3c3Zz0+znrIMR812SnIUQFUJISAje3t6sXbuWF198sUjXjB07lrZt2zJlypRSjq7qun37NidPnixwnzgqKopWrVppR8QODg4888wzVKtWjtYgJyVBcDCcPAnXr4O5ObRqBd7eULeurqOT5CyEqDj27t2Ll5cXS5YsKdK95D179jBp0iROnDhR+H6/olB5eXlcuHChQCI+efIkTZo0KZCIW7VqhaGhoa7DrdAkOQshKpTIyEg8PT2ZN28eo0aNeuS5eXl5NGvWjPXr19NBh1OUFVVsbGyBRHzkyBHMzc0LTE2/8MILmJqa6jrUSkeSsxCiwjl9+jT9+vXjgw8+YGIhC3Zmz55NYmIiixYtKqPoKqbr169z5MgRbSKOjIzk9u3bBRKxg4OD3L8vI5KchRAV0sWLF+nduzevvPIK06ZNe+h5ly5don379sTGxlKjRo0yjLD8ysjI4NixYwUScVxcHO3atdMm4o4dO2JnZye3A3REkrMQosKKjY2lb9++eHp64u/v/9BE0qtXL1555RWGDx9exhHq3t3CHvkT8dmzZ3n22WcLJOJiF/YQpUqSsxCiQktOTsbFxQUHBwcWLVr0wBXBK1asYMWKFWzbtk0HEZadu4U98ifio0ePYm1tXSARt23b9skLe4hSJclZCFHh3bhxA09PTxo2bEhwcPB9JTvT09Np2LAhJ06cKHYp0PIsKSmpQCI+fPgwBgYGBRJxhw4dSrewhygVkpyFEJVCRkYGQ4cOpXr16qxdu/a++8uvvPIKTZo0Yfr06TqK8MmkpaVx9OjRAon4+vXrdOjQQZuIO3bsqJvCHqLESXIWQlQat2/fZsyYMSQlJbFly5YCj/gcPHiQcePG8eeff5b7RU7Z2dn3Ffb4+++/ad26dYFRcbkr7CFKjCRnIUSlkpuby4QJEzh58iShoaHUqVMH0NyPtbe3Z/ncuXQ8cwZOnIDUVKhdG1q3Bh8fnVSGysvL46+//iqQiE+cOKEt7HE3EUthj6pFkrMQotJRSvHOO+8QHh7O9u3bsba2hshIzvv4YHfuHIYGBpCZee+CuzWVXV01NZUdHEottri4uPsKe9SuXbvA1LQU9hCSnIUQlZJSik8//ZRly5ZxcNw4LP39URkZ6JXhbkQpKSkFCnscPnyYrKysAiNiKewhHkSSsxCiUtvt5UXnDRswLs6vurv7+P4rQevp6XHhwgWefvrp+y7JzMzk2LFjBUbFsbGxvPDCCwUScZMmTcr9PW+he5KchRA6s2bNGr788ktOnTpFzZo1adKkCePGjWPixIklk8AiI8HZGdLTi3+tsTHs21dg28C7yblJkyacPXu2QCK+W9gjfyJ+7rnnpLCHeCzyX40QQifmzZvHF198waJFi+jXrx8mJiYcO3aMuXPn4uvry1NPPfXknfj7F9yvtzgyMsDfH7VhA9HR0Rw+fBiAl156ibNnz2Jtba1NxGPGjKFt27YYGxs/ecxCALIGXwhR5lJTU5kxYwaLFy9m6NChmJqaoqenR7t27Vi5ciVPPfUUzs7OBAQEaK8JDg6mW7du2teTJ6nXw8QAAA9WSURBVE+mUaNG1KpVi/bt2xMREaE9NmvWLLwGDGDsli2YKkVL4Ei+/o8C7QBTYBgwHPjvnWOegAlgohQmGzdSrVo12rRpw8qVKwHo3Lkz9erVIzExETMzMyZNmkTXrl2pUaMGn3zyCba2ttSrV4+xY8eSmpoKaLa6/HfxEzs7O3bu3FkyP1BR6UhyFkKUuYMHD5KVlVWkPZkfxsHBgWPHjnHt2jVeeuklhg0bRma+Fdg/hYYyQl+fFKA/8Mad928DgwBv4BowEtiUr92fgbQ7/9ZUr46ViQknT55ky5YtgGbDjd9//50TJ06wbt06wsPDAc0fD8HBwezZs4eLFy+SlpbGG2+8gRCPQ5KzEKLMJScnY2lpWeB+bNeuXTEzM8PIyIj9+/cX2sbo0aOxsLCgevXqvP3222RlZfHnn39qj3eztMQtOxt9YAxw/M77vwE5wCTAABgMdHxA++eBl3NyWO/oSOPGjbXvT5s2DTMzMxo3bkzPnj05duwYACtXrmTKlCk0bdoUExMT/P39WbNmDTk5OcX62QgBkpyFEDpgYWFBcnJygcT166+/kpKSgoWFBXl5ef/f3t3HVlXneRx/94mWQp+CpS1QLw5IbBB10zZriSKTJUvpUlZMWJUHHQyuI5qogZCVNT4wxBmQxUwUnWQ1YeOGNcQxiDwokYQZSCBQVkBlQGq0zHYstlBKsRRaZP+4tlM7QFt623Ppfb/+Orfnd879tmnyye97zvmdLs+xatUqCgoKyMjIIDMzk4aGBurq6tr35yYktG+nAs2EQ/kvwEig4+1m+Z3O3QD8M7AcuKvTOt25ubl/PW9qKmfPngXCzy+HQqH2faFQiNbWVk6cONHl7yJ1ZjhL6nclJSUkJye3t4ovZ8iQITR1uMu6pqamfXvnzp2sXLmS9evXU19fz+nTp8nIyOAnD590CtU2eUA10PExlT932P4BmA38HPhXgG6+NGLEiBFUVVW1fz5+/DiJiYnk5OT8ze9y8eJFamtru3VexSbDWVK/y8zM5IUXXmDhwoW89957NDY28sMPP3DgwAG+//57AO644w7ef/99mpqaqKys5O23324/vrGxkcTERLKzs2ltbWXZsmWcOXPmp1+SlQWdXn4BUAIkAK8Tnkl/AOztsP/fge+B30J4QZIJE7r1Oz344IO8+uqrfP3115w9e5alS5dy//33k5iYyLhx42hubmbz5s20tLSwfPlyzp8/390/l2KQ4SwpEEuWLGH16tWsXLmSnJwccnJyeOyxx1ixYgUTJ07kmWeeYdCgQeTk5PDwww8zZ86c9mOnTp1KaWkp48aNIxQKkZKSQn5+p+b0z3522e8dBLwPvA1kAv8NTAfaHtz6H8LXpbOAoefOMfTFF9vv1L6aRx55hHnz5jFp0iRuuukmUlJSeO211wDIyMjgjTfeYMGCBYwcOZIhQ4YMqFdXKvJchETSwHXffbBhQ3jd7Kv4e+CXwPyOP4yLg5kz4fe/78MCpctz5ixp4Hr22XBrupM/ADWE29r/BRwCSjsPGjw4fLwUAMNZ0sBVXBxeI7vTyl1HgdsJt7X/A3iP8I1i7drW1u6wdKfUn2xrSxr43nwTFi8OL8nZj2+lkq6V4SwpNlRUhNfa3rIlHMId1txuAganpBBXVhZuZTtjVsAMZ0mxpbYW1q6Fzz6D+nrIymLNH//ILb/5Df/wwANBVycBhrMksWLFCo4fP86aNWuCLkUCDGdJ4vDhw5SWllJVVRWZ90hLveTd2pJiXkFBAYMGDeLgwYNdD5b6geEsKebFxcVRXl7Ohx9+GHQpEmA4SxIAM2bMMJwVNbzmLElAS0sLOTk5fP7554wYMSLochTjnDlLEpCUlMTUqVPZvHlz0KVIhrMktZkxYwYbN24MugzJtrYktamvrycUClFTU0Nqp/W4pf7kzFmSfpSVlUVhYSHbt28PuhTFOMNZkjqwta1oYFtbkjqorKzk7rvvprq6mvh45y8Khv95ktTB2LFjycrKoqKiIuhSFMMMZ0nqxNXCFDTDWZI6MZwVNK85S1InFy9eJDc3l4qKCkKhUNDlKAY5c5akThISEigrK2PTpk1Bl6IYZThL0mX4SJWCZFtbki6jsbGRkSNHUl1dTVpaWtDlKMY4c5aky0hLS6OkpIRt27YFXYpikOEsSVdga1tBsa0tSVdQVVVFUVERNTU1JCQkBF2OYogzZ0m6glAoxIgRI9izZ0/QpSjGGM6SdBW2thUEw1mSrsLVwhQEw1mSrqKoqIj6+noqKyuDLkUxxHCWpKuIj49n+vTpzp7VrwxnSeqCrW31Nx+lkqQuNDU1kZubS1VVFVlZWUGXoxjgzFmSupCamso999zDRx99FHQpihGGsyR1g49UqT/Z1pakbvj2228ZP348J06cICkpKehyNMA5c5akbsjLy2PMmDHs2rUr6FIUAwxnSeomW9vqL4azJHVT2yNVXg1UXzOcJambbr/9di5cuMCRI0eCLkUDnOEsSd0UFxdHeXm5rW31OcNZknrA1cLUH3yUSpJ64Pz58wwfPpzKykqys7ODLkcDlDNnSeqB5ORkpkyZwpYtW4IuRQOY4SxJPWRrW33NtrYk9VBtbS1jx47lu+++Izk5OehyNAA5c5akHsrOzubWW29lx44dQZeiAcpwlqRr4Gph6ku2tSXpGhw+fJjS0lKqqqqIi4sLuhwNMM6cJekaFBQUkJSUxKFDh4IuRQOQ4SxJ1yAuLs7WtvqM4SxJ18hHqtRXvOYsSdeopaWF4cOHc/jwYfLy8oIuRwOIM2dJukZJSUmUlpayadOmoEvRAGM4S1Iv2NpWX7CtLUm9UF9fTygUoqamhtTU1KDL0QDhzFmSeiErK4vCwkK2b98edCkaQAxnSeolW9uKNNvaktRLx44dY9KkSVRXVxMf75xHved/kST10s0330xmZib79+8PuhQNEIazJEWAq4UpkgxnSYoArzsrkrzmLEkRcPHiRXJzc9m/fz833nhj0OXoOufMWZIiICEhgbKyMmfPigjDWZIixNa2IsW2tiRFyJkzZxg1ahTV1dWkpaUFXY6uY86cJSlC0tPTKSkpYdu2bUGXouuc4SxJEWRrW5FgW1uSIqiqqoqioiJqampISEgIuhxdp5w5S1IEhUIhRowYwZ49e4IuRdcxw1mSIszWtnrLcJakCHMpT/WW4SxJEVZUVER9fT2VlZVBl6LrlOEsSREWHx/P9OnTbW3rmiUGXYAkDUTl5eWsXbmSZ1pa4NAhaGiAjAy47TaYPx+ys4MuUVHMR6kkKdL27aP1V7+i9cMPSU5JIa65+a/7Bg+GS5dg2jR49lkoLg6uTkUtw1mSIunNN2HxYjh3LhzCVxIXFw7qVavg8cf7rz5dF2xrS1KktAVzU1PXYy9dCo9bvDj82YBWB94QJknAiy++yNy5c6+4f/z48ezYsePKJ9i3r/vB3FFbQFdU9Oy4bnj55ZdZsGBBxM+rvmc4S4op69ato6ioiKFDh5KXl8e0adPYtWtXl8d98cUXTJ48+coDfv3rcCv7Wpw7Fz4+wpYuXcpbb70V8fOq7xnOkmLG6tWrefrpp1m6dCknTpzg+PHjLFy4kA8++KB3J/7uO9i69erXmK/m0iXYsgVqa3tXhwYMw1lSTGhoaOD5559nzZo13HfffQwZMoSkpCTKy8t55ZVXALhw4QIPPfQQaWlpjB8/nooOrebRo0fzySefALB3715KSkrIzMwkLy+PJ++9lwsdgjkO+B1wM5AJPAG07b0ILAJuAG4CXv9xfCvA2rVMnjyZ5557jokTJzJ06FDKy8s5efIkc+bMIT09neLiYr755pv273rqqafIz88nPT2dwsJCdu7c2b6vq1a9opfhLCkm7N69m+bmZmbOnHnFMRs3buSBBx7g9OnTzJgxgyeffPKy4xISEnj11Vepq6tj9+7dbP/iC944f/4nYzYB+4BDwHrg4x9//p/AVuAA8L/AhrYDmpvhs88AePfdd3nnnXeorq7mq6++oqSkhPnz53Pq1CkKCgp46aWX2r+nuLiYAwcOcOrUKWbPns2sWbNo7vjolq5LhrOkmHDy5EluuOEGEhOv/JDKXXfdRVlZGQkJCcybN4+DBw9edlxhYSF33nkniYmJjB49msdGjeIPncb8G+FZ843AzwmHMYSD+ilgFJD147h29fUAzJ8/nzFjxpCRkcG0adMYM2YMU6ZMITExkVmzZvHpp5+2HzJ37lyGDRtGYmIiixYt4vz58xw9erT7fxhFJcNZUkwYNmwYdXV1tLa2XnFMbm5u+3ZqairNzc2XHf/ll18yffp0cnNzSU9PZ+nRo9R1PleH7VTg7I/bfwHyO+zruE1WFgA5OTntPxo8ePDffD579mz751WrVlFQUEBGRgaZmZk0NDRQV9e5Gl1vDGdJMaGkpITk5GQ2bNjQ9eAuPP7449xyyy0cO3aMM2fO8PK0aVyKi+vWsXnA/3X4/Oe2jZQUmDChR3Xs3LmTlStXsn79eurr6zl9+jQZGRm4ttT1z3CWFBMyMjJYtmwZTzzxBBs2bKCpqYmWlha2bt3KkiVLenSuxsZG0tPTGTp0KEeOHOHNP/2p28f+C/BboBo4Daxo23HpEvziFz2uIzExkezsbFpbW1m2bBlnzpzp0TkUnQxnSTFj0aJFrF69muXLl5OdnU1+fj6vv/469957b4/Os2rVKtatW0daWhqPPvoo98+eHW5Jd2P2/Cjwj8BtwN8BZYSXakwoK+vxyzCmTp1KaWkp48aNIxQKkZKSQn5+ftcHKuq5trYkRcK+fTB5co9XCNsK/DIujqq9e6GoqE9K0/XHmbMkRUJxcfglFqmpVx12DthC+LnmauCl+HhmTp5sMOsnnDlLUiR18VaqJuAe4AgwGPinO+/ktx9/THp6ej8XqmhmOEtSpFVUhNfK3rIlfB2645rbbe9zLisLv8/ZGbMuw3CWpL5SWwtr14ZX/qqvD980NmFC+K7sHt78pdhiOEuSFGW8IUySpChjOEuSFGUMZ0mSoozhLElSlDGcJUmKMoazJElRxnCWJCnKGM6SJEUZw1mSpChjOEuSFGUMZ0mSoozhLElSlDGcJUmKMoazJElRxnCWJCnKGM6SJEUZw1mSpChjOEuSFGUMZ0mSoozhLElSlDGcJUmKMoazJElRxnCWJCnKGM6SJEUZw1mSpChjOEuSFGUMZ0mSoozhLElSlDGcJUmKMoazJElRxnCWJCnK/D/PW1VmjT4yyQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "networkx.draw(air_route, with_labels=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 334,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def search_desitination(graph, start, destination):\n",
+    "    pathes = [[start]]\n",
+    "    seen = set()\n",
+    "    choosen_pathes = []\n",
+    "    while pathes:\n",
+    "        path = pathes.pop(0)\n",
+    "        froniter = path[-1]\n",
+    "        if froniter in seen: continue\n",
+    "        # get new lines\n",
+    "        \n",
+    "        for city in graph[froniter]:\n",
+    "            new_path = path + [city]\n",
+    "            pathes.append(new_path)\n",
+    "            if city == destination: return new_path\n",
+    "        \n",
+    "        seen.add(city)\n",
+    "    return choosen_pathes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 332,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_route(cities): return ' ✈️ -> '.join(cities)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 336,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Shenzhen ✈️ -> Beijing ✈️ -> Guangzhou ✈️ -> Chiangmai'"
+      ]
+     },
+     "execution_count": 336,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "draw_route(search_desitination(air_route, SZ, CM))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2018-autumn/Lecture-01-An Introduction to AI.ipynb b/2018-autumn/Lecture-01-An Introduction to AI.ipynb
index c80739e..f75c374 100644
--- a/2018-autumn/Lecture-01-An Introduction to AI.ipynb	
+++ b/2018-autumn/Lecture-01-An Introduction to AI.ipynb	
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 152,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -19,7 +19,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 116,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,7 +34,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 177,
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -50,7 +59,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 179,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -59,16 +68,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 185,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'蓝色好看的女人静静看着静静皮球'"
+       "'漂亮蓝色的女人安静地坐着静静皮球'"
       ]
      },
-     "execution_count": 185,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -86,7 +95,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -95,7 +104,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -104,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -113,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -122,7 +131,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -131,16 +140,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "' 蓝色 猫  坐着  皮球'"
+       "'漂亮  女人 看着 桌子 '"
       ]
      },
-     "execution_count": 46,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -173,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 219,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -189,7 +198,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 245,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -199,7 +208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 230,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -208,7 +217,7 @@
        "True"
       ]
      },
-     "execution_count": 230,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -219,25 +228,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 229,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "元素\n",
+      "3\n",
       "2\n",
-      "1\n",
-      "100000\n",
-      "9\n",
+      "10\n",
+      "6\n",
+      "5\n",
       "4\n",
-      "3\n",
       "8\n",
-      "6\n",
+      "1\n",
       "7\n",
-      "5\n",
-      "10\n"
+      "元素\n",
+      "100000\n",
+      "9\n"
      ]
     }
    ],
@@ -248,7 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 216,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
@@ -262,7 +271,7 @@
        " 'F': {'E'}}"
       ]
      },
-     "execution_count": 216,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -273,7 +282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 234,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -289,7 +298,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 209,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -297,8 +306,8 @@
      "output_type": "stream",
      "text": [
       "   I am looking at : A\n",
-      "   I am looking at : C\n",
       "   I am looking at : B\n",
+      "   I am looking at : C\n",
       "   I am looking at : D\n",
       "   I am looking at : E\n",
       "   I am looking at : F\n"
@@ -306,6 +315,8 @@
     }
    ],
    "source": [
+    "seen = set()\n",
+    "need_visited = ['A']\n",
     "while need_visited:\n",
     "    node = need_visited.pop(0)\n",
     "    if node in seen: continue\n",
@@ -324,7 +335,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 287,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -346,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 288,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -362,7 +373,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 283,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -381,7 +392,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 298,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -394,7 +405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 289,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
@@ -422,7 +433,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 290,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
@@ -450,7 +461,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 291,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -459,7 +470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 294,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -468,7 +479,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 295,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
@@ -496,7 +507,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 296,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -505,7 +516,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 297,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [
     {
@@ -540,7 +551,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 299,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -556,7 +567,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 318,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -573,7 +584,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 301,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -582,7 +593,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 319,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -591,7 +602,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 304,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -600,12 +611,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 320,
+   "execution_count": 43,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -620,7 +631,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 334,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -645,7 +656,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 332,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -654,7 +665,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 336,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -663,7 +674,7 @@
        "'Shenzhen ✈️ -> Beijing ✈️ -> Guangzhou ✈️ -> Chiangmai'"
       ]
      },
-     "execution_count": 336,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -671,13 +682,6 @@
    "source": [
     "draw_route(search_desitination(air_route, SZ, CM))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -696,7 +700,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.7.0"
   }
  },
  "nbformat": 4,