From 6f17ee1f385fe885b8728d5445160091c1c1f735 Mon Sep 17 00:00:00 2001 From: xtzd Date: Wed, 7 Nov 2018 16:47:46 -0800 Subject: [PATCH] some progress and corrections 1. spelling mistakes 2. one coding mistake: last example: seen.add(city)->seen.add(frontier) 3.adjust cell orders Thanks! --- ...-01-An Introduction to AI-checkpoint.ipynb | 733 ++++++++++++++++++ .../Lecture-01-An Introduction to AI.ipynb | 337 ++++---- 2 files changed, 916 insertions(+), 154 deletions(-) create mode 100644 2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb 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..1a17489 --- /dev/null +++ b/2018-autumn/.ipynb_checkpoints/Lecture-01-An Introduction to AI-checkpoint.ipynb @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import networkx\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 最后一题" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#定义语法内容\n", + "grammar = \"\"\"\n", + "sentence = adj noun verb adj 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": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#定义语法创建函数：从语法内容中读取语法规则并映射到创建的字典，键值为声明，值为表达式\n", + "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": 4, + "metadata": {}, + "outputs": [], + "source": [ + "grammar_pattern = build_grammar(grammar)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#定义生成符合某声明的函数：\n", + "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": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'猫静静地看着漂亮和蓝色的皮球'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generate(grammar_pattern, 'sentence')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A simpler solution" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def adj(): return random.choice('漂亮 | 蓝色 | 好看'.split('|'))\n", + "\n", + "def noun(): return random.choice('猫 | 女人 | 男人'.split('|'))\n", + "\n", + "def verb(): return random.choice('看着 | 坐着 '.split('|'))\n", + "\n", + "def noun2(): return random.choice('桌子 | 皮球'.split('|'))\n", + "\n", + "def sentence(): return ''.join([adj(), noun(), verb(), noun2()])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' 好看 女人 看着 桌子 '" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sentence()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Search Based Intelligence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## BFS 广度优先搜索 DFS 深度优先搜索" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BFS Breadth First Search \n", + "### DFS Depth First Search" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#定义无向图\n", + "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": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#去重\n", + "for k in graph:\n", + " graph[k] = set(graph[k].split())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#非空数值均可以作为Bool类型True\n", + "'元素' in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "7\n", + "9\n", + "100000\n", + "10\n", + "2\n", + "8\n", + "4\n", + "3\n", + "5\n", + "元素\n", + "6\n" + ] + } + ], + "source": [ + "#集合通过split后不维持之前的顺序，但也不是随机的\n", + "for element in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split()):\n", + " print(element)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Graph = networkx.Graph(graph)\n", + "networkx.draw(Graph, with_labels=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Breadth First Search" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "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", + "A has been seen\n", + "C has been seen\n", + "A has been seen\n", + "B has been seen\n", + " I am looking at : E\n", + " I am looking at : D\n", + " I am looking at : F\n", + "C has been seen\n", + "C has been seen\n", + "E has been seen\n" + ] + } + ], + "source": [ + "seen=set()\n", + "need_visited = ['A']\n", + "while need_visited:\n", + " node = need_visited.pop(0)\n", + " if node in seen: \n", + " print('{} has been seen'.format(node))\n", + " continue\n", + " print(' I am looking at : {}'.format(node))\n", + " need_visited += graph[node] \n", + " seen.add(node)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Depth First Search" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#定义无向长图\n", + "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": 17, + "metadata": {}, + "outputs": [], + "source": [ + "for n in graph_long: graph_long[n] = graph_long[n].split()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAFCCAYAAADGwmVOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xt4VOW99//3QIBMAEMwJAQERPBcogLBsyBuq8RiiTxFkRBOT3GnaoVdLI2Hn7jpBrFRi4gpqBgggKBBKghCqwhsUQgISfBQKj6FctAEwYDMREKyfn8sgiFMTjCZe2bN53VducjMrBm+CSGfue/1XfftsizLQkRERAKuiekCREREwpVCWERExBCFsIiIiCEKYREREUMUwiIiIoYohEVERAxRCIuIiBiiEBYRETFEISwiImKIQlhERMQQhbCIiIghCmERERFDFMIiIiKGKIRFREQMUQiLiIgYohAWERExRCEsIiJiiEJYRETEEIWwiIiIIQphERERQyJMFyAiIoYUFUF2NhQUQEkJREdDYiKMGgXt2pmuLiy4LMuyTBchIiIBlJcHU6fCqlX27dLSnx5zu8GyYMAAyMiApCQzNYYJhbCISDjJyoIJE8DrtcO2Ji6XHciZmZCeHrj6woymo0XEuTTderrKAPZ46j7WsuzjJkywbyuIG4VGwiLiPJpuPVNeHvTrd1oAt6p2iBf4DTCj+nOjomDdOujdu1FLDEfqjhYRZ8nKssNm2TI7fKsGMNjTsKWl9uP9+tnHh4OpU+2vvYofqnx8C7iBX/l6rtdrP1/8TiNhEXGOhky3VoqKcv55z6Ii6NLlzDckVcwFngZ2AS5fB0RGwp494TmN34g0EhYRZ8jL8xnA/wKSgRigPfAQcKLqAZXnPbdsCVChBmRn13nIXCCNGgIY7EateryONIwas0TEGXxMt4J9jjMOOAB8D9wOvAz8tupBldOtubkBKNS/LMvC6/Vy7Ngxfvjhh1N/Vv28T24uF9cyCt4DrANeq+0v8nqhsNDP1YtCWERCX1GR3YTl4+za/8Me/UZij4TvBD6rfpBlwcqVUFzcaNOtlmXh8XhqDcuzuc/j8dCiRQtatmxJq1atTv1Z9fOfffNNrbXNA24Cutb1RRw+7KfvhlRSCItI6KtlmvQR4A2gH3AYWAVM9nXgyenWit/97pzCsqbHKsOypqCsfl9sbCxdunQ547jqz2nZsiVNmzat/fuTmgoLFtT48DzgD7W/gi0mpj5HSQMohEUk9BUU1Nh01Bd4BTgPKAdGAIN8Hej1svCxx0idOBG3212voGzVqhVxcXF07dq1znCNioqqOywbS2KiPdXu43u0EdhHDV3RVbnd0KNHIxQX3tQdLSKhb+BAWLHijLsrgAuBB4AJ2JfijAYuBZ718TIn7ryTJu++S5MmDutZraU7+gHAA8yv6zXUHd0oHPaTJiJhKTra592HgH9jnxNuAZwPjAJW1vAyEe3aOS+AAeLi7MVJXGf2Ps+i7gC2XC5ITlYANwIH/rSJSNhJTLRHatXEYjcbZWFflvQ99qU4V/l6DadPt2Zk2F/jWSgF9g4f7t96BFAIi4gTjBxZ40NLgfeAdkB37EaYF3wdaFm1vk7IS0qyFyWJimrQ06yoKD751a/o/Z//yfvvv99IxYUvhbCIhLwfo6P5rHNnyn08djXwIXZn9EHgTezrhk8TLtOt6ek/BbGPqenTuFwQFYUrM5NbFy/mjTfeIDU1lT//+c+olch/FMIiEtLy8/Pp06cPc+LjaXKW06243fZ0bThIT7c3Y0hJsafwq3/P3G77/pQU+7iTy3n269ePTz75hLlz5zJy5Ei8PhZGkYZTd7SIhKQTJ07w7LPP8sILL5CZmUlaWhquv/xFa0c3RHGxfY11YaG9EEdMjH1efOTIGmcFPB4Po0ePZteuXbz99ttccMEFAS3ZaRTCIhJydu7cyYgRI2jZsiVz5syhc+fOPz2oTesbnWVZPPvss7z44ossWbKEG2+80XRJIUvT0SISMioqKpgxYwY33HADw4YNY82aNacHMJz1dKvUn8vlYuLEibz66qukpKQwe/Zs0yWFLI2ERSQk7N69m9GjR+PxeJg7dy6XXHJJ3U86i+lWaZidO3cyaNAg+vbty/Tp02nevLnpkkKKQlhEgpplWWRnZ/P73/+e3/3udzz66KPmln8Un44cOcLw4cM5fPgwb775JvHx8aZLChkKYREJWt988w1jx45lz549zJs3j8TERNMlSQ0qKip4+umnyc7OZunSpfTq1ct0SSFB54RFJCi99dZbXH311fTo0YPNmzcrgINckyZNePrpp3nhhRe48847WVDLrk3yE42ERSSoHDp0iIcffpgtW7Ywd+5crrvuOtMlSQPt2LGDQYMGMWjQIJ555hkiIrRhX000EhaRoLFq1SoSExOJjY1l27ZtCuAQ9bOf/YzNmzdTUFBAcnIyhw4dMl1S0FIIi4hxR48e5YEHHiA9PZ158+Yxffp0ohq4xrEEl7Zt27Jy5UoSExPp06cPO3bsMF1SUFIIi4hR69ev56qrrqKsrIz8/Hz69+9vuiTxk4iICDIzM5k0aRK33norS5cuNV1S0NE5YRExorS0lMcff5xFixYxa9YsBg4caLokaURbt24lJSWFUaNG8dRTTzlz3+azoO+CiATcli1b6NmzJ//+978pKChQAIeBXr16kZeXxwcffEBKSgpHjhwxXVJQUAiLSMCUlZUxadIk7rrrLp588kkWL15MbGys6bIkQOLj43n//ffp0KED1113Hf/85z9Nl2ScQlhEAuLzzz/n+uuvZ9OmTWzbto2hQ4fiqmtPW3Gc5s2bk5WVxbhx47jpppt47733TJdklEJYRBpVeXk5mZmZ9O3bl7Fjx7Jy5Uo6dOhguiwxbOzYseTm5jJ69GimTZtGuLYnqTFLRBrN119/zciRI3G5XLz++utcdNFFpkuSILN3715SUlLo3r07r732WthdmqaRsIj4nWVZzJo1i2uvvZZBgwaxdu1aBbD4dMEFF7B+/XqaNWvGjTfeyO7du02XFFAaCYuIX+3bt48xY8Zw8OBB5s2bxxVXXGG6JAkBlmUxffp0pk2bxqJFi+jXr5/pkgJCI2ER8QvLsliwYAHXXHMNN9xwAx9//LECWOrN5XIxbtw45s+fz3333cdLL70UFueJNRIWkXNWXFxMeno6X3zxBfPmzdM2dnJOvv76awYNGkRSUhIvv/wyLVq0MF1So9FIWETOyTvvvMNVV13FRRddxNatWxXAcs4uuugiNm7cSElJCf369WP//v2mS2o0GgmLyFkpKSlh3LhxrF+/nuzsbG6++WbTJYnDWJbFlClTyMrK4q233nLkrloaCYtIg73//vskJiYSGRlJfn6+Algahcvl4vHHHycrK4u7776bOXPmmC7J7zQSFpF683g8TJw4kWXLlvHqq69yxx13mC5JwsSXX37JL3/5S37+85/z/PPP06xZM9Ml+YVCWETq5eOPP2bEiBH06dOHGTNmEBMTY7okCTPff/89w4YNw+PxsGTJEtq1a3fmQUVFkJ0NBQVQUgLR0ZCYCKNGga/jDVMIi0itfvzxRyZNmsTrr7/OzJkzGTx4sOmSJIyVl5fz5JNPsnDhQpYtW8bVV19tP5CXB1OnwqpV9u3S0p+e5HaDZcGAAZCRAUlJgS+8BgphEalRfn4+aWlpdO3alVmzZhEfH2+6JBEAlixZwoMPPshLL73EvYcOwYQJ4PXaYVsTl8sO5MxMSE8PXLG1UAiLONlZTs2dOHGCZ599lhdeeIHMzEzS0tK045EEnfz8fJb0789TR47Q/MSJ+j8xKipoglghLOJE5zA1t3PnTtLS0mjVqhVz5syhc+fOASxcpAHy8rD69sXl9Z5290tANlAIDD35+RmiomDdOujdu5GLrJ0uURJxmqws6NcPli2zw7dqAIM9ZVdaaj/er599PFBRUcGMGTO44YYbSE1NZc2aNQpgCW5Tp+Kq/vMNdACeAEbX9lyv136japhGwiJOkpVlnxvzeOr/nKgovnvsMYZ88AEej4e5c+dyySWXNF6NIv5QVARdupz5JrOKJ4C91DASBoiMhD17jHZNayQs4hR5eQ0PYACPB/cTTzD88sv53//9XwWwhIbs7HN/DZfLP69zDhTCIk4xdao9xVbNF0B/IBroDrzt46lul4uRBw7QtGnTxq1RxF8KCmodBdeL1wuFhf6p5ywphEWcoKjIbsKqdnbpBPBL4BfAIWA2kArsrPZ0l2XBypVQXByIakXOXUmJf17n8GH/vM5ZUgiLOEENU2pfAvuB8UBT7BHxjcB8XwcHwdScSL1FR/vndQyv/KYQFnGCGqbmfHVdWsAOX68RBFNzIvWWmGg3VvlwAigFyk9+lJ687wxuN/To0VgV1otCWMQJapiauwyIA/4ElAFrgHVAja1bhqfmROpt5MgaH/oj4AaeAXJOfv5HXwdaVq2vEwgKYREnqGFqrhmwDHgXaA88BwwBLqjpdbQpg4SKuDh7wRkfK7lNwp7xqfoxqfpBLhckJxvf1EEhLOIEtUzNJWKPfr8DVgNfA318HRgEU3MiDZKRYf/cng23236+YQphESeoZUqtAPucmAfIBA4APo8Ogqk5kQZJSrLXgI6KatjzKteONrxkJSiERZyhlqm5+UAC9rnh94G/AS2qHxQkU3MiDZae/lMQ17XJiMsVVJs3gJatFHGOvDx7LeiGrpgFQbOYvchZ27LFXrBm5Uo7bKsuXFO5aUlysj0FHUQ/5wphESc5y7Wjg2lkIHJOiovt690LC9n32Wfs+u47bnnwQftUSxDO9CiERRym6L//m1ZPPYXb5bJXwqpJEG5wLuJPH3zwAZMnT2bt2rWmS6mRzgmLOEh5eTn3rFnDsvHjcaWk2B3T1btH3W77/pQUewpaASwOFR8fz7fffmu6jFpFmC5ARPzn+eefJyIigvsyM6FJk9Om5jh82L4OuEePoJ2aE/GnuLg4ioqKTJdRK01HizjEjh07uPXWW9m8eTNdu3Y1XY6IceXl5URGRuLxeGjWrJnpcnzSdLSIAxw/fpy0tDSmTp2qABY5qWnTppx//vkcPHjQdCk1UgiLOMDkyZPp0KEDY8aMMV2KSFCJi4sL6vPCOicsEuI2b97M7Nmz2b59O666FisQCTPx8fFBfV5YI2GREOb1eklLS2PGjBkkJCSYLkck6AT7SFghLBLCMjIyuOaaaxgyZIjpUkSCUrCPhDUdLRKi1q5dy1tvvUVBQYHpUkSCVrBfpqSRsEgIKikpYdSoUcyePZu2bduaLkckaGk6WkT8bvz48dxxxx0kJyebLkUkqGk6WkT8avny5Xz44Yfk5+ebLkUk6AX7SFghLBJCDh48yAMPPMDixYtp3bq16XJEgl6wj4S1bKVIiLAsiyFDhtClSxcyMzNNlyMSEkpLS4mOjqa0tDQor6PXSFgkRCxatIjPP/+c+fPnmy5FJGRERkYSGRlJSUkJbdq0MV3OGRTCIiFg3759jBs3jlWrVhEZGWm6HJGQUnmZUjCGsLqjRYKcZVmMGTOGhx56iF69epkuRyTkBHNzlkJYJMjNmjWL7777joyMDNOliISkYG7O0nS0SBDbtWsXTz75JOvXrw/a/VBFgp1GwiLSYOXl5YwYMYLHHnuMyy+/3HQ5IiErmEfCCmGRIPX8888TERHBI488YroUkZCmkbCINEhhYSHTpk3j9ddfp0kT/TcVORcaCYtIvR0/fpy0tDSmTZtG165dTZcjEvKCeSclhbBIkJk8eTIdO3Zk9OjRpksRcYRgno5Wd7RIENm8eTOzZ89m+/btQbnEnkgo0nS0iNTJ4/GQlpbGjBkzSEhIMF2OiGO0adMGj8dDaWmp6VLOoBAWCRIZGRlcc801DBkyxHQpIo7icrmIi4ujuLjYdCln0HS0SBD44IMPyM3NpaCgwHQpIo5UeV64U6dOpks5jUbCIoaVlJQwevRoXnnlFdq2bWu6HBFHCtbzwgphEcPGjx/PHXfcwYABA0yXIuJYwXqZkqajRQxavnw5H374Ifn5+aZLEXG0YL1MSSEsYkhxcTEPPPAAixcvpnXr1qbLEXG0+Ph4Dhw4YLqMM2g6WsQAy7JIT0/n/vvv5+abbzZdjojjaSQsIqcsXLiQL774gpycHNOliISFYG3MUgiLBNi+ffsYP3487733HpGRkabLEQkLwToS1nS0SABZlsWYMWN46KGH6Nmzp+lyRMJGsI6EFcIiATRr1iy+++47MjIyTJciElZiY2M5ePAgFRUVpks5jcuyLMt0EQFVVATZ2VBQACUlEB0NiYkwahS0a2e6OnGwr776iuuuu44NGzZw+eWXmy5HJOy0bduWnTt3Ehsba7qUU8InhPPyYOpUWLXKvl11IW+3GywLBgyAjAxISjJTozhWeXk5ffv2ZfDgwYwfP950OSJh6fLLLyc3N5crrrjCdCmnhMd0dFYW9OsHy5bZ4Vt9Jw2v175v2TL7uKwsE1WKgz333HNERETwyCOPmC5FJGwFY3OW87ujs7JgwgTweOo+1rLs4yZMsG+npzdubRIWCgsL+dOf/kReXh5NmoTH+16RYBSMzVnO/o2Ql8dLjzxCb4+HFsDIKg99AtwOtAXaAb8CTq2lUhnEW7YEslpxoOPHj5OWlsYzzzzDhRdeaLockbAWjCNhZ4fw1Kl0KCvjCWB0tYcOA2OBfwG7gdbAqKoHeL32OWSRczB58mQ6duzI6NHVfwJFJNCCcSTs3OnooiJYtYp7Tt7cAuyt8nD1/WoeAvpWvcOyYOVKKC52Tte0OsMDatOmTcyePZvt27fjcrlMlyMS9uLi4ti6davpMk7j3BDOzm7Q4euBK6vf6XLZr/Poo/6pyZTaOsOXLoWnnlJnuJ95PB7S0tKYMWMGCQkJpssRETQdHVgFBWd2Qdd0KPDfwJ+qP+D1QmGhnwsLMHWGG5GRkUGvXr0YMmSI6VJE5CRNRwdSSUm9DvsKe2p6OuBrL5svPv6Yv58czbRv356EhAQSEhKIioryY7GNRJ3hRnzwwQfk5uZSUFBguhQRqSIYR8LODeHo6DoP2Q38B/AkMLyGY8patuTLL79k7dq1fPPNNxw4cIADBw7QvHnzU4FcNZyrfp6QkEDbtm3NnA882RmeXVZGITAUyD750HHgfuzz5LuBtUC/yudVBnFSEvTuHdiaHaCkpITRo0fzyiuv0LZtW9PliEgVGgkHUmIi5OZyorSUE0D5yY9S7C/6W6A/8CDwnzW9httN4rBhzKx2TtiyLL7//vvTQrny8/z8/NPu93g8xMfH1xrW7du3p3379jRr1sx/X3+VzvDVgLfawzcB47AvzTpDZWd4bq7/6gkT48eP54477mDAgOqtfyJiVFERrbKzme31cmLAACLOPz8oGlOdu2xlURF06cKk0lKervbQU4ALmAS0rPbYD1VvREbCnj3n9A9UWlp6KpR9hXblR3FxMW3atKl1VF15u3Xr1vX62ivP/z6B3Rme7ePQC4AcqoyE/fi1h5t33nmHcePGkZ+fX/e/kYgERpAvWezcEAa45x674ehsvkSXC1JSAjYaLC8v5+DBg7WGdeXnLper1lF14nvv0X7WLJqcSwi73fD006HfGR4gxcXFXHXVVSxevJibb/bVXSAiAVfZF+P11p4DLpf9Oy8zM+D9MM6djgb7nc3q1fVrTKrO7bafHyBNmzYlPj6e+Pj4Wo+zLIujR4/6DOcvvviCAwcO8Nu8PAbWszO8Rk7oDPenWq6xtmJjSU9PZ9iwYQpgkWARIo2pzh4JQ8P+ISpFRRl5R+Q3AwfCihWnbp7VSBjY3aMHhVOmkJCQQIcOHYiLi6Np06aNUHAQq8dU1p4rr+T3hw+T/dlnREZGmqlTRH6Sl2dfcnk2A7CoKFi3LmCNqc4eCcNPQRrkUxJ+VY/O8PrY7/WSlZXF/v372b9/P4cOHSIuLo4OHTqc9lEZ0pUfsbGxztiooK6pLK/d7tZx61YWREbS9PXXQ/vnRsQppk499f+z0o/Ab4C/A4eA7sAUzlw9MdCNqc4PYbB/MSYl2d/YlSvtsK36D1R5cj452Z6CDvVLc+roDI/A/oGsjJXjJx9rgd2wBoDbzfVjx/JulXPCx48f59tvvz0VygcOHGD//v1s3Ljx1H379+/nyJEjtG/fvsaQrvwwdvlWfTRgBqUp2CNkXWMtYt7JJYurv3E+AXQC1gGdgZXAEKAQuLDqgQFestj509HVFRfb5/YKC+HwYYiJgR49YORI53QC19EZPgn7h253tcf+H1V+GM+hO7pqR3jVcK7+4fV6TzWU+Qrpyo/o6OjAhnUITWWJSDXPPmsvxVuPvphE7N+Jg6s/EMDG1PAL4XARAp3hXq+3zqA+cOAAZWVldQZ1hw4d/HdZ0Mnv3UuWRTacsdgJwPvY15jvAa49+VgXCHhXvYhUk5oKCxbUedi32P9ntwOX+Tpg+HCYN8+/tfmgEHYqB43mfvjhhxrDuvL+ffv24XK5ag3pyiBv2bL61eFVVLnGein24uqVi51knzzkINANeBUYiL3i2gbsPaoBXWMtYlK1xlRfyrDPBXcDZtV00C9+AcuX+7c2H8LjnHA4SkqyG8zOtjM8SAIYoFWrVlx88cVcfPHFNR5TeelW9ZDes2cPmzZtOu2+5s2b1xjUvT/4gC6WRROocRvMpdg7blWuNjYJiAW+5OQ7aqfsviUSiupoTK3AXqa4OfBSbQfGxPivploohJ0sjDrDXS4X5513Hueddx6XXeZzcgn4acnR6qPpXbt2sWHDBlqvW0fXH3+s9e/6DLiqyu2W2O+oP+NkCOsaaxFzTjam+jonbAFjsKeiVwI1LhTsdtu9QgGgEHa6cOsMr4PL5SImJoaYmBiuvPKMHaTrNZX1A1B9ojkaOFr1jsOHz61QETk7I0fajVk+pANfYF+m5K7tNSzLfp0AUAiHg9697XeG4dAZfq7qcY11K+BItfuOAKe1hQVoKktEqomLs9eCrtaYuhv7/G8LoH2Vw2cBw6o+3+WyByUB+p2oEA4n7drpPGVdapnKqnQlMLfK7WPArpP3AwGdyhIRH3wsWdyFn9ZGqFWAlyx2wLJGIn5UZQrqBPYiJlUXOzkBpAA7gNyT9/039vWGp85EB3AqS0R8ONmYWuGuddL5TAYaUxXCIlVVTmW5XPwR+7zRM9jra7uBP2KfD84FHgdigE3AG5XPD/BUloj4duLXv+b5hATKmjWz/1/WxuUytmeArhMWqc5B11iLhKsnnniCvLw8Vk2eTJNp04K2MVUhLOJLOO6+JeIQf//73xkxYgSffvrpT9vDBmljqkJYpCb13BC8AiiLiKDFiy8qgEUM+/bbb+nZsyfz5s3jtttuM11OnXROWKQm6en21HJKir0UZfUmD7cbIiMpHziQ/xMby3tdu5qpU0QAqKioIC0tjVGjRoVEAINGwiL1U8dU1vvvv8/IkSMpLCykTZs2pqsVCUvPPPMM7777LmvXriUiIjSuwFUIi/jJgw8+yLFjx8jOzjZdikjY2bhxIykpKWzZsoVOnTqZLqfeNB0t4ifTpk1jw4YNvPPOO6ZLEQkrhw4d4v777+eVV14JqQAGjYRF/Gr9+vUMHTqUgoICzj//fNPliDieZVkMHjyYTp06MX36dNPlNJhCWMTPxo8fz7fffsvChQtNlyLieDNnzmTOnDls3LiRFi1amC6nwRTCIn7m8Xi45pprmDJlCoMHDzZdjohjbd++ndtvv52NGzfWut94MNM5YRE/i4qKIjs7m4ceeoiioiLT5Yg40g8//MC9997L9OnTQzaAQSNhkUYzceJEdu3axZtvvomrrrVrRaRB0tLSaNasGa+99prpUs6JRsIijeTpp5/miy++4I033qj7YBGpt7lz57JlyxZefPFF06WcM42ERRrRli1buOuuu9i+fTsJCQmmyxEJeV9++SU333wza9eu5Wc/+5npcs6ZRsIijah3796MHTuWBx54AL3fFTk3Xq+Xe++9l//5n/9xRACDRsIije748eMkJSXxX//1X4wYMcJ0OSIh6ze/+Q0HDx5k8eLFjumzUAiLBMD27dv5+c9/zqeffsoFF1xguhyRkJObm8ujjz7Ktm3biI6ONl2O3yiERQJk8uTJfPTRR6xatcox7+JFAuFf//oXffr0YcWKFfTp08d0OX6lc8IiAfKHP/yBgwcP8uqrr5ouRSRklJWVMXToUCZOnOi4AAaNhEUC6rPPPqNfv37k5eVx4YUXmi5HJOhNnDiRHTt2sHz5cpo0cd64USEsEmDTpk1jzZo1/O1vf3PkLxURf3nvvff49a9/zbZt24iNjTVdTqPQbwCRAJswYQIej4esrCzTpYgErf379zNq1ChycnIcG8CgkbCIEf/4xz+48cYb+eSTT+jevbvpckSCSnl5Obfffjt9+/blqaeeMl1Oo9JIWMSASy+9lMcff5xRo0ZRUVFhuhyRoDJlyhQqKip44oknTJfS6BTCIoY88sgjuFyukNyIXKSxrF+/npkzZ7JgwQKaNm1qupxGp+loEYN27drFtddey0cffcSll15quhwRo7777juuvvpqZs2aRXJysulyAkIhLGLYzJkzmT9/Ph999FFYvPMX8cWyLO6++24uvfRSMjMzTZcTMJqOFjEsPT2dli1bhtUvHpHqpk+fTlFREVOmTDFdSkBpJCwSBHbv3k3v3r0dsz2bSENs2bKF5ORkPvnkEy666CLT5QSURsIiQaBLly5MmTKFESNGUFZWZrockYA5cuQI9913HzNnzgy7AAaNhEWChmVZJCcnc8MNN/Dkk0+aLkek0VmWxf333090dDR/+ctfTJdjhEJYJIjs3buXnj17smbNGq6++mrT5Yg0qldffZUXX3yRTZs24Xa7TZdjhEJYJMjMnTuX559/nry8PJo3b266HJFGUbmZyfr167n88stNl2OMzgmLBJm0tDS6dOnC5MmTTZci0ig8Hg9Dhgxh2rRpYR3AoJGwSFD65ptvuOqqq1ixYgVJSUmmyxHxq7Fjx3Ls2DFycnJwuVymyzEqwnQBInKm9u3bM336dEaMGMGnn35KZGRZt+ZFAAAP7ElEQVSk6ZJE/GLx4sWsXbuWTz/9NOwDGDQSFglalmXxq1/9im7dujFt2jTT5Yics127dnH99dfz3nvv0bNnT9PlBAWFsEgQKy4uJjExkaVLl3L99debLkfkrB0/fpwbb7yR4cOH89vf/tZ0OUFDjVkiQaxdu3a89NJLjBgxAo/HY7ockbP2hz/8gY4dO/Lwww+bLiWoaCQsEgLuv/9+4uPjeeGFF0yXItJgK1as4MEHH2Tbtm20bdvWdDlBRSEsEgIOHTpEjx49WLRoEbfccovpckTqbe/evfTu3Zvc3FxuvPFG0+UEHYWwSIhYvnw548aNIz8/n1atWpkuR8RWVATZ2VBQACUlEB0NiYkwahQnYmLo378/d955J4899pjpSoOSQlgkhIwcOZKoqChefvll06VIuMvLg6lTYdUq+3Zp6U+Pud1gWXx+4YXMbN2aFz/+WHtl10AhLBJCvv/+exITE5kzZw7/8R//YbocCVdZWTBhAni9UEuElAMut5smzz0H6emBqy+EqDtaJIS0adOGV155hTFjxnDkyBHT5Ug4qgxgj6fWAAZoCjTxeu3js7ICU1+I0UhYJASNHTuWiooKXn31VdOlSDjJy4N+/ewAriIVeB84BrQHfg/83+rPjYqCdeugd+8AFBo6FMIiIejo0aMkJiby8ssvM2DAANPlSLi45x5YtuyMEfBnQHegBfAl0A94F+hV9SCXC1JSIDc3MLWGCE1Hi4Sg1q1b89prrzF27FgOHz5suhwJB0VFdhOWj3HbldgBDOA6+bGr+kGWBStXQnFxo5YZahTCIiGqf//+/PKXv+SRRx4xXYqEg+zsWh/+DRAFXAYkAMm+DnK56nydcKMQFglh06ZNY+PGjfz1r381XYo4XUHB6ZchVfMycBTYANzDTyPj03i9UFjYKOWFKoWwSAhr2bIl2dnZpKen891335kuR5yspKTOQ5oCNwF7gRp7oXX65DQKYZEQd9NNNzF06FAefPBB06WIg1nR0fU+9gQ+zglXionxRzmOoRAWcYA//vGPbN++nTfffNN0KeIwn332GRkZGUxZsYJSl+uMx4uAN4AfsBfnWA0sAvr7ejG3G3r0aMRqQ49CWMQB3G43c+fO5eGHH6aoqMh0ORLi9u/fz3PPPcc111zDHXfcQUVFBYPefpvIFmee6XVhTz1fAMQAE4A/A7/09cKWBSNHNl7hIUjXCYs4SEZGBv/4xz/Izc3F5WPUIlKTo0ePsnTpUnJyctiyZQv33HMPqamp3HLLLT+t+1zDdcL1ouuEfVIIizjIjz/+SK9evXjssce4//77TZcjQa6srIw1a9aQk5PDypUr6du3L8OHD+cXv/gFbrf7zCfUsGJWvWjFLJ8UwiIOs3XrVpKTk9m2bRsdOnQwXY4EGcuyyMvLIycnh8WLF9OtWzdSU1MZMmQIsbGxdb9A1bWj6ysqCjIztYmDDwphEQd66qmn2Lp1K8uXL9e0tACwa9cuFixYQE5ODgCpqakMGzaMbt26NfzF6rmLEi6X3YylAK6RQljEgY4fP861117Lb3/7W0aNGmXfWcvm67RrZ7ReaRwHDx5kyZIl5OTk8NVXX3HfffeRmppKUlLSub8527LF3k945Uo7bL3enx47uZ8wycmQkaEp6FoohEUcqqCggNtuu40dr79O/Jw5tW6+zoAB9i/LpCQzxYrfeL1eli9fTk5ODuvXryc5OZnU1FRuv/12mjVr5v+/sLjYfnNXWGgvxBETY1+GNHKk3tzVg0JYxMFW3n03/d99lxaWhUvTho5VXl7OunXryMnJ4e233yYpKYnU1FRSUlJo3bq16fKkFgphEafKysKaMAGXGmgcq6CggJycHBYuXEhcXBypqancd999asgLIQphESfSpSSOtXfvXhYuXEhOTg4lJSUMGzaMYcOGceWVV5ouTc6CQljEiWpYVKEf8AkQcfJ2R+Af1Z+rRRWCTklJCbm5ueTk5JCfn8/gwYNJTU3lpptuokkTLXwYyhTCIk5TVARduvjcdq4fkAr837peIzIS9uxRY41Bx48fZ/Xq1cyfP5/Vq1fTv39/UlNTueuuu4iMjDRdnvhJRN2HiEhI8cem6ZWbrz/66Lm/ltSbZVl88skn5OTksGTJEi677DJSU1P5y1/+Qtu2bU2XJ41AISziNHVsvp4B/AG4FPgf7NHxGbT5+uka+RrrnTt3nlpIo1mzZgwfPpzNmzfTtWvXc69dgpqmo0WcZuBAWLHC50ObgCuA5tjbzz0EbAd8rZm0r2dPvnr+eTp06EBCQgKtWrVqrIqDV16evSBFI1xjXVRUxOLFi8nJyWH37t0MHTqU1NRUevbsqVXOwohCWMRpUlNhwYJ6HXoncBfwsI/H1nXuzBOdO7N//34OHDhAREQECQkJp0K56udV/3TMdamNsDSjx+Phr3/9Kzk5OXz00UcMHDiQ1NRUbrvtNiIiNDEZjvSvLuI0iYl2Z3MtU9KVXIDPeHG76fvQQ2w4eU7YsixKSko4cODAqVDev38/e/fuJS8v77T7XC6Xz3D2FdZBO+JryCYFlmUfN2GCfbtaEJeXl7N27Vrmz5/PO++8w3XXXUdqaiqLFy8Oz9kFOY1GwiJOU0N39PfY09F9sd99LwbGAp9inx8+zVl2R1uWxdGjR08L5Zr+tCyrXmF93nnnBTas67jG+p9AD+D/ADnVHzx5jbXVqxf5+fmnFtLo2LEjqamp3HvvvbRv375Ry5fQohAWcSIf1wkXA8nAl0BT4DJgMnB79ecG6Drh+oZ1eXn5GeHsK7DbtGnjn7CuY+P6nwNeoAtnhrDlcrHziisYDBw7duzUTkWXXXbZudcljqQQFnEiB62YdfToUQ4cOFBnWJeVldU5qk5ISCAmJqbmsK7lGmuwm9mWYje3fYWPkTBQ1rQpW99+mz533aWFNKROOics4kRJSXaj0Nluvh4kAQzQunVrWrduzSWXXFLrcceOHfMZ0Dt27DjtdmlpaY0hfd2GDVxsWfiKziPA/we8D7xWSx3Nmjfnui+/tLvUReqgEBZxqsoGoQkTqPB4fAbLKQ7YRally5Z0796d7t2713qcx+PxGdaff/45Hf/2Ny798Uefz3sSGAN0qqsQXWMtDaAQFnGy9HTKe/Zkdb9+3FlRQZOmTcN+8/WoqCi6detGt24+ro6u4Rrr7cDfgW31/UsOHz6HCiWcKIRFHO7DH37gicsvJ3n1am2+XpfoaJ93fwj8C+h88vYPQDnwOXZ3+RliYvxemjiTQljE4XJyckhNTbWDVmtB166Ga6zHAvdVuZ2JHcpZvl7D7bbf3IjUg7qjRRzM4/HQsWNHPv/8cxISEkyXE/zq6I6uNImau6O1A5U0hPrnRRxs+fLl9OnTRwFcX3Fx9lrQdVxvPIkaAtjlss+vK4ClnhTCIg52aipa6i8jw55SPhtut/18kXpSCIs4VHFxMRs2bCAlJcV0KaGl8hrrqKiGPS8Ir7GW4KfGLBGHWrJkCXfddZc2CTgbVa6x9ucuSiLVaSQs4lCaij5H6en28p0pKXazVfUparfbvj8lxT5OASxnQd3RIg70z3/+k5tuuol9+/Zpn1p/KC7WNdbSKBTCIg40adIkDh8+zPTp002XIiK1UAiLOIxlWVx88cUsWrSIpKQk0+WISC10TljEYTZt2kTTpk3prS5dkaCnEBZxmJycHIYPH+6fDe5FpFFpOlrEQcrKyujQoQObNm3ioosuMl2OiNRBI2ERB1m9ejWXXnqpAlgkRCiERRxE1waLhBZNR4s4xJEjR+jUqRNff/01559/vulyRKQeNBIWcYilS5dy6623KoBFQohCWMQhNBUtEno0HS3iAHv37iUxMZH9+/cTGRlpuhwRqSeNhEUcYNGiRdxzzz0KYJEQoxAWcQBNRYuEJoWwSIgrKCjg8OHD3HLLLaZLEZEGUgiLhLgFCxYwbNgwmjTRf2eRUKPGLJEQVlFRQefOnVm9ejVXXnml6XJEpIH01lkkhK1bt4527dopgEVClEJYJISpIUsktGk6WiREeb1eOnbsyI4dO+jQoYPpckTkLGgkLBKiVqxYQa9evRTAIiFMISwSoubPn6+paJEQp+lokRB08OBBunXrxr///W/OO+880+WIyFnSSFgkBC1ZsoTk5GQFsEiIUwiLhCB1RYs4g6ajRULMrl27uOGGG9i7dy/NmjUzXY6InAONhEVCzIIFC7j33nsVwCIOoBAWCSGWZWkqWsRBFMIiISQvLw+ApKQkw5WIiD8ohEVCSOUo2OVymS5FRPxAjVkiIaKsrIwLLriAjRs30q1bN9PliIgfaCQsEiLWrFlDt27dFMAiDqIQFgkRasgScR5NR4uEgCNHjtCpUyd27dpFbGys6XJExE80EhYJAW+//TZ9+/ZVAIs4jEJYJARoKlrEmSJMFyAiVRQVQXY2FBRASQlER1Ny4YX8Ky+Pge+8Y7o6EfEznRMWCQZ5eTB1KqxaZd8uLT31UFlEBJZl0fzuuyEjA7RQh4hjKIRFTMvKggkTwOuF2v47ulzgdkNmJqSnB64+EWk0mo4WMakygD2euo+1LPu4CRPs2wpikZCnkbCIKXl50K+fzwB+A3ga2AO0B7KBm6seEBUF69ZB796NX6eINBp1R4uYMnWqPQVdzd+AicDrwFFgPXBR9YO8Xvv5IhLSNBIWMaGoCLp0Oa0Bq9INwJiTH7WKjIQ9e6Bdu0YoUEQCQSNhEROys33eXQ5sAYqB7sAFwEPAmeNl7EatGl5HREKDQljEhIICn6Pgb4Ey4C1gA7Ad2Ab80ddreL1QWNiIRYpIY1MIi5hQUuLzbvfJPx8GEoBY4L+AlTW9zuHD/q5MRAJIISxiQnS0z7tjsKegXfV9nZgYPxUkIiYohEVMSEy0G6t8GAXMAIqAw8CfgV/4OtDthh49GqtCEQkAdUeLmFBLd3QZ8AiwEIgEhgDPnvz8NOqOFgl5GgmLmBAXBwMG2B3O1TQDXga+B74BXsRHALtckJysABYJcRoJi5hSy4pZddKKWSKOoJGwiClJSfZmDFFRDXteVJT9PAWwSMjTBg4iJlVuwqBdlETCkqajRYLBli32WtArV9phW3VNabfbDufkZHs/YY2ARRxDISwSTIqL7aUoCwvthThiYuzLkEaOVBOWiAMphEVERAxRY5aIiIghCmERERFDFMIiIiKGKIRFREQMUQiLiIgYohAWERExRCEsIiJiiEJYRETEEIWwiIiIIQphERERQxTCIiIihiiERUREDFEIi4iIGKIQFhERMUQhLCIiYohCWERExBCFsIiIiCEKYREREUMUwiIiIoYohEVERAxRCIuIiBiiEBYRETFEISwiImKIQlhERMQQhbCIiIghCmERERFDFMIiIiKGKIRFREQMUQiLiIgYohAWERExRCEsIiJiiEJYRETEEIWwiIiIIf8/Cm+4qE9g7yMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Graph_long = networkx.Graph(graph_long)\n", + "networkx.draw(Graph_long, with_labels=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Repetition is the mother of evil." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#合并广度优先和深度优先解法\n", + "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: \n", + " print('{} has been seen'.format(node))\n", + " 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": 20, + "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": 21, + "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", + "10 has been seen\n", + "5 has been seen\n", + " I am looking at : 11\n", + "5 has been seen\n", + " I am looking at : 12\n", + "11 has been seen\n" + ] + } + ], + "source": [ + "search(graph_long, treat_already_discoveried_more_important)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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", + "5 has been seen\n", + " I am looking at : 10\n", + "5 has been seen\n", + " I am looking at : 11\n", + " I am looking at : 12\n", + "11 has been seen\n", + " I am looking at : 7\n", + " I am looking at : 8\n", + " I am looking at : 9\n", + "10 has been seen\n" + ] + } + ], + "source": [ + "search(graph_long, treat_new_discover_more_important)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "dfs = partial(search, concat_func=treat_new_discover_more_important)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "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", + "5 has been seen\n", + " I am looking at : 10\n", + "5 has been seen\n", + " I am looking at : 11\n", + " I am looking at : 12\n", + "11 has been seen\n", + " I am looking at : 7\n", + " I am looking at : 8\n", + " I am looking at : 9\n", + "10 has been seen\n" + ] + } + ], + "source": [ + "dfs(graph_long)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "bfs = partial(search, concat_func=treat_already_discoveried_more_important)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "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", + "10 has been seen\n", + "5 has been seen\n", + " I am looking at : 11\n", + "5 has been seen\n", + " I am looking at : 12\n", + "11 has been seen\n" + ] + } + ], + "source": [ + "bfs(graph_long)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mapping" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "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": 29, + "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": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "air_route = networkx.Graph(air_route)\n", + "\n", + "networkx.draw(air_route, with_labels=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def search_destination(graph, start, destination):\n", + " pathes = [[start]]\n", + " seen = set()\n", + " chosen_pathes = []\n", + " while pathes:\n", + " path = pathes.pop(0)\n", + " frontier = path[-1]\n", + " if frontier in seen: continue\n", + " # get new lines\n", + " \n", + " for city in graph[frontier]:\n", + " new_path = path + [city]\n", + " pathes.append(new_path)\n", + " if city == destination: return new_path\n", + " \n", + " seen.add(frontier)\n", + " return chosen_pathes" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_route(cities): return ' ✈️ -> '.join(cities)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Shenzhen ✈️ -> Beijing ✈️ -> Guangzhou ✈️ -> Chiangmai'" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw_route(search_destination(air_route, SZ, CM))" + ] + } + ], + "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.6.5" + } + }, + "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..1a17489 100644 --- a/2018-autumn/Lecture-01-An Introduction to AI.ipynb +++ b/2018-autumn/Lecture-01-An Introduction to AI.ipynb @@ -2,15 +2,35 @@ "cells": [ { "cell_type": "code", - "execution_count": 152, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ + "import random\n", + "import networkx\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 最后一题" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#定义语法内容\n", "grammar = \"\"\"\n", - "sentence = adj noun verb adv noun2\n", - "adj = adj_single adj_single 的 | null\n", + "sentence = adj noun verb adj noun2\n", + "adj = adj_single 和 adj_single 的 | null\n", "adj_single = 漂亮 | 蓝色 | 好看\n", - "adv = 安静地 | 静静\n", + "adv = 安静地 | 静静地\n", "noun = 猫 | 女人 | 男人\n", "verb = adv 看着 | adv 坐着 \n", "noun2 = 桌子 | 皮球 \n", @@ -19,10 +39,11 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ + "#定义语法创建函数：从语法内容中读取语法规则并映射到创建的字典，键值为声明，值为表达式\n", "def build_grammar(grammar_str, split='='):\n", " grammar_pattern = {}\n", " for line in grammar_str.split('\\n'):\n", @@ -34,41 +55,42 @@ }, { "cell_type": "code", - "execution_count": 177, + "execution_count": 4, "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'])" + "grammar_pattern = build_grammar(grammar)" ] }, { "cell_type": "code", - "execution_count": 179, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "grammar_pattern = build_grammar(grammar)" + "#定义生成符合某声明的函数：\n", + "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": 185, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'蓝色好看的女人静静看着静静皮球'" + "'猫静静地看着漂亮和蓝色的皮球'" ] }, - "execution_count": 185, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -81,66 +103,38 @@ "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('|'))" + "## A simpler solution" ] }, { "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, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ + "def adj(): return random.choice('漂亮 | 蓝色 | 好看'.split('|'))\n", + "\n", + "def noun(): return random.choice('猫 | 女人 | 男人'.split('|'))\n", + "\n", + "def verb(): return random.choice('看着 | 坐着 '.split('|'))\n", + "\n", + "def noun2(): return random.choice('桌子 | 皮球'.split('|'))\n", + "\n", "def sentence(): return ''.join([adj(), noun(), verb(), noun2()])" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "' 蓝色 猫 坐着 皮球'" + "' 好看 女人 看着 桌子 '" ] }, - "execution_count": 46, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -160,7 +154,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## BSF 广度搜索 DFS 深度优先搜索" + "## BFS 广度优先搜索 DFS 深度优先搜索" ] }, { @@ -168,15 +162,16 @@ "metadata": {}, "source": [ "### BFS Breadth First Search \n", - "### DFS Deep First Search" + "### DFS Depth First Search" ] }, { "cell_type": "code", - "execution_count": 219, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ + "#定义无向图\n", "graph = {\n", " 'A' :'B B B C', \n", " 'B' : 'A C', \n", @@ -189,17 +184,18 @@ }, { "cell_type": "code", - "execution_count": 245, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ + "#去重\n", "for k in graph:\n", " graph[k] = set(graph[k].split())" ] }, { "cell_type": "code", - "execution_count": 230, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -208,47 +204,49 @@ "True" ] }, - "execution_count": 230, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "#非空数值均可以作为Bool类型True\n", "'元素' in set('1 2 3 4 5 6 7 8 9 10 100000 元素'.split())" ] }, { "cell_type": "code", - "execution_count": 229, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "元素\n", - "2\n", "1\n", - "100000\n", + "7\n", "9\n", + "100000\n", + "10\n", + "2\n", + "8\n", "4\n", "3\n", - "8\n", - "6\n", - "7\n", "5\n", - "10\n" + "元素\n", + "6\n" ] } ], "source": [ + "#集合通过split后不维持之前的顺序，但也不是随机的\n", "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, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -262,7 +260,7 @@ " 'F': {'E'}}" ] }, - "execution_count": 216, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -273,11 +271,23 @@ }, { "cell_type": "code", - "execution_count": 234, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "L = [0, 1, 2, 3, 4, 5]" + "Graph = networkx.Graph(graph)\n", + "networkx.draw(Graph, with_labels=True)" ] }, { @@ -289,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 209, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -297,21 +307,31 @@ "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 : C\n", + "A has been seen\n", + "C has been seen\n", + "A has been seen\n", + "B has been seen\n", " I am looking at : E\n", - " I am looking at : F\n" + " I am looking at : D\n", + " I am looking at : F\n", + "C has been seen\n", + "C has been seen\n", + "E has been seen\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", + " if node in seen: \n", + " print('{} has been seen'.format(node))\n", + " continue\n", " print(' I am looking at : {}'.format(node))\n", - " need_visited += graph[node]\n", - " \n", + " need_visited += graph[node] \n", " seen.add(node)" ] }, @@ -319,15 +339,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Deep First Search" + "## Depth First Search" ] }, { "cell_type": "code", - "execution_count": 287, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ + "#定义无向长图\n", "graph_long = {\n", " '1': '2 7',\n", " '2': '3', \n", @@ -346,13 +367,34 @@ }, { "cell_type": "code", - "execution_count": 288, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "for n in graph_long: graph_long[n] = graph_long[n].split()" ] }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Graph_long = networkx.Graph(graph_long)\n", + "networkx.draw(Graph_long, with_labels=True)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -362,17 +404,20 @@ }, { "cell_type": "code", - "execution_count": 283, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ + "#合并广度优先和深度优先解法\n", "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", + " if node in seen: \n", + " print('{} has been seen'.format(node))\n", + " continue\n", " print(' I am looking at : {}'.format(node))\n", " seen.add(node)\n", " new_discoveried = graph[node] \n", @@ -381,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 298, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -394,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 289, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -411,8 +456,12 @@ " I am looking at : 5\n", " I am looking at : 10\n", " I am looking at : 6\n", + "10 has been seen\n", + "5 has been seen\n", " I am looking at : 11\n", - " I am looking at : 12\n" + "5 has been seen\n", + " I am looking at : 12\n", + "11 has been seen\n" ] } ], @@ -422,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 290, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -435,12 +484,16 @@ " I am looking at : 4\n", " I am looking at : 5\n", " I am looking at : 6\n", + "5 has been seen\n", " I am looking at : 10\n", + "5 has been seen\n", " I am looking at : 11\n", " I am looking at : 12\n", + "11 has been seen\n", " I am looking at : 7\n", " I am looking at : 8\n", - " I am looking at : 9\n" + " I am looking at : 9\n", + "10 has been seen\n" ] } ], @@ -450,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 291, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -459,7 +512,7 @@ }, { "cell_type": "code", - "execution_count": 294, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -468,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 295, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -481,12 +534,16 @@ " I am looking at : 4\n", " I am looking at : 5\n", " I am looking at : 6\n", + "5 has been seen\n", " I am looking at : 10\n", + "5 has been seen\n", " I am looking at : 11\n", " I am looking at : 12\n", + "11 has been seen\n", " I am looking at : 7\n", " I am looking at : 8\n", - " I am looking at : 9\n" + " I am looking at : 9\n", + "10 has been seen\n" ] } ], @@ -496,7 +553,7 @@ }, { "cell_type": "code", - "execution_count": 296, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -505,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 297, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -522,8 +579,12 @@ " I am looking at : 5\n", " I am looking at : 10\n", " I am looking at : 6\n", + "10 has been seen\n", + "5 has been seen\n", " I am looking at : 11\n", - " I am looking at : 12\n" + "5 has been seen\n", + " I am looking at : 12\n", + "11 has been seen\n" ] } ], @@ -540,7 +601,7 @@ }, { "cell_type": "code", - "execution_count": 299, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -556,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 318, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -573,39 +634,12 @@ }, { "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, + "execution_count": 30, "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -615,37 +649,39 @@ } ], "source": [ + "air_route = networkx.Graph(air_route)\n", + "\n", "networkx.draw(air_route, with_labels=True)" ] }, { "cell_type": "code", - "execution_count": 334, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "def search_desitination(graph, start, destination):\n", + "def search_destination(graph, start, destination):\n", " pathes = [[start]]\n", " seen = set()\n", - " choosen_pathes = []\n", + " chosen_pathes = []\n", " while pathes:\n", " path = pathes.pop(0)\n", - " froniter = path[-1]\n", - " if froniter in seen: continue\n", + " frontier = path[-1]\n", + " if frontier in seen: continue\n", " # get new lines\n", " \n", - " for city in graph[froniter]:\n", + " for city in graph[frontier]:\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" + " seen.add(frontier)\n", + " return chosen_pathes" ] }, { "cell_type": "code", - "execution_count": 332, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -654,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 336, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -663,21 +699,14 @@ "'Shenzhen ✈️ -> Beijing ✈️ -> Guangzhou ✈️ -> Chiangmai'" ] }, - "execution_count": 336, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "draw_route(search_desitination(air_route, SZ, CM))" + "draw_route(search_destination(air_route, SZ, CM))" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -696,7 +725,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.6.5" } }, "nbformat": 4,