Upload New File

课件/0607生活中的优化问题/optimization-checkpoint.ipynb

+{
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 图的遍历"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'B', 'C', 'D', 'E', 'A', 'F'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "def BFS(graph, s):\n",
+    "    queue = [] # \n",
+    "    queue.append(s)\n",
+    "    seen = set() # \n",
+    "    while len(queue) > 0:\n",
+    "        vertex = queue.pop(0)\n",
+    "        nodes = graph[vertex]\n",
+    "        for w in nodes:\n",
+    "            if w not in seen:\n",
+    "                queue.append(w)\n",
+    "                seen.add(w)\n",
+    "\n",
+    "        # print(vertex)\n",
+    "\n",
+    "    print(seen)\n",
+    "\n",
+    "\n",
+    "graph = {\n",
+    "    \"A\": [\"B\", \"C\"],\n",
+    "    \"B\": [\"A\", \"C\", \"D\"],\n",
+    "    \"C\": [\"A\", \"B\", \"E\", \"D\"],\n",
+    "    \"D\": [\"B\", \"C\", \"E\", \"F\"],\n",
+    "    \"F\": [\"D\"],\n",
+    "    \"E\": [\"C\", \"D\"],\n",
+    "}\n",
+    "\n",
+    "BFS(graph, \"F\")\n",
+    "#\n",
+    "# def breadth_travel(root):\n",
+    "#     \"\"\"利⽤队列实现树的层次遍历\"\"\"\n",
+    "#     if root == None:\n",
+    "#         return\n",
+    "#     queue = []\n",
+    "#     queue.append(root)\n",
+    "#     while queue:\n",
+    "#         node = queue.pop(0)\n",
+    "#         print(node.elem)\n",
+    "#         if node.lchild is not None:\n",
+    "#             queue.append(node.lchild)\n",
+    "#         if node.rchild != None:\n",
+    "#             queue.append(node.rchild)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# dijkstra heap"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import heapq as hp\n",
+    "import math\n",
+    "\n",
+    "graph = {\n",
+    "\n",
+    "    \"A\": {\"B\": 5, \"C\": 1},\n",
+    "    \"B\": {\"A\": 5, \"C\": 2, \"D\": 1},\n",
+    "    \"C\": {\"A\": 1, \"B\": 2, \"E\": 8, \"D\": 4},\n",
+    "    \"D\": {\"B\": 1, \"C\": 4, \"E\": 3, \"F\": 6},\n",
+    "    \"F\": {\"D\": 6},\n",
+    "    \"E\": {\"C\": 8, \"D\": 3},\n",
+    "}\n",
+    "\n",
+    "\n",
+    "def init_distance(graph, s):\n",
+    "    distance = {s: 0}\n",
+    "    for key in graph:\n",
+    "        if key != s:\n",
+    "            distance[key] = math.inf\n",
+    "    return distance\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<module 'heapq' from '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/heapq.py'>\n",
+      "{'A': 0, 'B': inf, 'C': inf, 'D': inf, 'F': inf, 'E': inf}\n",
+      "seen:    {'A'}\n",
+      "nodes:    dict_keys(['B', 'C'])\n",
+      "change distance for B:    {'A': 0, 'B': 5, 'C': inf, 'D': inf, 'F': inf, 'E': inf}\n",
+      "change distance for C:    {'A': 0, 'B': 5, 'C': 1, 'D': inf, 'F': inf, 'E': inf}\n",
+      "seen:    {'A', 'C'}\n",
+      "nodes:    dict_keys(['A', 'B', 'E', 'D'])\n",
+      "change distance for B:    {'A': 0, 'B': 3, 'C': 1, 'D': inf, 'F': inf, 'E': inf}\n",
+      "change distance for E:    {'A': 0, 'B': 3, 'C': 1, 'D': inf, 'F': inf, 'E': 9}\n",
+      "change distance for D:    {'A': 0, 'B': 3, 'C': 1, 'D': 5, 'F': inf, 'E': 9}\n",
+      "seen:    {'A', 'B', 'C'}\n",
+      "nodes:    dict_keys(['A', 'C', 'D'])\n",
+      "change distance for D:    {'A': 0, 'B': 3, 'C': 1, 'D': 4, 'F': inf, 'E': 9}\n",
+      "seen:    {'D', 'A', 'B', 'C'}\n",
+      "nodes:    dict_keys(['B', 'C', 'E', 'F'])\n",
+      "change distance for E:    {'A': 0, 'B': 3, 'C': 1, 'D': 4, 'F': inf, 'E': 7}\n",
+      "change distance for F:    {'A': 0, 'B': 3, 'C': 1, 'D': 4, 'F': 10, 'E': 7}\n",
+      "seen:    {'D', 'A', 'B', 'C'}\n",
+      "nodes:    dict_keys(['A', 'C', 'D'])\n",
+      "seen:    {'D', 'A', 'B', 'C'}\n",
+      "nodes:    dict_keys(['B', 'C', 'E', 'F'])\n",
+      "seen:    {'B', 'D', 'C', 'E', 'A'}\n",
+      "nodes:    dict_keys(['C', 'D'])\n",
+      "seen:    {'B', 'D', 'C', 'E', 'A'}\n",
+      "nodes:    dict_keys(['C', 'D'])\n",
+      "seen:    {'B', 'D', 'C', 'E', 'A', 'F'}\n",
+      "nodes:    dict_keys(['D'])\n",
+      "{'A': 0, 'B': 3, 'C': 1, 'D': 4, 'F': 10, 'E': 7}\n"
+     ]
+    }
+   ],
+   "source": [
+    "def dijkstra(graph, s):\n",
+    "    pqueue = []\n",
+    "    hp.heappush(pqueue, (0, s)) #\n",
+    "    print(hp)\n",
+    "#   seen = set()\n",
+    "    distance = init_distance(graph, s)\n",
+    "    print(distance)\n",
+    "    while len(pqueue) > 0:\n",
+    "        pair = hp.heappop(pqueue)\n",
+    "        dist = pair[0] # \n",
+    "        node = pair[1] #\n",
+    "#         seen.add(node)\n",
+    "        print(\"seen:   \", seen)\n",
+    "        nodes = graph[node].keys() # \n",
+    "        print(\"nodes:   \", nodes)\n",
+    "        #\n",
+    "        for w in nodes:\n",
+    "            if dist + graph[node][w] < distance[w]:\n",
+    "                hp.heappush(pqueue, (dist + graph[node][w], w))\n",
+    "                distance[w] = dist + graph[node][w]\n",
+    "                print(f\"change distance for {w}:   \", distance)\n",
+    "    return distance\n",
+    "\n",
+    "\n",
+    "d = dijkstra(graph, \"A\")\n",
+    "print(d)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# dijkstra 动态规划"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 3, 1, 4, 7, 10]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "10"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Inf = float('inf')\n",
+    "Adjacent = [[0, 5, 1, Inf, Inf, Inf],\n",
+    "            [5, 0, 2, 1, Inf, Inf],\n",
+    "            [1, 2, 0, 4, 8, Inf],\n",
+    "            [Inf, 1, 4, 0, 3, 6],\n",
+    "            [Inf, Inf, 8, 3, 0, Inf],\n",
+    "            [Inf, Inf, Inf, 6, Inf, 0]]\n",
+    "Src, Dst, N = 0, 5, 6\n",
+    "\n",
+    "\n",
+    "# 动态规划\n",
+    "def dijstra(adj, src, dst, n):\n",
+    "    dist = [Inf] * n  #\n",
+    "    dist[src] = 0\n",
+    "    book = [0] * n  # 记录已经确定的顶点\n",
+    "    # 每次找到起点到该点的最短途径\n",
+    "    u = src\n",
+    "    for _ in range(n - 1):  # 找n-1次\n",
+    "        book[u] = 1  # 已经确定\n",
+    "        # 更新距离并记录最小距离的结点\n",
+    "        next_u, minVal = None, float('inf')\n",
+    "        for v in range(n):  # w\n",
+    "            w = adj[u][v]\n",
+    "            if w == Inf:  # 结点u和v之间没有边\n",
+    "                continue\n",
+    "            if not book[v] and dist[u] + w < dist[v]:  # 判断结点是否已经确定了\n",
+    "                dist[v] = dist[u] + w\n",
+    "                if dist[v] < minVal:\n",
+    "                    next_u, minVal = v, dist[v]\n",
+    "        # 开始下一轮遍历\n",
+    "        u = next_u\n",
+    "    print(dist)\n",
+    "    return dist[dst]\n",
+    "\n",
+    "\n",
+    "dijstra(Adjacent, Src, Dst, N)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 模拟退火"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "最小值 400\n",
+      "最优值 40.0 -32154.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from __future__ import division\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import math\n",
+    " \n",
+    "#define aim function\n",
+    "def aimFunction(x):\n",
+    "    y=x**3-60*x**2-4*x+6\n",
+    "    return y\n",
+    "x=[i/10 for i in range(1000)]\n",
+    "y=[0 for i in range(1000)]\n",
+    "for i in range(1000):\n",
+    "    y[i]=aimFunction(x[i])\n",
+    "\n",
+    "plt.plot(x,y)\n",
+    "plt.show()\n",
+    "\n",
+    "print('最小值',y.index(min(y)))   \n",
+    "print(\"最优值\",x[400], min(y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "39.69856448101894 -32147.369845045607\n"
+     ]
+    }
+   ],
+   "source": [
+    "T=1000 #initiate temperature\n",
+    "Tmin=10 #minimum value of terperature\n",
+    "x=np.random.uniform(low=0,high=100)#initiate x\n",
+    "k=50 #times of internal circulation \n",
+    "y=0#initiate result\n",
+    "t=0#time\n",
+    "while T>=Tmin:\n",
+    "    for i in range(k):\n",
+    "        #calculate y\n",
+    "        y=aimFunction(x)\n",
+    "        #generate a new x in the neighboorhood of x by transform function\n",
+    "        xNew=x+np.random.uniform(low=-0.055,high=0.055)*T\n",
+    "        if (0<=xNew and xNew<=100):\n",
+    "            yNew=aimFunction(xNew)\n",
+    "            if yNew-y<0:\n",
+    "                x=xNew\n",
+    "            else:\n",
+    "                #metropolis principle\n",
+    "                p=math.exp(-(yNew-y)/T)\n",
+    "                r=np.random.uniform(low=0,high=1)\n",
+    "                if r<p:\n",
+    "                    x=xNew\n",
+    "    t+=1\n",
+    "#     print(t)\n",
+    "    T=1000/(1+t)\n",
+    "    \n",
+    "print (x,aimFunction(x))"
+   ]
+  },
+  {
+   "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.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}