Rhichard_Koh_FP_Tree.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install wikipedia-api\n",
        "import wikipediaapi\n",
        "import sys"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aw6l6xgRVU1M",
        "outputId": "add6a384-5e22-4738-83a2-ebabbe27c04f"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting wikipedia-api\n",
            "  Downloading Wikipedia-API-0.5.4.tar.gz (18 kB)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from wikipedia-api) (2.23.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->wikipedia-api) (2022.9.24)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->wikipedia-api) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->wikipedia-api) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->wikipedia-api) (1.24.3)\n",
            "Building wheels for collected packages: wikipedia-api\n",
            "  Building wheel for wikipedia-api (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for wikipedia-api: filename=Wikipedia_API-0.5.4-py3-none-any.whl size=13476 sha256=f7c5667afdb41c9c6c7e21d7a2fde48521ec293c34902438defd83e591807ddf\n",
            "  Stored in directory: /root/.cache/pip/wheels/d3/24/56/58ba93cf78be162451144e7a9889603f437976ef1ae7013d04\n",
            "Successfully built wikipedia-api\n",
            "Installing collected packages: wikipedia-api\n",
            "Successfully installed wikipedia-api-0.5.4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "6gHRctoNU9it"
      },
      "outputs": [],
      "source": [
        "class FPTree:\n",
        "    class Node:\n",
        "        def __init__(self, item, frequency, parent):\n",
        "            self.item = item\n",
        "            self.freq = frequency\n",
        "            self.nodeLink = None\n",
        "            self.parent = parent\n",
        "            self.children = {}\n",
        "\n",
        "        def _counter(self, frequency):\n",
        "            self.freq += frequency\n",
        "\n",
        "        def display(self):\n",
        "            print(f'item: {self.item}, freq: {self.freq}', end='')\n",
        "            if len(self.children) > 0:\n",
        "                print(\",[\", end='')\n",
        "            for c in self.children.values():\n",
        "                print(\"[\", end='')\n",
        "                c.display()\n",
        "                if len(c.children) == 0:\n",
        "                    print(\"]\", end='')\n",
        "            print(\"]\", end='')\n",
        "\n",
        "    def getData(self, wikipages):\n",
        "        self.data = []\n",
        "        for page in wikipages:\n",
        "            p_wiki = wiki_wiki.page(page)\n",
        "            self.data.append(p_wiki.text.split(sep=' '))\n",
        "        self.Dict = {}\n",
        "        for i in self.data:\n",
        "            self.Dict[frozenset(i)] = 1\n",
        "        return self.Dict\n",
        "\n",
        "    def makeTree(self, data, freqThreshold=2):\n",
        "        HeaderTable = {}\n",
        "        for page in data:\n",
        "            for item in page:\n",
        "                HeaderTable[item] = HeaderTable.get(item, 0) + data[page]\n",
        "        for i in list(HeaderTable):\n",
        "            if HeaderTable[i] < freqThreshold:\n",
        "                del (HeaderTable[i])\n",
        "\n",
        "        freqItemSet = set(HeaderTable.keys())\n",
        "\n",
        "        if len(freqItemSet) == 0:\n",
        "            return None, None\n",
        "\n",
        "        for i in HeaderTable:\n",
        "            HeaderTable[i] = [HeaderTable[i], None]\n",
        "\n",
        "        FPTree = self.Node('root', 1, None)\n",
        "        for itemset, freq in data.items():\n",
        "            frequent_transaction = {}\n",
        "            for item in itemset:\n",
        "                if item in freqItemSet:\n",
        "                    frequent_transaction[item] = HeaderTable[item][0]\n",
        "            if len(frequent_transaction) > 0:\n",
        "                ordered_itemset = [x[0] for x in sorted(frequent_transaction.items(), key=lambda y: y[1], reverse=True)]\n",
        "                self._update(ordered_itemset, FPTree, HeaderTable, freq)\n",
        "        return FPTree, HeaderTable\n",
        "\n",
        "    def _update(self, itemset, FPTree, HeaderTable, freq):\n",
        "        if itemset[0] in FPTree.children:\n",
        "            FPTree.children[itemset[0]]._counter(freq)\n",
        "        else:\n",
        "            FPTree.children[itemset[0]] = self.Node(itemset[0], freq, FPTree)\n",
        "\n",
        "            if HeaderTable[itemset[0]][1] == None:\n",
        "                HeaderTable[itemset[0]][1] = FPTree.children[itemset[0]]\n",
        "            else:\n",
        "                self._updateNode(HeaderTable[itemset[0]][1], FPTree.children[itemset[0]])\n",
        "\n",
        "        if len(itemset) > 1:\n",
        "            self._update(itemset[1::], FPTree.children[itemset[0]], HeaderTable, freq)\n",
        "\n",
        "    def _updateNode(self, xNode, yNode):\n",
        "        while (xNode.nodeLink != None):\n",
        "            xNode = xNode.nodeLink\n",
        "\n",
        "        xNode.nodeLink = yNode\n",
        "\n",
        "    def _uptransveral(self, leaf_Node, path):\n",
        "        if leaf_Node.parent != None:\n",
        "            path.append(leaf_Node.item)\n",
        "            self._uptransveral(leaf_Node.parent, path)\n",
        "\n",
        "    def _findPath(self, basePat, treeNode):\n",
        "        conditionalPatternBase = {}\n",
        "\n",
        "        while treeNode != None:\n",
        "            path = []\n",
        "            self._uptransveral(treeNode, path)\n",
        "            if len(path) > 1:\n",
        "                conditionalPatternBase[frozenset(path[1:])] = treeNode.freq\n",
        "            treeNode = treeNode.nodeLink\n",
        "\n",
        "        return conditionalPatternBase\n",
        "\n",
        "    def mine(self, FPTree, HeaderTable, threshold, prefix, frequent_itemset):\n",
        "        basePatList = [x[0] for x in sorted(HeaderTable.items(), key=lambda y: y[1][0])]\n",
        "        for basePat in basePatList:\n",
        "            frequentset = prefix.copy()\n",
        "            frequentset.add(basePat)\n",
        "            frequent_itemset.append(frequentset)\n",
        "            conditionalPatternBases = self._findPath(basePat, HeaderTable[basePat][1])\n",
        "            conditionalFPTree, conditionalHeader = self.makeTree(conditionalPatternBases, threshold)\n",
        "            if conditionalHeader != None:\n",
        "                self.mine(conditionalFPTree, conditionalHeader, threshold, frequentset, frequent_itemset)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "DSA = ['Deep reinforcement learning',\n",
        " 'Dehaene–Changeux model',\n",
        " 'Diffusion map',\n",
        " 'Diffusion model',\n",
        " 'Dominance-based rough set approach',\n",
        " 'Dynamic time warping',\n",
        " 'Cardinal tree',\n",
        " 'Collection (abstract data type)',\n",
        " 'Container (abstract data type)',\n",
        " 'Linked data structure',\n",
        " 'List (abstract data type)',\n",
        " 'Set (abstract data type)',\n",
        " 'Stack (abstract data type)',\n",
        " 'Tree (data structure)',\n",
        " 'Peek (data type operation)',\n",
        " 'Pile (abstract data type)',\n",
        " 'Priority queue',\n",
        " 'Double-ended priority queue',\n",
        " 'Double-ended queue',\n",
        " 'Magic state distillation',\n",
        " 'Plotting algorithms for the Mandelbrot set',\n",
        " 'Manhattan address algorithm',\n",
        " 'The Master Algorithm',\n",
        " 'Maze generation algorithm',\n",
        " 'Maze-solving algorithm',\n",
        " 'Medical algorithm',\n",
        " \"Miller's recurrence algorithm\",\n",
        " 'Multiplicative weight update method',\n",
        " 'Sardinas–Patterson algorithm',\n",
        " 'Sequential algorithm',\n",
        " 'Serial algorithm',\n",
        " 'Shapiro Senapathy algorithm',\n",
        " 'Shuffling algorithm',\n",
        " 'Sieve of Eratosthenes',\n",
        " 'Sieve of Pritchard',\n",
        " 'Simulation algorithms for atomic DEVS',\n",
        " 'Simulation algorithms for coupled DEVS',\n",
        " 'Snap rounding',\n",
        " 'Spreading activation',\n",
        " 'Super-recursive algorithm',\n",
        " 'Adaptive algorithm',\n",
        " 'Algorism',\n",
        " 'The Algorithm Auction',\n",
        " 'Algorithm characterizations',\n",
        " 'Algorithm engineering',\n",
        " 'Algorithmic game theory',\n",
        " 'Algorithmic logic',\n",
        " 'Algorithmic management',\n",
        " 'Algorithmic mechanism design',\n",
        " 'Algorithmic paradigm',\n",
        " 'Algorithmic Puzzles',\n",
        " 'Algorithmic transparency',\n",
        " 'Algorithms and Combinatorics',\n",
        " 'Algorithms of Oppression',\n",
        " 'Automate This',\n",
        " 'AVT Statistical filtering algorithm',\n",
        " 'Recursion (computer science)',\n",
        " 'Recursive acronym',\n",
        " 'Recursive definition',\n",
        " 'Recursive function',\n",
        " 'Recursive islands and lakes',\n",
        " 'Recursive language',\n",
        " 'Reentrancy (computing)',\n",
        " 'A* search algorithm',\n",
        " 'All nearest smaller values',\n",
        " 'Alpha–beta pruning',\n",
        " 'Amplitude amplification',\n",
        " 'Any-angle path planning',\n",
        " 'Anytime A*',\n",
        " 'Anytime algorithm',\n",
        " 'Search game',\n",
        " 'Search tree',\n",
        " 'Search-based software engineering',\n",
        " 'Siamese method',\n",
        " 'Similarity search',\n",
        " 'SMA*',\n",
        " 'Spiral hashing',\n",
        " 'Spreading activation',\n",
        " 'SSS*',\n",
        " 'Stack search',\n",
        " 'State space search',\n",
        " 'Sudoku solving algorithms',\n",
        " 'Late move reductions',\n",
        " 'Lexicographic breadth-first search',\n",
        " 'Lifelong Planning A*',\n",
        " 'Linear hashing',\n",
        " 'Linear probing',\n",
        " 'Linear search',\n",
        " 'Linear-quadratic regulator rapidly-exploring random tree',\n",
        " 'Locality-sensitive hashing',\n",
        " 'Look-ahead (backtracking)',\n",
        " 'Genetic algorithm',\n",
        " 'Geometric hashing',\n",
        " 'Gestalt pattern matching',\n",
        " \"God's algorithm\",\n",
        " 'Golden-section search',\n",
        " 'Graphplan',\n",
        " \"Grover's algorithm\",\n",
        " 'Nearest neighbor search',\n",
        " 'NewsRx']"
      ],
      "metadata": {
        "id": "MdBSOlH1VvLN"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if __name__ == '__main__':\n",
        "    sys.setrecursionlimit(60000)\n",
        "\n",
        "    wiki_wiki = wikipediaapi.Wikipedia(language='en', extract_format=wikipediaapi.ExtractFormat.WIKI)\n",
        "\n",
        "    wiki = [\"Genetic algorithm\", \"A* search algorithm\", \"Search tree\", \"Recursion (computer science)\", \"Linear search\"]\n",
        "\n",
        "    test = FPTree()\n",
        "\n",
        "    # data = test.get_data(DSA) ## ran out of memory with DSA list because it's too large.\n",
        "\n",
        "    data = test.getData(wiki)\n",
        "\n",
        "    FPtree, HeaderTable = test.makeTree(data)\n",
        "\n",
        "    frequent_itemset = []\n",
        "\n",
        "    test.mine(FPtree, HeaderTable, 5, set([]), frequent_itemset)\n",
        "\n",
        "    print(\"All frequent itemsets:\")\n",
        "    print(frequent_itemset)\n",
        "    print(f\"FPtree Children {FPtree.children}\")\n",
        "    print(f\"Header Table {HeaderTable}\")\n",
        "    print(test.Dict)"
      ],
      "metadata": {
        "id": "fyK1FDwSVjgK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5241ee53-21fb-4623-d049-ce592129af5d"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All frequent itemsets:\n",
            "[{'(and'}, {'notion'}, {'general'}, {'intended'}, {'attempts'}, {'(as'}, {'high'}, {'evaluation'}, {'commonly'}, {'published'}, {'Other'}, {'algorithm.'}, {'combine'}, {'essentially'}, {'blocks'}, {'limited'}, {'languages,'}, {'needs'}, {'define'}, {'references'}, {'you'}, {'J.'}, {'performance,'}, {'candidate'}, {'speed'}, {'structure.'}, {'i.e.,'}, {'iterations'}, {'occur'}, {'similar'}, {'subset'}, {'construction'}, {'(e.g.'}, {'however,'}, {'complex'}, {'procedure'}, {'pair'}, {'online'}, {'algorithms,'}, {'hybrid'}, {'Its'}, {'higher'}, {'items,'}, {'natural'}, {'describes'}, {'testing'}, {'nodes.'}, {'determine'}, {'effective'}, {'adding'}, {'operators,'}, {'combination'}, {'pick'}, {'require'}, {'array'}, {'search.'}, {'regarding'}, {'proposed'}, {'difficult'}, {'multiple'}, {'therefore'}, {'permits'}, {'parameters'}, {'length,'}, {'working'}, {'definition'}, {'originally'}, {'overall'}, {'and,'}, {'evaluated'}, {'Linear'}, {'optimal'}, {'cases,'}, {'conditions'}, {'good'}, {'selection'}, {'worse'}, {'necessary'}, {'kind'}, {'makes'}, {'work'}, {'programming,'}, {'likely'}, {'comparison'}, {'Algorithm'}, {'provides'}, {'able'}, {'Like'}, {'problems.'}, {'help'}, {'processing'}, {'items'}, {'especially'}, {'waste'}, {'cannot'}, {'maintain'}, {'generates'}, {'variants,'}, {'useful'}, {'difference'}, {'numbers'}, {'current'}, {'three'}, {'direct'}, {'implement'}, {'approximate'}, {'environment'}, {'bit'}, {'design'}, {'research'}, {'starts'}, {'Artificial'}, {'child'}, {'arguably'}, {'iterative'}, {'computation'}, {'solutions'}, {'about'}, {'successive'}, {'avoid'}, {'applications'}, {'(see'}, {'potentially'}, {'object'}, {'lead'}, {'continues'}, {'criterion'}, {'objects'}, {'simply'}, {'well'}, {'initialize'}, {'modifications'}, {'solution.'}, {'away'}, {'primarily'}, {'construct'}, {'results'}, {'possibly'}, {'case.'}, {'via'}, {'solve'}, {'planning,'}, {'arrays'}, {'further'}, {'selects'}, {'prevent'}, {'used,'}, {'class'}, {'attempt'}, {'appear'}, {'reached'}, {'Nils'}, {'adaptive'}, {'whereas'}, {'along'}, {'model'}, {'game,'}, {'selected,'}, {'Turing'}, {'and/or'}, {'integers,'}, {'implement,'}, {'Institute'}, {'context'}, {'global'}, {'algorithms.'}, {'They'}, {'starting'}, {'broken'}, {'decreasing'}, {'Starting'}, {'whether'}, {'belongs'}, {'represent'}, {'strings'}, {'change'}, {'appropriate'}, {'versus'}, {'loop'}, {'(the'}, {'programming'}, {'defining'}, {'components'}, {'our'}, {'way,'}, {'were'}, {'diverse'}, {'types'}, {'updated'}, {'operations.'}, {'provide'}, {'other.'}, {'moves'}, {'satisfies'}, {'programs,'}, {'Such'}, {'effectively'}, {'stored'}, {'particularly'}, {'variants'}, {'reached.'}, {'aim'}, {'how'}, {'understand'}, {'systems,'}, {'clear'}, {'inherently'}, {'form'}, {'(such'}, {'Thus,'}, {'instead'}, {'every'}, {'level'}, {'highly'}, {'study'}, {'range'}, {'portion'}, {'data.'}, {'techniques'}, {'linked'}, {'lower'}, {'inefficient'}, {'quickly'}, {'essential'}, {'long'}, {'solved'}, {'later'}, {'certain'}, {'Design'}, {'developed'}, {'see'}, {'condition'}, {'typically'}, {'defined'}, {'part'}, {'product'}, {'quality'}, {'computational'}, {'steps'}, {'main'}, {'General'}, {'structural'}, {'depending'}, {'related'}, {'select'}, {'technique'}, {'action'}, {'expected'}, {'i.e.'}, {'affected'}, {'0'}, {'Some'}, {'addition'}, {'particular,'}, {'whole'}, {'idea'}, {'While'}, {'replacing'}, {'problem.'}, {'generate'}, {'child,'}, {'generated'}, {'traverse'}, {'lowest'}, {'subject'}, {'Each'}, {'terminating'}, {'theorem'}, {'respect'}, {'could'}, {'information'}, {'others,'}, {'include:'}, {'parameters.'}, {'Because'}, {'behind'}, {'optimization'}, {'promising'}, {'complete'}, {'better'}, {'smaller'}, {'probability,'}, {'components.'}, {'examples'}, {'That'}, {'open'}, {'although'}, {'was'}, {'partial'}, {'implicitly'}, {'guarantees'}, {'heuristic'}, {'consists'}, {'heuristics'}, {'through'}, {'knowledge'}, {'frequently'}, {'add'}, {'Python'}, {'strings.'}, {'classic'}, {'property'}, {'had'}, {'sets'}, {'suitable'}, {'response'}, {'get'}, {'Computer'}, {'series'}, {'As'}, {'control'}, {'programs'}, {'among'}, {'position.'}, {'instance,'}, {'domain'}, {'mechanism'}, {'(possibly)'}, {'There'}, {'orders'}, {'reason'}, {'distance'}, {'reduce'}, {'represents'}, {'probabilities'}, {'processes'}, {'down'}, {'mean'}, {'added,'}, {'expression'}, {'Research'}, {'efficiently'}, {'reference'}, {'variation'}, {'computing'}, {'stochastic'}, {'points'}, {'typical'}, {'(also'}, {'compared'}, {'zero'}, {'involved'}, {'≤'}, {'leading'}, {'operation'}, {'value.'}, {'actual'}, {'\\\\varepsilon'}, {'running'}, {'heap,'}, {'On'}, {'case.\\nIn'}, {'test'}, {'maintaining'}, {'log\\n'}, {'depth'}, {'(a'}, {'>0}\\n'}, {'grammars'}, {'ISBN'}, {'table'}, {'depth-first'}, {'version'}, {'required'}, {'One'}, {'guaranteed'}, {'>\\n'}, {'referred'}, {'what'}, {'on,'}, {'pseudocode'}, {'here'}, {'expressed'}, {'+'}, {'With'}, {'Fibonacci'}, {'O\\n'}, {'hash'}, {'cases'}, {'hold'}, {'directly'}, {'branch'}, {'f\\n'}, {'finds'}, {'one.'}, {'h\\n'}, {\"node's\"}, {'f'}, {'arbitrarily'}, {'happens'}, {'memory'}, {'Thus'}, {'removed'}, {'Alternatively,'}, {'C'}, {'least'}, {'becomes'}, {'target.'}, {'unbounded'}, {'call'}, {'.'}, {'steps,'}, {'infinite'}, {'sequence'}, {',\\n'}, {'eventually'}, {'smallest'}, {'x'}, {'positive'}, {'When'}, {'traversal'}, {'heap'}, {'definitions'}, {'original'}, {'significantly'}, {'takes'}, {'track'}, {'considering'}, {'memory.'}, {'complexity,'}, {'keeps'}, {'hence'}, {'ending'}, {','}, {'example'}, {'nodes,'}, {'path'}, {'concepts'}, {'true'}, {'grow'}, {'pre-process'}, {'factor'}, {'g'}, {'x\\n'}, {'compute'}, {'terminate'}, {'node,'}, {'y\\n'}, {'constant'}, {'ε\\n'}, {'contained'}, {'\\u2061\\n'}, {'time.'}, {'times'}, {'target'}, {'logarithmic'}, {'available'}, {'Every'}, {'note'}, {'start'}, {'possibility'}, {'proof'}, {'pathological'}, {'−'}, {'manner,'}, {'.\\n'}, {'pointers'}, {'Binary'}, {'children,'}, {'ordered'}, {'References'}, {'type'}, {'children'}, {'sorted'}, {'necessarily'}, {'height'}, {'say'}, {'worst-case'}, {'left'}, {'third'}, {'passing'}, {'space.'}, {'{\\\\frac'}, {'data,'}, {'string'}, {'advantage'}, {'insertion'}, {'exception'}, {'array.'}, {'tree.'}, {'=='}, {'comparable'}, {'need'}, {'a\\n'}, {'beginning'}, {'content'}, {'absence'}, {'sort'}, {'desired'}, {'(for'}, {'method.'}, {'Therefore,'}, {'short'}, {'practice'}, {'extra'}, {'build'}, {'searched'}, {'index'}, {'once,'}, {'\\n\\n'}, {'1,'}, {'does'}, {'between'}, {'minimum'}, {'size'}, {'common'}, {'finite'}, {'based'}, {'requires'}, {'own'}, {'initial'}, {'using'}, {'solution,'}, {'best'}, {'right'}, {'next'}, {'terminates'}, {'into'}, {'allowing'}, {'up'}, {'science'}, {'decrease'}, {'depends'}, {'do'}, {'(or'}, {'reduced'}, {'application'}, {'maximum'}, {'low'}, {'rule'}, {'always'}, {'including'}, {'implementations'}, {'efficiency'}, {'take'}, {'These'}, {'entirely'}, {'there'}, {'solving'}, {'performed'}, {'significant'}, {'shown'}, {'exact'}, {'fixed'}, {'though'}, {'rather'}, {'so'}, {'basic'}, {'making'}, {'result,'}, {'implementation'}, {'support'}, {'dynamic'}, {'building'}, {'different'}, {'generally'}, {'larger'}, {'already'}, {'less'}, {'theory'}, {'no'}, {'–'}, {'result'}, {'like'}, {'still'}, {'position'}, {'designed'}, {'function,'}, {'approach'}, {'valid'}, {'contains'}, {'nodes'}, {'sum'}, {'set'}, {'terms'}, {'By'}, {'-'}, {'those'}, {'problems'}, {'element'}, {'problems,'}, {'include'}, {'either'}, {'trees'}, {'length'}, {'several'}, {'due'}, {'above'}, {'usually'}, {'involves'}, {'method'}, {'without'}, {'easily'}, {'near'}, {'it.'}, {'structures'}, {'particular'}, {'problem'}, {'seen'}, {'process'}, {'methods'}, {'equivalent'}, {'small'}, {'iteration'}, {'proved'}, {'point'}, {'considered'}, {'termination'}, {'special'}, {'may'}, {'whose'}, {'linear'}, {'perform'}, {'applied'}, {'specific'}, {'since'}, {'them'}, {'standard'}, {'space,'}, {'means'}, {'place'}, {'while'}, {'move'}, {'important'}, {'case,'}, {'would'}, {'exponential'}, {'An'}, {'instance'}, {'created'}, {'alternative'}, {'finding'}, {'space'}, {'much'}, {'list'}, {'(which'}, {'solution'}, {'efficiency.'}, {'few'}, {'called'}, {'is,'}, {'implemented'}, {'A'}, {'state'}, {'another'}, {'variable'}, {'described'}, {'allows'}, {'average'}, {'never'}, {'Search'}, {'new'}, {'algorithm,'}, {'−\\n'}, {'stores'}, {'n,'}, {'b\\n'}, {'{\\n'}, {'node.'}, {'following'}, {'b'}, {'>'}, {'n\\n'}, {'corresponding'}, {'once'}, {'elements,'}, {'per'}, {'occurs'}, {'end'}, {'equally'}, {'case'}, {'check'}, {'If'}, {'=\\n'}, {'tree,'}, {'itself'}, {'tree'}, {'1'}, {'0\\n'}, {'cost'}, {'3'}, {'2'}, {'science,'}, {'many'}, {'performance'}, {'one'}, {'such'}, {'value'}, {'find'}, {'any'}, {'values'}, {'because'}, {'more'}, {'example,'}, {'greater'}, {'even'}, {'allow'}, {'simple'}, {'used'}, {'way'}, {'order'}, {'structure'}, {'use'}, {'or'}, {'this'}, {'found'}, {'practical'}, {'when'}, {'they'}, {'node'}, {'complexity'}, {'only'}, {'known'}, {'entire'}, {'given'}, {'must'}, {'by'}, {'data'}, {'list,'}, {'However,'}, {'repeated'}, {'these'}, {'uses'}, {'their'}, {'function'}, {'might'}, {'meaning'}, {'been'}, {'we'}, {'very'}, {'step'}, {'also'}, {'both'}, {'until'}, {'first'}, {'search,'}, {'possible'}, {'second'}, {'operations'}, {'faster'}, {'being'}, {'worst'}, {'This'}, {'within'}, {'elements'}, {'It'}, {''}, {'2\\n'}, {'searching'}, {'return'}, {'<'}, {'1\\n'}, {'+\\n'}, {'='}, {'{\\\\displaystyle'}, {')\\n'}, {'\\n'}, {'n'}, {'(\\n'}, {'≤\\n'}, {'time'}, {'computer'}, {'time', 'computer'}, {'which'}, {'number'}, {'search'}, {'its'}, {'be'}, {'most'}, {'large'}, {'than'}, {'some'}, {'other'}, {'an'}, {'other', 'an'}, {'it'}, {'an', 'it'}, {'it', 'time'}, {'an', 'it', 'time'}, {'other', 'it'}, {'as'}, {'as', 'an'}, {'as', 'time'}, {'as', 'an', 'time'}, {'as', 'it'}, {'an', 'as', 'it'}, {'as', 'it', 'time'}, {'an', 'as', 'it', 'time'}, {'as', 'other'}, {'where'}, {'can'}, {'is'}, {'in'}, {'if'}, {'not'}, {'a'}, {'to'}, {'The'}, {'are'}, {'single'}, {'at'}, {'have'}, {'have', 'other'}, {'have', 'an'}, {'often'}, {'often', 'other'}, {'often', 'an'}, {'often', 'time'}, {'often', 'an', 'time'}, {'often', 'it'}, {'often', 'an', 'it'}, {'often', 'it', 'time'}, {'often', 'an', 'it', 'time'}, {'often', 'have'}, {'algorithm'}, {'other', 'algorithm'}, {'an', 'algorithm'}, {'time', 'algorithm'}, {'time', 'an', 'algorithm'}, {'it', 'algorithm'}, {'an', 'it', 'algorithm'}, {'time', 'it', 'algorithm'}, {'time', 'an', 'it', 'algorithm'}, {'often', 'algorithm'}, {'have', 'algorithm'}, {'often', 'have', 'algorithm'}, {'algorithms'}, {'that'}, {'will'}, {'all'}, {'but'}, {'from'}, {'each'}, {'In'}, {'then'}, {'of'}, {'equal'}, {'two'}, {'for'}, {'for', 'other'}, {'for', 'an'}, {'for', 'time'}, {'for', 'an', 'time'}, {'for', 'have'}, {'same'}, {'has'}, {'the'}, {'For'}, {'and'}, {'with'}, {'efficient'}, {'binary'}, {'on'}]\n",
            "FPtree Children {'time': <__main__.FPTree.Node object at 0x7fcf5f8a1550>, 'other': <__main__.FPTree.Node object at 0x7fcf5f7a0590>, 'then': <__main__.FPTree.Node object at 0x7fcf5f7c9090>}\n",
            "Header Table {'(and': [2, <__main__.FPTree.Node object at 0x7fcf5f84e150>], 'does': [3, <__main__.FPTree.Node object at 0x7fcf5f820a90>], 'notion': [2, <__main__.FPTree.Node object at 0x7fcf5f84e190>], 'general': [2, <__main__.FPTree.Node object at 0x7fcf5f84e1d0>], 'between': [3, <__main__.FPTree.Node object at 0x7fcf5f820ad0>], 'intended': [2, <__main__.FPTree.Node object at 0x7fcf5f84e210>], 'attempts': [2, <__main__.FPTree.Node object at 0x7fcf5f84e250>], 'many': [4, <__main__.FPTree.Node object at 0x7fcf5f884a90>], '(as': [2, <__main__.FPTree.Node object at 0x7fcf5f84e290>], 'high': [2, <__main__.FPTree.Node object at 0x7fcf5f84e2d0>], 'performance': [4, <__main__.FPTree.Node object at 0x7fcf5f884ad0>], 'minimum': [3, <__main__.FPTree.Node object at 0x7fcf5f820b10>], 'evaluation': [2, <__main__.FPTree.Node object at 0x7fcf5f84e310>], 'commonly': [2, <__main__.FPTree.Node object at 0x7fcf5f84e350>], 'size': [3, <__main__.FPTree.Node object at 0x7fcf5f820b50>], 'published': [2, <__main__.FPTree.Node object at 0x7fcf5f84e390>], 'common': [3, <__main__.FPTree.Node object at 0x7fcf5f820b90>], 'time': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1550>], 'Other': [2, <__main__.FPTree.Node object at 0x7fcf5f84e3d0>], 'one': [4, <__main__.FPTree.Node object at 0x7fcf5f884b10>], 'algorithm.': [2, <__main__.FPTree.Node object at 0x7fcf5f84e410>], 'combine': [2, <__main__.FPTree.Node object at 0x7fcf5f84e450>], 'essentially': [2, <__main__.FPTree.Node object at 0x7fcf5f84e490>], 'blocks': [2, <__main__.FPTree.Node object at 0x7fcf5f84e4d0>], 'limited': [2, <__main__.FPTree.Node object at 0x7fcf5f84e510>], 'languages,': [2, <__main__.FPTree.Node object at 0x7fcf5f84e550>], 'needs': [2, <__main__.FPTree.Node object at 0x7fcf5f84e590>], 'define': [2, <__main__.FPTree.Node object at 0x7fcf5f84e5d0>], 'such': [4, <__main__.FPTree.Node object at 0x7fcf5f884b90>], 'value': [4, <__main__.FPTree.Node object at 0x7fcf5f884bd0>], 'find': [4, <__main__.FPTree.Node object at 0x7fcf5f884b50>], 'finite': [3, <__main__.FPTree.Node object at 0x7fcf5f820bd0>], 'based': [3, <__main__.FPTree.Node object at 0x7fcf5f820c10>], 'references': [2, <__main__.FPTree.Node object at 0x7fcf5f84e610>], 'you': [2, <__main__.FPTree.Node object at 0x7fcf5f84e650>], 'J.': [2, <__main__.FPTree.Node object at 0x7fcf5f84e690>], 'performance,': [2, <__main__.FPTree.Node object at 0x7fcf5f84e6d0>], 'candidate': [2, <__main__.FPTree.Node object at 0x7fcf5f84e710>], 'speed': [2, <__main__.FPTree.Node object at 0x7fcf5f84e750>], 'structure.': [2, <__main__.FPTree.Node object at 0x7fcf5f84e790>], 'requires': [3, <__main__.FPTree.Node object at 0x7fcf5f820c50>], 'own': [3, <__main__.FPTree.Node object at 0x7fcf5f820c90>], 'i.e.,': [2, <__main__.FPTree.Node object at 0x7fcf5f84e7d0>], 'initial': [3, <__main__.FPTree.Node object at 0x7fcf5f820cd0>], 'iterations': [2, <__main__.FPTree.Node object at 0x7fcf5f84e810>], 'occur': [2, <__main__.FPTree.Node object at 0x7fcf5f84e850>], 'similar': [2, <__main__.FPTree.Node object at 0x7fcf5f84e890>], 'subset': [2, <__main__.FPTree.Node object at 0x7fcf5f84e8d0>], 'any': [4, <__main__.FPTree.Node object at 0x7fcf5f884c10>], 'computer': [5, <__main__.FPTree.Node object at 0x7fcf5f8a13d0>], 'construction': [2, <__main__.FPTree.Node object at 0x7fcf5f84e910>], 'values': [4, <__main__.FPTree.Node object at 0x7fcf5f884c50>], '(e.g.': [2, <__main__.FPTree.Node object at 0x7fcf5f84e950>], 'however,': [2, <__main__.FPTree.Node object at 0x7fcf5f84e990>], 'complex': [2, <__main__.FPTree.Node object at 0x7fcf5f84e9d0>], 'procedure': [2, <__main__.FPTree.Node object at 0x7fcf5f84ea10>], 'pair': [2, <__main__.FPTree.Node object at 0x7fcf5f84ea50>], 'online': [2, <__main__.FPTree.Node object at 0x7fcf5f84ea90>], 'which': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1090>], 'algorithms,': [2, <__main__.FPTree.Node object at 0x7fcf5f84ead0>], 'hybrid': [2, <__main__.FPTree.Node object at 0x7fcf5f84eb10>], 'using': [3, <__main__.FPTree.Node object at 0x7fcf5f820d10>], 'Its': [2, <__main__.FPTree.Node object at 0x7fcf5f84eb50>], 'solution,': [3, <__main__.FPTree.Node object at 0x7fcf5f820d50>], 'higher': [2, <__main__.FPTree.Node object at 0x7fcf5f84eb90>], 'number': [5, <__main__.FPTree.Node object at 0x7fcf5f8a10d0>], 'best': [3, <__main__.FPTree.Node object at 0x7fcf5f820d90>], 'right': [3, <__main__.FPTree.Node object at 0x7fcf5f820dd0>], 'search': [5, <__main__.FPTree.Node object at 0x7fcf5f8a12d0>], 'next': [3, <__main__.FPTree.Node object at 0x7fcf5f820e10>], 'terminates': [3, <__main__.FPTree.Node object at 0x7fcf5f820e50>], 'items,': [2, <__main__.FPTree.Node object at 0x7fcf5f84ebd0>], 'its': [5, <__main__.FPTree.Node object at 0x7fcf5f8a15d0>], 'into': [3, <__main__.FPTree.Node object at 0x7fcf5f820e90>], 'because': [4, <__main__.FPTree.Node object at 0x7fcf5f884c90>], 'allowing': [3, <__main__.FPTree.Node object at 0x7fcf5f820ed0>], 'natural': [2, <__main__.FPTree.Node object at 0x7fcf5f84ec10>], 'more': [4, <__main__.FPTree.Node object at 0x7fcf5f884cd0>], 'describes': [2, <__main__.FPTree.Node object at 0x7fcf5f84ec50>], 'testing': [2, <__main__.FPTree.Node object at 0x7fcf5f84ec90>], 'up': [3, <__main__.FPTree.Node object at 0x7fcf5f820f10>], 'science': [3, <__main__.FPTree.Node object at 0x7fcf5f820f50>], 'nodes.': [2, <__main__.FPTree.Node object at 0x7fcf5f84ecd0>], 'determine': [2, <__main__.FPTree.Node object at 0x7fcf5f84ed10>], 'decrease': [3, <__main__.FPTree.Node object at 0x7fcf5f820f90>], 'be': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1190>], 'effective': [2, <__main__.FPTree.Node object at 0x7fcf5f84ed50>], 'most': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1450>], 'adding': [2, <__main__.FPTree.Node object at 0x7fcf5f84ed90>], 'depends': [3, <__main__.FPTree.Node object at 0x7fcf5f820fd0>], 'operators,': [2, <__main__.FPTree.Node object at 0x7fcf5f84edd0>], 'combination': [2, <__main__.FPTree.Node object at 0x7fcf5f84ee10>], 'example,': [4, <__main__.FPTree.Node object at 0x7fcf5f884d10>], 'do': [3, <__main__.FPTree.Node object at 0x7fcf5f82e050>], 'pick': [2, <__main__.FPTree.Node object at 0x7fcf5f84ee50>], 'require': [2, <__main__.FPTree.Node object at 0x7fcf5f84ee90>], 'greater': [4, <__main__.FPTree.Node object at 0x7fcf5f884d50>], 'array': [2, <__main__.FPTree.Node object at 0x7fcf5f84eed0>], 'search.': [2, <__main__.FPTree.Node object at 0x7fcf5f84ef10>], 'regarding': [2, <__main__.FPTree.Node object at 0x7fcf5f84ef50>], '(or': [3, <__main__.FPTree.Node object at 0x7fcf5f82e090>], 'proposed': [2, <__main__.FPTree.Node object at 0x7fcf5f84ef90>], 'difficult': [2, <__main__.FPTree.Node object at 0x7fcf5f84efd0>], 'reduced': [3, <__main__.FPTree.Node object at 0x7fcf5f82e0d0>], 'application': [3, <__main__.FPTree.Node object at 0x7fcf5f82e110>], 'multiple': [2, <__main__.FPTree.Node object at 0x7fcf5f7de050>], 'therefore': [2, <__main__.FPTree.Node object at 0x7fcf5f7de090>], 'permits': [2, <__main__.FPTree.Node object at 0x7fcf5f7de0d0>], 'maximum': [3, <__main__.FPTree.Node object at 0x7fcf5f82e150>], 'even': [4, <__main__.FPTree.Node object at 0x7fcf5f884d90>], 'low': [3, <__main__.FPTree.Node object at 0x7fcf5f82e190>], 'rule': [3, <__main__.FPTree.Node object at 0x7fcf5f82e1d0>], 'parameters': [2, <__main__.FPTree.Node object at 0x7fcf5f7de110>], 'always': [3, <__main__.FPTree.Node object at 0x7fcf5f82e210>], 'large': [5, <__main__.FPTree.Node object at 0x7fcf5f8a14d0>], 'allow': [4, <__main__.FPTree.Node object at 0x7fcf5f884dd0>], 'length,': [2, <__main__.FPTree.Node object at 0x7fcf5f7de150>], 'working': [2, <__main__.FPTree.Node object at 0x7fcf5f7de190>], 'definition': [2, <__main__.FPTree.Node object at 0x7fcf5f7de1d0>], 'originally': [2, <__main__.FPTree.Node object at 0x7fcf5f7de210>], 'overall': [2, <__main__.FPTree.Node object at 0x7fcf5f7de250>], 'and,': [2, <__main__.FPTree.Node object at 0x7fcf5f7de290>], 'evaluated': [2, <__main__.FPTree.Node object at 0x7fcf5f7de2d0>], 'Linear': [2, <__main__.FPTree.Node object at 0x7fcf5f7de310>], 'optimal': [2, <__main__.FPTree.Node object at 0x7fcf5f7de350>], 'cases,': [2, <__main__.FPTree.Node object at 0x7fcf5f7de390>], 'conditions': [2, <__main__.FPTree.Node object at 0x7fcf5f7de3d0>], 'good': [2, <__main__.FPTree.Node object at 0x7fcf5f7de410>], 'including': [3, <__main__.FPTree.Node object at 0x7fcf5f82e250>], 'selection': [2, <__main__.FPTree.Node object at 0x7fcf5f7de450>], 'simple': [4, <__main__.FPTree.Node object at 0x7fcf5f884e10>], 'worse': [2, <__main__.FPTree.Node object at 0x7fcf5f7de490>], 'implementations': [3, <__main__.FPTree.Node object at 0x7fcf5f82e290>], 'necessary': [2, <__main__.FPTree.Node object at 0x7fcf5f7de4d0>], 'kind': [2, <__main__.FPTree.Node object at 0x7fcf5f7de510>], 'makes': [2, <__main__.FPTree.Node object at 0x7fcf5f7de550>], 'work': [2, <__main__.FPTree.Node object at 0x7fcf5f7de590>], 'used': [4, <__main__.FPTree.Node object at 0x7fcf5f884e90>], 'programming,': [2, <__main__.FPTree.Node object at 0x7fcf5f7de5d0>], 'likely': [2, <__main__.FPTree.Node object at 0x7fcf5f7de610>], 'comparison': [2, <__main__.FPTree.Node object at 0x7fcf5f7de650>], 'Algorithm': [2, <__main__.FPTree.Node object at 0x7fcf5f7de690>], 'provides': [2, <__main__.FPTree.Node object at 0x7fcf5f7de6d0>], 'efficiency': [3, <__main__.FPTree.Node object at 0x7fcf5f82e2d0>], 'able': [2, <__main__.FPTree.Node object at 0x7fcf5f7de710>], 'Like': [2, <__main__.FPTree.Node object at 0x7fcf5f7de750>], 'problems.': [2, <__main__.FPTree.Node object at 0x7fcf5f7de790>], 'help': [2, <__main__.FPTree.Node object at 0x7fcf5f7de7d0>], 'than': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1510>], 'processing': [2, <__main__.FPTree.Node object at 0x7fcf5f7de810>], 'way': [4, <__main__.FPTree.Node object at 0x7fcf5f884ed0>], 'take': [3, <__main__.FPTree.Node object at 0x7fcf5f82e310>], 'items': [2, <__main__.FPTree.Node object at 0x7fcf5f7de850>], 'These': [3, <__main__.FPTree.Node object at 0x7fcf5f82e350>], 'some': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1250>], 'especially': [2, <__main__.FPTree.Node object at 0x7fcf5f7de890>], 'waste': [2, <__main__.FPTree.Node object at 0x7fcf5f7de8d0>], 'cannot': [2, <__main__.FPTree.Node object at 0x7fcf5f7de910>], 'other': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1390>], 'entirely': [3, <__main__.FPTree.Node object at 0x7fcf5f82e390>], 'an': [5, <__main__.FPTree.Node object at 0x7fcf5f8a1110>], 'maintain': [2, <__main__.FPTree.Node object at 0x7fcf5f7de950>], 'there': [3, <__main__.FPTree.Node object at 0x7fcf5f82e3d0>], 'generates': [2, <__main__.FPTree.Node object at 0x7fcf5f7de990>], 'variants,': [2, <__main__.FPTree.Node object at 0x7fcf5f7de9d0>], 'useful': [2, <__main__.FPTree.Node object at 0x7fcf5f7dea10>], 'difference': [2, <__main__.FPTree.Node object at 0x7fcf5f7dea50>], 'solving': [3, <__main__.FPTree.Node object at 0x7fcf5f82e410>], 'numbers': [2, <__main__.FPTree.Node object at 0x7fcf5f7dea90>], 'performed': [3, <__main__.FPTree.Node object at 0x7fcf5f82e450>], 'current': [2, <__main__.FPTree.Node object at 0x7fcf5f7dead0>], 'three': [2, <__main__.FPTree.Node object at 0x7fcf5f7deb10>], 'order': [4, <__main__.FPTree.Node object at 0x7fcf5f884e50>], 'structure': [4, <__main__.FPTree.Node object at 0x7fcf5f884f10>], 'direct': [2, <__main__.FPTree.Node object at 0x7fcf5f7deb50>], 'implement': [2, <__main__.FPTree.Node object at 0x7fcf5f7deb90>], 'approximate': [2, <__main__.FPTree.Node object at 0x7fcf5f7debd0>], 'environment': [2, <__main__.FPTree.Node object at 0x7fcf5f7dec10>], 'bit': [2, <__main__.FPTree.Node object at 0x7fcf5f7dec50>], 'design': [2, <__main__.FPTree.Node object at 0x7fcf5f7dec90>], 'significant': [3, <__main__.FPTree.Node object at 0x7fcf5f82e490>], 'use': [4, <__main__.FPTree.Node object at 0x7fcf5f884f50>], 'research': [2, <__main__.FPTree.Node object at 0x7fcf5f7decd0>], 'starts': [2, <__main__.FPTree.Node object at 0x7fcf5f7ded10>], 'Artificial': [2, <__main__.FPTree.Node object at 0x7fcf5f7ded50>], 'it': [5, <__main__.FPTree.Node object at 0x7fcf66531ed0>], 'or': [4, <__main__.FPTree.Node object at 0x7fcf5f884f90>], 'child': [2, <__main__.FPTree.Node object at 0x7fcf5f7ded90>], 'arguably': [2, <__main__.FPTree.Node object at 0x7fcf5f7dedd0>], 'shown': [3, <__main__.FPTree.Node object at 0x7fcf5f82e4d0>], 'iterative': [2, <__main__.FPTree.Node object at 0x7fcf5f7dee10>], 'exact': [3, <__main__.FPTree.Node object at 0x7fcf5f82e510>], 'computation': [2, <__main__.FPTree.Node object at 0x7fcf5f7dee50>], 'solutions': [2, <__main__.FPTree.Node object at 0x7fcf5f7dee90>], 'about': [2, <__main__.FPTree.Node object at 0x7fcf5f7deed0>], 'successive': [2, <__main__.FPTree.Node object at 0x7fcf5f7def10>], 'as': [5, <__main__.FPTree.Node object at 0x7fcf5f877a10>], 'fixed': [3, <__main__.FPTree.Node object at 0x7fcf5f82e550>], 'avoid': [2, <__main__.FPTree.Node object at 0x7fcf5f7def50>], 'applications': [2, <__main__.FPTree.Node object at 0x7fcf5f7def90>], 'though': [3, <__main__.FPTree.Node object at 0x7fcf5f82e590>], 'where': [5, <__main__.FPTree.Node object at 0x7fcf5f877bd0>], '(see': [2, <__main__.FPTree.Node object at 0x7fcf5f7defd0>], 'potentially': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef050>], 'object': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef090>], 'rather': [3, <__main__.FPTree.Node object at 0x7fcf5f82e5d0>], 'this': [4, <__main__.FPTree.Node object at 0x7fcf5f884fd0>], 'lead': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef0d0>], 'continues': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef110>], 'found': [4, <__main__.FPTree.Node object at 0x7fcf5f820050>], 'so': [3, <__main__.FPTree.Node object at 0x7fcf5f82e610>], 'can': [5, <__main__.FPTree.Node object at 0x7fcf5f877c50>], 'criterion': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef150>], 'basic': [3, <__main__.FPTree.Node object at 0x7fcf5f82e650>], 'making': [3, <__main__.FPTree.Node object at 0x7fcf5f82e690>], 'result,': [3, <__main__.FPTree.Node object at 0x7fcf5f82e6d0>], 'is': [5, <__main__.FPTree.Node object at 0x7fcf5f877cd0>], 'objects': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef190>], 'simply': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef1d0>], 'implementation': [3, <__main__.FPTree.Node object at 0x7fcf5f82e710>], 'support': [3, <__main__.FPTree.Node object at 0x7fcf5f82e750>], 'in': [5, <__main__.FPTree.Node object at 0x7fcf5f877c90>], 'well': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef210>], 'initialize': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef250>], 'modifications': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef290>], 'solution.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef2d0>], 'away': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef310>], 'primarily': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef350>], 'practical': [4, <__main__.FPTree.Node object at 0x7fcf5f820090>], 'dynamic': [3, <__main__.FPTree.Node object at 0x7fcf5f82e790>], 'construct': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef390>], 'results': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef3d0>], 'building': [3, <__main__.FPTree.Node object at 0x7fcf5f82e7d0>], 'possibly': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef410>], 'case.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef450>], 'via': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef490>], 'solve': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef4d0>], 'different': [3, <__main__.FPTree.Node object at 0x7fcf5f82e810>], 'if': [5, <__main__.FPTree.Node object at 0x7fcf5f877d50>], 'when': [4, <__main__.FPTree.Node object at 0x7fcf5f8200d0>], 'they': [4, <__main__.FPTree.Node object at 0x7fcf5f820110>], 'planning,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef510>], 'generally': [3, <__main__.FPTree.Node object at 0x7fcf5f82e850>], 'larger': [3, <__main__.FPTree.Node object at 0x7fcf5f82e890>], 'arrays': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef550>], 'further': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef590>], 'selects': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef5d0>], 'prevent': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef610>], 'already': [3, <__main__.FPTree.Node object at 0x7fcf5f82e8d0>], 'used,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef650>], 'less': [3, <__main__.FPTree.Node object at 0x7fcf5f82e910>], 'class': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef690>], 'attempt': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef6d0>], 'theory': [3, <__main__.FPTree.Node object at 0x7fcf5f82e950>], 'appear': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef710>], 'no': [3, <__main__.FPTree.Node object at 0x7fcf5f82e990>], 'reached': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef750>], 'Nils': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef790>], 'adaptive': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef7d0>], '–': [3, <__main__.FPTree.Node object at 0x7fcf5f82e9d0>], 'whereas': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef810>], 'along': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef850>], 'result': [3, <__main__.FPTree.Node object at 0x7fcf5f82ea10>], 'model': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef890>], 'like': [3, <__main__.FPTree.Node object at 0x7fcf5f82ea50>], 'game,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef8d0>], 'selected,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef910>], 'node': [4, <__main__.FPTree.Node object at 0x7fcf5f820150>], 'still': [3, <__main__.FPTree.Node object at 0x7fcf5f82ea90>], 'Turing': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef950>], 'not': [5, <__main__.FPTree.Node object at 0x7fcf5f877f50>], 'complexity': [4, <__main__.FPTree.Node object at 0x7fcf5f820190>], 'a': [5, <__main__.FPTree.Node object at 0x7fcf5f877d90>], 'and/or': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef990>], 'integers,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ef9d0>], 'implement,': [2, <__main__.FPTree.Node object at 0x7fcf5f7efa10>], 'position': [3, <__main__.FPTree.Node object at 0x7fcf5f82ead0>], 'only': [4, <__main__.FPTree.Node object at 0x7fcf5f8201d0>], 'Institute': [2, <__main__.FPTree.Node object at 0x7fcf5f7efa50>], 'known': [4, <__main__.FPTree.Node object at 0x7fcf5f820210>], 'designed': [3, <__main__.FPTree.Node object at 0x7fcf5f82eb10>], 'context': [2, <__main__.FPTree.Node object at 0x7fcf5f7efa90>], 'entire': [4, <__main__.FPTree.Node object at 0x7fcf5f820250>], 'function,': [3, <__main__.FPTree.Node object at 0x7fcf5f82eb50>], 'approach': [3, <__main__.FPTree.Node object at 0x7fcf5f82eb90>], 'valid': [3, <__main__.FPTree.Node object at 0x7fcf5f82ebd0>], 'given': [4, <__main__.FPTree.Node object at 0x7fcf5f820290>], 'contains': [3, <__main__.FPTree.Node object at 0x7fcf5f82ec10>], 'global': [2, <__main__.FPTree.Node object at 0x7fcf5f7efad0>], 'algorithms.': [2, <__main__.FPTree.Node object at 0x7fcf5f7efb10>], 'They': [2, <__main__.FPTree.Node object at 0x7fcf5f7efb50>], 'to': [5, <__main__.FPTree.Node object at 0x7fcf5fddeb90>], 'starting': [2, <__main__.FPTree.Node object at 0x7fcf5f7efb90>], 'nodes': [3, <__main__.FPTree.Node object at 0x7fcf5f82ec50>], 'broken': [2, <__main__.FPTree.Node object at 0x7fcf5f7efbd0>], 'The': [5, <__main__.FPTree.Node object at 0x7fcf5f884350>], 'decreasing': [2, <__main__.FPTree.Node object at 0x7fcf5f7efc10>], 'sum': [3, <__main__.FPTree.Node object at 0x7fcf5f82ec90>], 'Starting': [2, <__main__.FPTree.Node object at 0x7fcf5f7efc50>], 'are': [5, <__main__.FPTree.Node object at 0x7fcf5f884390>], 'single': [5, <__main__.FPTree.Node object at 0x7fcf5f8843d0>], 'whether': [2, <__main__.FPTree.Node object at 0x7fcf5f7efc90>], 'belongs': [2, <__main__.FPTree.Node object at 0x7fcf5f7efcd0>], 'represent': [2, <__main__.FPTree.Node object at 0x7fcf5f7efd10>], 'set': [3, <__main__.FPTree.Node object at 0x7fcf5f82ecd0>], 'strings': [2, <__main__.FPTree.Node object at 0x7fcf5f7efd50>], 'change': [2, <__main__.FPTree.Node object at 0x7fcf5f7efd90>], 'at': [5, <__main__.FPTree.Node object at 0x7fcf5f884410>], 'appropriate': [2, <__main__.FPTree.Node object at 0x7fcf5f7efdd0>], 'versus': [2, <__main__.FPTree.Node object at 0x7fcf5f7efe10>], 'loop': [2, <__main__.FPTree.Node object at 0x7fcf5f7efe50>], '(the': [2, <__main__.FPTree.Node object at 0x7fcf5f7efe90>], 'terms': [3, <__main__.FPTree.Node object at 0x7fcf5f82ed10>], 'have': [5, <__main__.FPTree.Node object at 0x7fcf5f884450>], 'programming': [2, <__main__.FPTree.Node object at 0x7fcf5f7efed0>], 'defining': [2, <__main__.FPTree.Node object at 0x7fcf5f7eff10>], 'components': [2, <__main__.FPTree.Node object at 0x7fcf5f7eff50>], 'our': [2, <__main__.FPTree.Node object at 0x7fcf5f7eff90>], 'way,': [2, <__main__.FPTree.Node object at 0x7fcf5f7effd0>], 'were': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff050>], 'By': [3, <__main__.FPTree.Node object at 0x7fcf5f82ed50>], '-': [3, <__main__.FPTree.Node object at 0x7fcf5f82ed90>], 'those': [3, <__main__.FPTree.Node object at 0x7fcf5f82edd0>], 'problems': [3, <__main__.FPTree.Node object at 0x7fcf5f82ee10>], 'diverse': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff090>], 'types': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff0d0>], 'element': [3, <__main__.FPTree.Node object at 0x7fcf5f82ee50>], 'updated': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff110>], 'often': [5, <__main__.FPTree.Node object at 0x7fcf5f884490>], 'problems,': [3, <__main__.FPTree.Node object at 0x7fcf5f82ee90>], 'include': [3, <__main__.FPTree.Node object at 0x7fcf5f82eed0>], 'operations.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff150>], 'must': [4, <__main__.FPTree.Node object at 0x7fcf5f8202d0>], 'provide': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff190>], 'either': [3, <__main__.FPTree.Node object at 0x7fcf5f82ef10>], 'by': [4, <__main__.FPTree.Node object at 0x7fcf5f820310>], 'other.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff1d0>], 'moves': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff210>], 'algorithm': [5, <__main__.FPTree.Node object at 0x7fcf5f8844d0>], 'algorithms': [5, <__main__.FPTree.Node object at 0x7fcf5f884510>], 'satisfies': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff250>], 'trees': [3, <__main__.FPTree.Node object at 0x7fcf5f82ef50>], 'length': [3, <__main__.FPTree.Node object at 0x7fcf5f82ef90>], 'programs,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff290>], 'several': [3, <__main__.FPTree.Node object at 0x7fcf5f82efd0>], 'data': [4, <__main__.FPTree.Node object at 0x7fcf5f820350>], 'Such': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff2d0>], 'due': [3, <__main__.FPTree.Node object at 0x7fcf5f83d050>], 'above': [3, <__main__.FPTree.Node object at 0x7fcf5f83d090>], 'effectively': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff310>], 'stored': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff350>], 'particularly': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff390>], 'usually': [3, <__main__.FPTree.Node object at 0x7fcf5f83d0d0>], 'variants': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff3d0>], 'reached.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff410>], 'that': [5, <__main__.FPTree.Node object at 0x7fcf5f884590>], 'involves': [3, <__main__.FPTree.Node object at 0x7fcf5f83d110>], 'aim': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff450>], 'method': [3, <__main__.FPTree.Node object at 0x7fcf5f83d150>], 'how': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff490>], 'list,': [4, <__main__.FPTree.Node object at 0x7fcf5f820390>], 'will': [5, <__main__.FPTree.Node object at 0x7fcf5f8845d0>], 'understand': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff4d0>], 'without': [3, <__main__.FPTree.Node object at 0x7fcf5f83d190>], 'systems,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff510>], 'However,': [4, <__main__.FPTree.Node object at 0x7fcf5f8203d0>], 'clear': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff550>], 'inherently': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff590>], 'form': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff5d0>], 'all': [5, <__main__.FPTree.Node object at 0x7fcf5f884550>], '(such': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff610>], 'easily': [3, <__main__.FPTree.Node object at 0x7fcf5f83d1d0>], 'Thus,': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff650>], 'but': [5, <__main__.FPTree.Node object at 0x7fcf5f884610>], 'repeated': [4, <__main__.FPTree.Node object at 0x7fcf5f820410>], 'instead': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff690>], 'every': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff6d0>], 'near': [3, <__main__.FPTree.Node object at 0x7fcf5f83d210>], 'level': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff710>], 'highly': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff750>], 'study': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff790>], 'range': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff7d0>], 'portion': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff810>], 'it.': [3, <__main__.FPTree.Node object at 0x7fcf5f83d250>], 'data.': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff850>], 'techniques': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff890>], 'structures': [3, <__main__.FPTree.Node object at 0x7fcf5f83d290>], 'linked': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff8d0>], 'lower': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff910>], 'particular': [3, <__main__.FPTree.Node object at 0x7fcf5f83d2d0>], 'problem': [3, <__main__.FPTree.Node object at 0x7fcf5f83d310>], 'inefficient': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff950>], 'quickly': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff990>], 'seen': [3, <__main__.FPTree.Node object at 0x7fcf5f83d350>], 'essential': [2, <__main__.FPTree.Node object at 0x7fcf5f7ff9d0>], 'process': [3, <__main__.FPTree.Node object at 0x7fcf5f83d390>], 'methods': [3, <__main__.FPTree.Node object at 0x7fcf5f83d3d0>], 'these': [4, <__main__.FPTree.Node object at 0x7fcf5f820450>], 'equivalent': [3, <__main__.FPTree.Node object at 0x7fcf5f83d410>], 'long': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffa10>], 'from': [5, <__main__.FPTree.Node object at 0x7fcf5f884650>], 'solved': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffa50>], 'small': [3, <__main__.FPTree.Node object at 0x7fcf5f83d450>], 'later': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffa90>], 'certain': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffad0>], 'Design': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffb10>], 'developed': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffb50>], 'see': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffb90>], 'condition': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffbd0>], 'typically': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffc10>], 'defined': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffc50>], 'iteration': [3, <__main__.FPTree.Node object at 0x7fcf5f83d490>], 'part': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffc90>], 'proved': [3, <__main__.FPTree.Node object at 0x7fcf5f83d4d0>], 'point': [3, <__main__.FPTree.Node object at 0x7fcf5f83d510>], 'product': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffcd0>], 'each': [5, <__main__.FPTree.Node object at 0x7fcf5f884690>], 'In': [5, <__main__.FPTree.Node object at 0x7fcf5f8846d0>], 'quality': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffd10>], 'computational': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffd50>], 'uses': [4, <__main__.FPTree.Node object at 0x7fcf5f820490>], 'then': [5, <__main__.FPTree.Node object at 0x7fcf5f884710>], 'of': [5, <__main__.FPTree.Node object at 0x7fcf5f884750>], 'steps': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffd90>], 'main': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffdd0>], 'General': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffe10>], 'their': [4, <__main__.FPTree.Node object at 0x7fcf5f8204d0>], 'considered': [3, <__main__.FPTree.Node object at 0x7fcf5f83d550>], 'structural': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffe50>], 'termination': [3, <__main__.FPTree.Node object at 0x7fcf5f83d590>], 'depending': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffe90>], 'special': [3, <__main__.FPTree.Node object at 0x7fcf5f83d5d0>], 'may': [3, <__main__.FPTree.Node object at 0x7fcf5f83d610>], 'whose': [3, <__main__.FPTree.Node object at 0x7fcf5f83d650>], 'related': [2, <__main__.FPTree.Node object at 0x7fcf5f7ffed0>], 'linear': [3, <__main__.FPTree.Node object at 0x7fcf5f83d690>], 'select': [2, <__main__.FPTree.Node object at 0x7fcf5f7fff10>], 'technique': [2, <__main__.FPTree.Node object at 0x7fcf5f7fff50>], 'action': [2, <__main__.FPTree.Node object at 0x7fcf5f7fff90>], 'expected': [2, <__main__.FPTree.Node object at 0x7fcf5f7fffd0>], 'i.e.': [2, <__main__.FPTree.Node object at 0x7fcf5f80d050>], 'affected': [2, <__main__.FPTree.Node object at 0x7fcf5f80d090>], 'perform': [3, <__main__.FPTree.Node object at 0x7fcf5f83d6d0>], 'equal': [5, <__main__.FPTree.Node object at 0x7fcf5f884790>], 'applied': [3, <__main__.FPTree.Node object at 0x7fcf5f83d710>], 'specific': [3, <__main__.FPTree.Node object at 0x7fcf5f83d750>], '0': [2, <__main__.FPTree.Node object at 0x7fcf5f80d0d0>], 'Some': [2, <__main__.FPTree.Node object at 0x7fcf5f80d110>], 'addition': [2, <__main__.FPTree.Node object at 0x7fcf5f80d150>], 'particular,': [2, <__main__.FPTree.Node object at 0x7fcf5f80d190>], 'since': [3, <__main__.FPTree.Node object at 0x7fcf5f83d790>], 'function': [4, <__main__.FPTree.Node object at 0x7fcf5f820510>], 'whole': [2, <__main__.FPTree.Node object at 0x7fcf5f80d1d0>], 'idea': [2, <__main__.FPTree.Node object at 0x7fcf5f80d210>], 'two': [5, <__main__.FPTree.Node object at 0x7fcf5f8847d0>], 'might': [4, <__main__.FPTree.Node object at 0x7fcf5f820550>], 'While': [2, <__main__.FPTree.Node object at 0x7fcf5f80d250>], 'meaning': [4, <__main__.FPTree.Node object at 0x7fcf5f820590>], 'replacing': [2, <__main__.FPTree.Node object at 0x7fcf5f80d290>], 'been': [4, <__main__.FPTree.Node object at 0x7fcf5f8205d0>], 'problem.': [2, <__main__.FPTree.Node object at 0x7fcf5f80d2d0>], 'generate': [2, <__main__.FPTree.Node object at 0x7fcf5f80d310>], 'child,': [2, <__main__.FPTree.Node object at 0x7fcf5f80d350>], 'generated': [2, <__main__.FPTree.Node object at 0x7fcf5f80d390>], 'traverse': [2, <__main__.FPTree.Node object at 0x7fcf5f80d3d0>], 'them': [3, <__main__.FPTree.Node object at 0x7fcf5f83d7d0>], 'lowest': [2, <__main__.FPTree.Node object at 0x7fcf5f80d410>], 'subject': [2, <__main__.FPTree.Node object at 0x7fcf5f80d450>], 'Each': [2, <__main__.FPTree.Node object at 0x7fcf5f80d490>], 'terminating': [2, <__main__.FPTree.Node object at 0x7fcf5f80d4d0>], 'we': [4, <__main__.FPTree.Node object at 0x7fcf5f820610>], 'theorem': [2, <__main__.FPTree.Node object at 0x7fcf5f80d510>], 'very': [4, <__main__.FPTree.Node object at 0x7fcf5f820650>], 'respect': [2, <__main__.FPTree.Node object at 0x7fcf5f80d550>], 'standard': [3, <__main__.FPTree.Node object at 0x7fcf5f83d810>], 'could': [2, <__main__.FPTree.Node object at 0x7fcf5f80d590>], 'step': [4, <__main__.FPTree.Node object at 0x7fcf5f820690>], 'information': [2, <__main__.FPTree.Node object at 0x7fcf5f80d5d0>], 'space,': [3, <__main__.FPTree.Node object at 0x7fcf5f83d850>], 'others,': [2, <__main__.FPTree.Node object at 0x7fcf5f80d610>], 'for': [5, <__main__.FPTree.Node object at 0x7fcf5f884810>], 'include:': [2, <__main__.FPTree.Node object at 0x7fcf5f80d650>], 'also': [4, <__main__.FPTree.Node object at 0x7fcf5f8206d0>], 'means': [3, <__main__.FPTree.Node object at 0x7fcf5f83d890>], 'both': [4, <__main__.FPTree.Node object at 0x7fcf5f820710>], 'until': [4, <__main__.FPTree.Node object at 0x7fcf5f820750>], 'first': [4, <__main__.FPTree.Node object at 0x7fcf5f820790>], 'parameters.': [2, <__main__.FPTree.Node object at 0x7fcf5f80d690>], 'place': [3, <__main__.FPTree.Node object at 0x7fcf5f83d8d0>], 'Because': [2, <__main__.FPTree.Node object at 0x7fcf5f80d6d0>], 'while': [3, <__main__.FPTree.Node object at 0x7fcf5f83d910>], 'behind': [2, <__main__.FPTree.Node object at 0x7fcf5f80d710>], 'optimization': [2, <__main__.FPTree.Node object at 0x7fcf5f80d750>], 'search,': [4, <__main__.FPTree.Node object at 0x7fcf5f8207d0>], 'move': [3, <__main__.FPTree.Node object at 0x7fcf5f83d950>], 'important': [3, <__main__.FPTree.Node object at 0x7fcf5f83d990>], 'case,': [3, <__main__.FPTree.Node object at 0x7fcf5f83d9d0>], 'possible': [4, <__main__.FPTree.Node object at 0x7fcf5f820810>], 'promising': [2, <__main__.FPTree.Node object at 0x7fcf5f80d790>], 'complete': [2, <__main__.FPTree.Node object at 0x7fcf5f80d7d0>], 'would': [3, <__main__.FPTree.Node object at 0x7fcf5f83da10>], 'better': [2, <__main__.FPTree.Node object at 0x7fcf5f80d810>], 'smaller': [2, <__main__.FPTree.Node object at 0x7fcf5f80d850>], 'probability,': [2, <__main__.FPTree.Node object at 0x7fcf5f80d890>], 'components.': [2, <__main__.FPTree.Node object at 0x7fcf5f80d8d0>], 'exponential': [3, <__main__.FPTree.Node object at 0x7fcf5f83da50>], 'An': [3, <__main__.FPTree.Node object at 0x7fcf5f83da90>], 'second': [4, <__main__.FPTree.Node object at 0x7fcf5f820850>], 'examples': [2, <__main__.FPTree.Node object at 0x7fcf5f80d910>], 'same': [5, <__main__.FPTree.Node object at 0x7fcf5f884890>], 'instance': [3, <__main__.FPTree.Node object at 0x7fcf5f83dad0>], 'That': [2, <__main__.FPTree.Node object at 0x7fcf5f80d950>], 'open': [2, <__main__.FPTree.Node object at 0x7fcf5f80d990>], 'operations': [4, <__main__.FPTree.Node object at 0x7fcf5f820890>], 'although': [2, <__main__.FPTree.Node object at 0x7fcf5f80d9d0>], 'was': [2, <__main__.FPTree.Node object at 0x7fcf5f80da10>], 'has': [5, <__main__.FPTree.Node object at 0x7fcf5f8848d0>], 'partial': [2, <__main__.FPTree.Node object at 0x7fcf5f80da50>], 'created': [3, <__main__.FPTree.Node object at 0x7fcf5f83db10>], 'the': [5, <__main__.FPTree.Node object at 0x7fcf5f884850>], 'implicitly': [2, <__main__.FPTree.Node object at 0x7fcf5f80da90>], 'guarantees': [2, <__main__.FPTree.Node object at 0x7fcf5f80dad0>], 'heuristic': [2, <__main__.FPTree.Node object at 0x7fcf5f80db10>], 'alternative': [3, <__main__.FPTree.Node object at 0x7fcf5f83db50>], 'consists': [2, <__main__.FPTree.Node object at 0x7fcf5f80db50>], 'finding': [3, <__main__.FPTree.Node object at 0x7fcf5f83db90>], 'heuristics': [2, <__main__.FPTree.Node object at 0x7fcf5f80db90>], 'space': [3, <__main__.FPTree.Node object at 0x7fcf5f83dbd0>], 'faster': [4, <__main__.FPTree.Node object at 0x7fcf5f8208d0>], 'through': [2, <__main__.FPTree.Node object at 0x7fcf5f80dbd0>], 'knowledge': [2, <__main__.FPTree.Node object at 0x7fcf5f80dc10>], 'frequently': [2, <__main__.FPTree.Node object at 0x7fcf5f80dc50>], 'add': [2, <__main__.FPTree.Node object at 0x7fcf5f80dc90>], 'Python': [2, <__main__.FPTree.Node object at 0x7fcf5f80dcd0>], 'strings.': [2, <__main__.FPTree.Node object at 0x7fcf5f80dd10>], 'classic': [2, <__main__.FPTree.Node object at 0x7fcf5f80dd50>], 'property': [2, <__main__.FPTree.Node object at 0x7fcf5f80dd90>], 'had': [2, <__main__.FPTree.Node object at 0x7fcf5f80ddd0>], 'sets': [2, <__main__.FPTree.Node object at 0x7fcf5f80de10>], 'suitable': [2, <__main__.FPTree.Node object at 0x7fcf5f80de50>], 'much': [3, <__main__.FPTree.Node object at 0x7fcf5f83dc10>], 'For': [5, <__main__.FPTree.Node object at 0x7fcf5f884910>], 'response': [2, <__main__.FPTree.Node object at 0x7fcf5f80de90>], 'and': [5, <__main__.FPTree.Node object at 0x7fcf5f884950>], 'get': [2, <__main__.FPTree.Node object at 0x7fcf5f80ded0>], 'list': [3, <__main__.FPTree.Node object at 0x7fcf5f83dc50>], '(which': [3, <__main__.FPTree.Node object at 0x7fcf5f83dc90>], 'Computer': [2, <__main__.FPTree.Node object at 0x7fcf5f80df10>], 'series': [2, <__main__.FPTree.Node object at 0x7fcf5f80df50>], 'As': [2, <__main__.FPTree.Node object at 0x7fcf5f80df90>], 'control': [2, <__main__.FPTree.Node object at 0x7fcf5f80dfd0>], 'solution': [3, <__main__.FPTree.Node object at 0x7fcf5f83dcd0>], 'programs': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0050>], 'efficiency.': [3, <__main__.FPTree.Node object at 0x7fcf5f83dd10>], 'few': [3, <__main__.FPTree.Node object at 0x7fcf5f83dd50>], 'among': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0090>], 'being': [4, <__main__.FPTree.Node object at 0x7fcf5f820910>], 'position.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a00d0>], 'instance,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0110>], 'with': [5, <__main__.FPTree.Node object at 0x7fcf5f884990>], 'efficient': [5, <__main__.FPTree.Node object at 0x7fcf5f8849d0>], 'called': [3, <__main__.FPTree.Node object at 0x7fcf5f83dd90>], 'domain': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0150>], 'worst': [4, <__main__.FPTree.Node object at 0x7fcf5f820950>], 'binary': [5, <__main__.FPTree.Node object at 0x7fcf5f884a10>], 'mechanism': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0190>], '(possibly)': [2, <__main__.FPTree.Node object at 0x7fcf5f7a01d0>], 'There': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0210>], 'on': [5, <__main__.FPTree.Node object at 0x7fcf5f884a50>], 'is,': [3, <__main__.FPTree.Node object at 0x7fcf5f83ddd0>], 'orders': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0250>], 'reason': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0290>], 'implemented': [3, <__main__.FPTree.Node object at 0x7fcf5f83de10>], 'A': [3, <__main__.FPTree.Node object at 0x7fcf5f83de50>], 'distance': [2, <__main__.FPTree.Node object at 0x7fcf5f7a02d0>], 'state': [3, <__main__.FPTree.Node object at 0x7fcf5f83de90>], 'another': [3, <__main__.FPTree.Node object at 0x7fcf5f83ded0>], 'reduce': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0310>], 'represents': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0350>], 'probabilities': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0390>], 'processes': [2, <__main__.FPTree.Node object at 0x7fcf5f7a03d0>], 'variable': [3, <__main__.FPTree.Node object at 0x7fcf5f83df10>], 'down': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0410>], 'mean': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0450>], 'This': [4, <__main__.FPTree.Node object at 0x7fcf5f820990>], 'added,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0490>], 'expression': [2, <__main__.FPTree.Node object at 0x7fcf5f7a04d0>], 'Research': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0510>], 'described': [3, <__main__.FPTree.Node object at 0x7fcf5f83df50>], 'efficiently': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0550>], 'allows': [3, <__main__.FPTree.Node object at 0x7fcf5f83df90>], 'average': [3, <__main__.FPTree.Node object at 0x7fcf5f83dfd0>], 'reference': [2, <__main__.FPTree.Node object at 0x7fcf5f7a05d0>], 'variation': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0650>], 'computing': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0690>], 'never': [3, <__main__.FPTree.Node object at 0x7fcf5f84e050>], 'within': [4, <__main__.FPTree.Node object at 0x7fcf5f8209d0>], 'elements': [4, <__main__.FPTree.Node object at 0x7fcf5f820a10>], 'Search': [3, <__main__.FPTree.Node object at 0x7fcf5f84e090>], 'stochastic': [2, <__main__.FPTree.Node object at 0x7fcf5f7a06d0>], 'points': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0710>], 'typical': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0750>], 'It': [4, <__main__.FPTree.Node object at 0x7fcf5f820a50>], 'new': [3, <__main__.FPTree.Node object at 0x7fcf5f84e0d0>], 'algorithm,': [3, <__main__.FPTree.Node object at 0x7fcf5f84e110>], '(also': [2, <__main__.FPTree.Node object at 0x7fcf5f7a0790>], 'compared': [2, <__main__.FPTree.Node object at 0x7fcf5f7a07d0>], '': [4, <__main__.FPTree.Node object at 0x7fcf5f8954d0>], 'zero': [2, <__main__.FPTree.Node object at 0x7fcf5f81d950>], 'involved': [2, <__main__.FPTree.Node object at 0x7fcf5f81d990>], '−\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f89c6d0>], '≤': [2, <__main__.FPTree.Node object at 0x7fcf5f81d9d0>], 'leading': [2, <__main__.FPTree.Node object at 0x7fcf5f81dad0>], '2\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f895590>], 'operation': [2, <__main__.FPTree.Node object at 0x7fcf5f81dc10>], 'value.': [2, <__main__.FPTree.Node object at 0x7fcf5f81dc50>], 'stores': [3, <__main__.FPTree.Node object at 0x7fcf5f89c890>], 'actual': [2, <__main__.FPTree.Node object at 0x7fcf5f81dcd0>], '\\\\varepsilon': [2, <__main__.FPTree.Node object at 0x7fcf5f81dd50>], 'running': [2, <__main__.FPTree.Node object at 0x7fcf5f81ddd0>], 'n,': [3, <__main__.FPTree.Node object at 0x7fcf5f89ca50>], 'b\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f89ca90>], 'heap,': [2, <__main__.FPTree.Node object at 0x7fcf5f81ded0>], 'On': [2, <__main__.FPTree.Node object at 0x7fcf5f81df10>], 'case.\\nIn': [2, <__main__.FPTree.Node object at 0x7fcf5f81dfd0>], 'test': [2, <__main__.FPTree.Node object at 0x7fcf5f83c050>], 'maintaining': [2, <__main__.FPTree.Node object at 0x7fcf5f83c090>], 'log\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83c110>], 'depth': [2, <__main__.FPTree.Node object at 0x7fcf5f83c250>], '(a': [2, <__main__.FPTree.Node object at 0x7fcf5f83c290>], '>0}\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83c2d0>], 'grammars': [2, <__main__.FPTree.Node object at 0x7fcf5f83c310>], 'ISBN': [2, <__main__.FPTree.Node object at 0x7fcf5f83c350>], 'table': [2, <__main__.FPTree.Node object at 0x7fcf5f83c3d0>], 'depth-first': [2, <__main__.FPTree.Node object at 0x7fcf5f83c410>], 'version': [2, <__main__.FPTree.Node object at 0x7fcf5f83c550>], 'required': [2, <__main__.FPTree.Node object at 0x7fcf5f83c590>], 'One': [2, <__main__.FPTree.Node object at 0x7fcf5f83c5d0>], 'guaranteed': [2, <__main__.FPTree.Node object at 0x7fcf5f83c650>], '>\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83c690>], 'referred': [2, <__main__.FPTree.Node object at 0x7fcf5f83c6d0>], 'what': [2, <__main__.FPTree.Node object at 0x7fcf5f83c790>], '{\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f89ce90>], 'on,': [2, <__main__.FPTree.Node object at 0x7fcf5f83c810>], 'pseudocode': [2, <__main__.FPTree.Node object at 0x7fcf5f83c890>], 'searching': [4, <__main__.FPTree.Node object at 0x7fcf5f895ad0>], 'return': [4, <__main__.FPTree.Node object at 0x7fcf5f895b10>], '<': [4, <__main__.FPTree.Node object at 0x7fcf5f895b50>], 'node.': [3, <__main__.FPTree.Node object at 0x7fcf5f89cf50>], 'here': [2, <__main__.FPTree.Node object at 0x7fcf5f83c990>], 'expressed': [2, <__main__.FPTree.Node object at 0x7fcf5f83ca10>], '+': [2, <__main__.FPTree.Node object at 0x7fcf5f83ca50>], 'With': [2, <__main__.FPTree.Node object at 0x7fcf5f83cad0>], '1\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f895b90>], 'Fibonacci': [2, <__main__.FPTree.Node object at 0x7fcf5f83cb10>], 'O\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83cb50>], 'hash': [2, <__main__.FPTree.Node object at 0x7fcf5f83cb90>], 'cases': [2, <__main__.FPTree.Node object at 0x7fcf5f83cbd0>], 'hold': [2, <__main__.FPTree.Node object at 0x7fcf5f83cc50>], 'following': [3, <__main__.FPTree.Node object at 0x7fcf5f7e30d0>], 'directly': [2, <__main__.FPTree.Node object at 0x7fcf5f83cc90>], 'branch': [2, <__main__.FPTree.Node object at 0x7fcf5f83cd10>], 'f\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83cd50>], 'finds': [2, <__main__.FPTree.Node object at 0x7fcf5f83cd90>], 'one.': [2, <__main__.FPTree.Node object at 0x7fcf5f83cdd0>], 'h\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f83ce90>], \"node's\": [2, <__main__.FPTree.Node object at 0x7fcf5f83cf50>], 'f': [2, <__main__.FPTree.Node object at 0x7fcf5f83cf90>], 'arbitrarily': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8050>], 'happens': [2, <__main__.FPTree.Node object at 0x7fcf5f7a80d0>], 'memory': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8110>], 'Thus': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8150>], 'b': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3410>], 'removed': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8250>], '>': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3510>], 'Alternatively,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8390>], 'C': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8450>], 'least': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8490>], 'becomes': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8510>], 'target.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8550>], 'unbounded': [2, <__main__.FPTree.Node object at 0x7fcf5f7a85d0>], 'n\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3650>], 'call': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8650>], '.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a86d0>], 'steps,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a87d0>], 'infinite': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8810>], '+\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f895ed0>], 'sequence': [2, <__main__.FPTree.Node object at 0x7fcf5f7a88d0>], ',\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8910>], 'eventually': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8950>], 'smallest': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8a10>], 'x': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8a50>], 'positive': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8b10>], 'When': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8b50>], 'traversal': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8c10>], 'corresponding': [3, <__main__.FPTree.Node object at 0x7fcf5f7e38d0>], 'heap': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8cd0>], 'once': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3a10>], '=': [4, <__main__.FPTree.Node object at 0x7fcf5f89c050>], 'definitions': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8d10>], 'original': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8d90>], 'elements,': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3ad0>], 'per': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3b50>], 'significantly': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8e50>], 'takes': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8e90>], 'occurs': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3bd0>], 'track': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8f10>], 'considering': [2, <__main__.FPTree.Node object at 0x7fcf5f7a8fd0>], 'memory.': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7050>], 'end': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3e10>], 'complexity,': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7190>], 'equally': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3e50>], 'case': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3f10>], '{\\\\displaystyle': [4, <__main__.FPTree.Node object at 0x7fcf5f89c190>], 'keeps': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7250>], 'check': [3, <__main__.FPTree.Node object at 0x7fcf5f7e3f90>], 'hence': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7290>], 'ending': [2, <__main__.FPTree.Node object at 0x7fcf5f7b72d0>], ',': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7310>], 'example': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7350>], 'nodes,': [2, <__main__.FPTree.Node object at 0x7fcf5f7b73d0>], 'path': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7410>], ')\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f89c250>], 'concepts': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7450>], 'true': [2, <__main__.FPTree.Node object at 0x7fcf5f7b74d0>], 'grow': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7590>], 'pre-process': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7610>], 'If': [3, <__main__.FPTree.Node object at 0x7fcf5f81d1d0>], 'factor': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7750>], 'g': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7790>], 'x\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7810>], 'compute': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7850>], '=\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f81d310>], '\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f89c450>], 'tree,': [3, <__main__.FPTree.Node object at 0x7fcf5f81d3d0>], 'terminate': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7950>], 'node,': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7990>], 'itself': [3, <__main__.FPTree.Node object at 0x7fcf5f81d450>], 'y\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7a10>], 'constant': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7a90>], 'ε\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7b10>], 'contained': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7bd0>], '\\u2061\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7c50>], 'time.': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7c90>], 'times': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7cd0>], 'target': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7d90>], 'logarithmic': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7e10>], 'tree': [3, <__main__.FPTree.Node object at 0x7fcf5f81d590>], 'n': [4, <__main__.FPTree.Node object at 0x7fcf5f89c4d0>], 'available': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7e50>], '(\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f89c510>], 'Every': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7f10>], '≤\\n': [4, <__main__.FPTree.Node object at 0x7fcf5f89c590>], '1': [3, <__main__.FPTree.Node object at 0x7fcf5f81d6d0>], 'note': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7f90>], 'start': [2, <__main__.FPTree.Node object at 0x7fcf5f7b7fd0>], 'possibility': [2, <__main__.FPTree.Node object at 0x7fcf5f7c9050>], 'proof': [2, <__main__.FPTree.Node object at 0x7fcf5f7c9150>], 'pathological': [2, <__main__.FPTree.Node object at 0x7fcf5f7c9190>], '−': [2, <__main__.FPTree.Node object at 0x7fcf5f7c91d0>], 'manner,': [2, <__main__.FPTree.Node object at 0x7fcf5f7c9210>], '0\\n': [3, <__main__.FPTree.Node object at 0x7fcf5f81d8d0>], '.\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7c9250>], 'pointers': [2, <__main__.FPTree.Node object at 0x7fcf5f7c92d0>], 'cost': [3, <__main__.FPTree.Node object at 0x7fcf5f81d910>], 'Binary': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6350>], 'children,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6390>], 'ordered': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6510>], 'References': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6550>], 'type': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6590>], 'children': [2, <__main__.FPTree.Node object at 0x7fcf5f7a65d0>], 'sorted': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6610>], '3': [3, <__main__.FPTree.Node object at 0x7fcf5f828b10>], 'necessarily': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6650>], 'height': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6690>], '2': [3, <__main__.FPTree.Node object at 0x7fcf5f828bd0>], 'say': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6750>], 'worst-case': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6810>], 'science,': [3, <__main__.FPTree.Node object at 0x7fcf5f828e10>], 'left': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6890>], 'third': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6950>], 'passing': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6990>], 'space.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a69d0>], '{\\\\frac': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6a10>], 'data,': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6a50>], 'string': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6a90>], 'advantage': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6ad0>], 'insertion': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6b10>], 'exception': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6bd0>], 'array.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6c10>], 'tree.': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6c50>], '==': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6c90>], 'comparable': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6d50>], 'need': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6dd0>], 'a\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f7a6f10>], 'beginning': [2, <__main__.FPTree.Node object at 0x7fcf5f808cd0>], 'content': [2, <__main__.FPTree.Node object at 0x7fcf5f808e10>], 'absence': [2, <__main__.FPTree.Node object at 0x7fcf5f761190>], 'sort': [2, <__main__.FPTree.Node object at 0x7fcf5f7616d0>], 'desired': [2, <__main__.FPTree.Node object at 0x7fcf5f771090>], '(for': [2, <__main__.FPTree.Node object at 0x7fcf5f771150>], 'method.': [2, <__main__.FPTree.Node object at 0x7fcf5f7712d0>], 'Therefore,': [2, <__main__.FPTree.Node object at 0x7fcf5f771c90>], 'short': [2, <__main__.FPTree.Node object at 0x7fcf5f782290>], 'practice': [2, <__main__.FPTree.Node object at 0x7fcf5f782850>], 'extra': [2, <__main__.FPTree.Node object at 0x7fcf5f782b90>], 'build': [2, <__main__.FPTree.Node object at 0x7fcf5f791090>], 'searched': [2, <__main__.FPTree.Node object at 0x7fcf5f791110>], 'index': [2, <__main__.FPTree.Node object at 0x7fcf5f791590>], 'once,': [2, <__main__.FPTree.Node object at 0x7fcf5f791690>], '\\n\\n': [2, <__main__.FPTree.Node object at 0x7fcf5f791750>], '1,': [2, <__main__.FPTree.Node object at 0x7fcf5f721f50>]}\n",
            "{frozenset({'(and', 'capacity.', 'approaches.\\n\\nVariants\\nChromosome', 'does', 'blocks.\"Despite', 'hypothesis,', 'hybridized', 'notion', 'sub-symbolic', '1957,', 'groups', 'tuning,', 'general', 'between', 'also\\nGenetic', 'intended', '[sic]', 'attempts', 'many', 'publication', '(as', 'high', 'performance', 'minimum', 'problems.\\nGAs', 'problems),', 'walking', 'Dilemma\\nAn', 'evaluation', 'ranking', '1990s,', 'problems\\nIn', 'selected.', 'commonly', 'watch', 'size', 'published', 'operators.\\n\\nInitialization\\nThe', 'regrouping,', 'common', 'time', 'Lunch', 'evolved', 'favorably', 'relies', 'begin', 'SA', 'simulations', 'Other', 'one', '\"evolve\"', 'limiting', 'Axcelis,', 'programming\\nList', 'tabu', 'algorithm.', 'solution.\\n\\nTermination\\nThis', 'combine', 'Ingo', 'drops', 'multi-parameter', 'essentially', 'blocks', 'limited', 'amount', 'generality', 'software', 'languages,', 'sub-field:\\n\\nEvolutionary', 'needs', 'define', 'such', 'optima', 'value', 'find', '(recombined', 'finite', 'engineering', 'based', 'breed', 'employed', 'make', '(particles)', 'studies', 'Michigan.', 'references', 'you', 'role', 'J.', 'performance,', 'nature).', 'candidate', 'Jersey.', 'reducing', 'undergoing', 'chromosomes', 'unlike', 'toward', 'Theory', 'speed', 'methods.\\n\\nMemetic', 'selectively', 'real', '\"ambition\"', 'recombination),', 'structure.', 'adapt', 'requires', 'own', 'PSO', 'strategies', 'i.e.,', 'initial', 'iterations', 'occur', 'similar', 'broadly', 'detailed', 'expression;', 'probability', 'subset', 'any', 'organisms,', 'computer', 'Often,', 'construction', 'Hans-Joachim', 'values', '(e.g.', 'however,', 'First', 'throughout', 'blades', 'designs.', 'below).', 'fields\\nGenetic', 'complex', 'intelligence\\nSwarm', 'procedure', 'neural', 'readily', 'domain,\\na', 'multimodal', 'pair', 'online', 'which', \"Rechenberg's\", 'algorithms,', 'hybrid', 'recombination', 'fit', 'music,', 'predictive', 'sunlight', 'recombining', 'predicting', 'using', 'penalizes', 'bits,', 'domains.\\nWhen', 'timetabling', 'Its', 'mixing,', 'system)', 'rate', 'solution,', 'Axelrod.', 'solutions.\\n\\nOther', 'higher', 'number', 'preferentially', 'best', 'right', 'space.\\nExtremal', 'search', 'next', 'ratio', 'constraints.\\nA', 'terminates', 'parts.\\nThe', 'space.\\nDifferential', 'past', 'removing', 'guided-crossover.\\nGenetic', 'technology', 'expensive', 'similar)', 'items,', '(ES,', 'creators', 'intelligence.', 'its', 'helps', 'into', 'climbing.\\nThis', 'because', 'allowing', 'puzzles,', 'cardinality', 'migration', 'disjoint', 'natural', 'more', 'integers', 'describes', 'ordinary', 'genetic', 'writer', 'estimation', 'testing', 'up', 'pm,', 'variables.\\n\\nOther', 'science', 'mix', 'nodes.', 'previously.', '(CMA-ES).\\nEvolutionary', 'determine', 'colony', 'decrease', 'etc.\\n\\nMethodology\\nOptimization', '\"parents\"', 'be', 'years—can', 'metaheuristic', 'hill', 'learned', 'evolution—where', 'function.\\n\\nAdaptive', 'effective', 'most', 'adding', 'depends', 'found.\\n\\nSelection\\nDuring', '1954', 'operators,', 'combination', 'replace', '1980s,', 'process,', 'aligned', 'hard', '(e.g.:', 'example,', 'do', 'fields\\nEvolutionary', 'Barricelli,', 'active', 'component', 'Henry', 'otherwise.\\nIn', 'required.\\n\\nHeuristics\\nIn', 'pick', 'though,', 'genes', 'recombination.', 'fitness', 'require', 'learn', 'greater', 'Conrad.', 'array', 'superorganisms.\\nGaussian', 'Study', 'gain', 'His', 'inspection\\nCombinations', 'house', 'pm', 'unless', 'p).', 'phenotype),', 'search.', 'mutation.', 'alphabet', 'abbreviated', 'regarding', 'translated', 'attack', 'evaluated;', 'changes', 'employing', 'Whitley', '(or', 'Fogel,', 'total', 'proposed', 'parents', 'difficult', 'reduced', 'ES', 'particularly,', 'tutorial', 'parents.\\nEstimation', 'application', '\"learning', 'multiple', 'contemporary', 'Overview', 'loss', 'Common', 'odds', 'encodings', 'extremely', 'destructive', 'therefore', 'Markov', 'permits', 'likelihood', 'maximum', 'even', 'encourage', 'low', '\"know', 'seemed', 'distribution.', 'representations.', 'artificial', 'rule', 'GAs', 'parameters', 'conceivable', '(a.k.a.', 'signal', 'theoretical', 'students', 'tree-based', 'of:\\n\\nA', '(its', 'real-valued', 'Palisade', 'in.', 'always', 'information.', 'large', 'techniques\\nParent', 'ready', 'allow', 'length,', 'working', 'maximize', 'success/failure', 'Application\\nGenetic', 'concatenating', 'optimization\\nOptimization\\n\\nRelated', 'definition', 'stop', 'originally', 'creatures,', 'drift', 'constructing', 'chain).\\nExamples', 'Holland', 'reaching', 'overall', 'started', 'possible.', 'dependent', 'fitness-based', 'Different', 'and,', 'evaluated', 'traditionally,', 'scheduling', '\"comma', 'fitness.', 'Linear', 'optimal', 'giving', 'AGA', 'cases,', 'misnomer', 'Block', 'conditions', 'offered', 'field\\nAn', 'voodoo', 'members,', 'good', 'Gene', 'worked', 'including', 'selection', 'simple', 'Pennsylvania.\\n\\nCommercial', '(pc)', 'former', 'worse', 'successfully', 'description.', '\"seeded\"', 'implementations', 'Gaussian', 'necessary', 'reinforcement', 'kind', 'makes', 'quantitative', 'creates', 'work', 'difficult,', 'needs.\\n\\nHistory\\nIn', 'used', 'strategy\"', 'integration', 'Algorithms\\n\\nTutorials\\nGenetic', '\"parent\"', 'programming,', 'likely', 'comparison', 'Algorithm', 'computationally', 'approaches', 'iteration.\\nReactive', 'proves', 'provides', 'climbing,', 'occurring', 'members.', 'Science', 'efficiency', 'able', 'follow', 'maximise', 'diversity', 'Burnell', 'Like', 'problems.', 'manipulate', 'influenced', 'help', 'objective', 'International', 'than', 'belief', 'put', 'optimize', 'processing', 'forming', 'adaptation.', 'methods.\\n\\nSimulated', 'batch,', 'ensure', 'way', 'principles', 'space).', 'identifying', 'chromosomal', 'producing', 'reasonable', 'efficient.', 'parallel', 'successes', 'take', 'focus', 'scale', 'John', 'learning,', 'Making', 'chromosomes.', 'items', 'These', 'capacity', 'sub-field', 'population,', 'largely', 'GGA', 'explained', 'suggest', 'some', 'especially', 'discovering', 'climb).', 'waste', \"Fraser's\", 'programming;', 'beneficial', 'recombination.\\nA', 'cannot', '(1970)', 'ergodicity', 'approximated', 'optimum,', 'belong', 'defined,', 'other', 'entirely', 'walls,', '1963,', 'representation', 'an', 'maintain', 'Just', 'there', 'remedy', 'feedback', 'algorithms.It', 'generates', 'variants,', 'Occasionally,', 'wrote', 'parts', 'plans,', '1970s,', 'divided', 'time/money)', 'useful', 'difference', 'encourages', 'solving', 'Rechenberg', 'numbers', 'performed', 'optimized.', 'current', '(called', 'aesthetic', 'Colorado', 'three', 'penalty', 'Bremermann', 'etc.\\nGrouping', 'order', 'structure', '(simplex', 'direct', 'implement', 'approximate', 'environment', 'problems.\\nAs', 'bit', 'design', 'programming.\\nOnce', 'significant', 'themselves.', 'phones,', 'use', 'Further,', 'comes', 'popularized', 'solar', 'years.', '1997,', 'stuck', 'life', '(BA)', 'research', 'starts', 'programming)', 'GA', 'figures,', 'Markoff', 'processor', '(swarm)', 'consistently', 'Artificial', 'expansion', 'above\\n\\nThe', 'product,', 'short,', 'it', '(less', '(TS)', 'obtain.', 'accuracy', 'memetic', 'or', 'child', 'chromosome', 'arguably', 'shown', 'iterative', 'substitutes', 'Koza', 'exact', 'computation', 'measure', 'solutions', '(when', 'about', 'Theorem.', 'instances,', 'successive', 'vehicle', 'as', 'mutated', 'fixed', 'optimization)', 'chromosome.', 'degree', 'avoid', 'ant', 'information)', 'absolute', 'blocks.', 'implementing', 'impossible', 'Arrays', '1970s', 'applications', 'group', '(average', 'Luke.\\nGlobal', 'wants', 'though', 'deal', 'vastly', 'disappear.', 'representation.An', 'Darrell', 'where', '(see', 'potentially', '(\"fitness\").', 'object', 'measure.\\nFor', 'consensus', 'Hamming', 'lack', 'domain.A', 'simultaneously', 'industrial', 'statistics,', 'rather', 'this', 'settings', 'lead', 'continues', 'evolves', 'found', 'so', 'reproduction', 'can', 'machines', 'maximises', 'criterion', 'basic', 'making', 'result,', 'generations,', 'gene', 'processes.', '6th', 'tool', 'University', 'is', 'objects', '[T]he', 'simply', 'implementation', 'hypothesis\\nGenetic', 'methods.', 'support', 'ultimately', 'schemata,', 'Fine-grained', 'adequate', 'acceptability', 'fan', 'in', 'well', 'remained', 'too', 'initialize', 'modifications', 'Individual', 'solution.', 'automata,', 'carry', 'moment', 'excellent', 'impose', 'representation\\nThe', 'introduced', 'computing.\\n\\nEvolution', 'somehow', '\\nIn', 'knapsack', 'Robert', 'away', 'primarily', 'designs', 'variation,', 'exploiting)', 'swarm', 'practical', 'Friedman,', 'numeric', 'dynamic', 'variant', 'construct', 'urban', 'schema\\nUniversal', 'Princeton,', 'results', 'distributions.', 'building', \"prisoner's\", 'crossover', 'almost', 'possibly', 'widely', 'breeding', 'phenotypic', 'Commonly,', 'GA)', 'antennae', 'mutations', 'mutated)', 'Schwefel', 'domains', '(no', 'opportunity', 'Friedberg,', 'interacting', 'pseudobiology', 'hold.', 'your', 'machine', 'case.', 'via', 'solve', 'different', 'if', 'when', 'they', 'planning,', 'climbing)', 'generally', 'larger', 'productive', 'algorithms:\\n\\nRepeated', 'satisfactory', 'arrays', 'controller', 'further', 'books', 'internal', 'selects', 'prevent', 'already', 'Strategy', 'generational', 'increases', 'Richard', 'Typical', 'used,', 'Covariance', 'survival', 'less', 'calculation', 'class', 'attempt', 'theory', 'appear', 'accepted', 'disparate', 'no', 'reached', 'radio', 'classical', 'rules', 'against', 'Nils', 'Observe', 'adaptation,', 'algorithm),', 'parameterized', 'adaptive', 'adaptation', 'hyperparameter', 'Darwinism\\nMetaheuristics\\nLearning', 'Optimization', 'Skiena', '(GGA)', 'optimum', '–', 'learning', 'whereas', 'So,', 'external', 'building-block', 'introduce', 'along', 'result', 'virtual', 'model', 'landscape.', 'like', 'game,', 'selected,', 'seek', 'node', 'still', 'algorithms.\\n\\nLimitations\\nThere', 'hours', 'importance', 'used.\\n\\nGenetic', 'on)', 'Turing', 'Reactive', 'section,', 'not', 'reached\\nAllocated', 'problem.\\nIn', 'book', 'complexity', 'a', 'noise', 'and/or', 'integers,', 'Models,', 'Grammatical', 'solutions.', 'easier', 'variations', 'Coarse-grained', 'implement,', 'smoothed', 'position', 'only', 'GAs,', 'remains.', 'Institute', 'known', 'designed', 'reported', 'ants', 'context', 'alone', 'assessment', 'entire', 'Moreover,', 'function,', 'Estimation', 'valleys', 'approach', 'GA.', 'machine\"', 'self-adaptation', 'valid', 'operators\\nThe', 'optima.', '1970s.', 'Manual,', 'given', 'particle', 'Rechenberg,', 'sharp', 'State', 'assume', 'equipped', 'coding', 'intelligence', 'manufacturing', 'states', 'strategy', 'organisms', '(adaptive', 'chromosomes.\\nThese', 'contains', 'implementation.\\nGenetic', 'fluid', 'results\\nManual', '\"building', 'convergence', 'global', 'algorithms.', 'optimum.', 'noteworthy', 'ridge', 'They', 'to', 'thumb', 'concerning', 'starting', 'longer', 'implementations\\nParallel', '(1998).Although', 'believed', 'advocates', 'knapsack.', 'probabilistically', 'fall', 'nodes', 'broken', 'heterogeneous', 'The', 'simplest', 'decreasing', 'packages', 'magnitude.', 'genomes', '(GP)', 'sum', 'learning\\n\\nReferences\\nBibliography\\nExternal', 'occasionally', 'Starting', 'are', 'single', 'shapes', 'evolution.', 'amalgamation', 'whether', 'belongs', 'systems.', 'represent', 'schedule.\\nTabu', 'set', 'strings', 'change', 'at', 'offspring.', 'blocks],', 'appropriate', 'Evolution', 'population', 'Systems', 'versus', '\"niche', '\"parents\".', 'loop', '(the', 'evolutionary', 'increase', 'Evolutionary', 'late', 'flavors.', 'forbidden', 'Learn', 'convenient', 'identical', 'variables.', 'traverses', 'me', 'mGA,', 'individuals', 'evaluations.', 'boundaries.', 'integer', 'memes,', 'areas', 'resampled', 'disorder', 'modern', 'terms', '2009', 'low-order,', 'have', 'measure,', '(ACO)', 'algorithms.\\nBacteriologic', 'seeking', 'Conference', 'programming', 'over', 'governing', 'defining', 'skepticism', 'accessible', 'operators:', 'floating', 'sudoku', 'region.', 'designing', 'components', 'fitness.\\nA', 'low-quality', 'during', 'our', 'ways', 'way,', 'were', 'By', 'graph-form', 'better,', '-', 'EO', 'those', 'above,', 'problems', 'Toth,', 'pool', 'elitist', 'diverse', 'system\\nRule-based', 'pc', 'he', 'phases.', 'movement', 'types', 'element', '1989,', 'Department', 'acts', 'strategies,', 'updated', 'DNA', 'packing,', 'parlance,', 'recombined', 'level.', '(antennas', 'increasing', 'often', 'pools', 'population-based', 'problems,', 'works:', 'Results', 'population.\\nA', 'domains\\nProblems', 'include', 'operations.', 'Evolver', 'keeping', 'George', 'premature', 'must', 'characteristics', 'inversion', 'provide', 'pioneers', 'released', 'effective,', 'dependent.', 'either', '1960s,', 'combination,', 'high-dimensional,', 'by', 'millions', 'other.', 'utilize', 'moves', 'principle', 'operators', 'algorithm', 'energy', 'algorithms', 'needed', 'tendency', 'satisfies', 'methods\\nMetaheuristic', 'events', 'mechanisms,', 'trees', 'encountered', 'altered;', 'length', 'peaks', 'appropriate.\\n[...]\\n\\nI', 'programs,', 'noticed.', 'maintained', \"Bremermann's\", 'generation.', 'dominant)', 'several', 'data', 'AGAs', 'Particle', 'Such', 'due', 'above', 'Algorithms', 'robustness', 'hundreds', 'effectively', 'blocks\",', 'stored', 'particularly', 'Hypothesis', 'usually', 'Since', 'sufficient', 'variants', 'reached.', 'that', 'consecutive', 'involves', 'distribution', 'how\"', 'clustering', 'cross-entropy', 'included', 'new,', 'aim', 'instruction', 'convergence.', 'seem', 'method', 'word', 'Alternating', 'how', '(like', 'Again,', '(PSO)', 'follows:\\n\\n\"Short,', 'modified', 'list,', 'decision', 'will', 'Aall', 'air', 'fitter', 'poorly.', 'understand', 'Programming,', 'adjustment', 'without', 'converge', 'trait.', '1960s', 'early', 'description', 'judge', '[...]', 'segment', 'systems,', '(pm)', 'rates/bounds', 'crossover,', 'mirrors', 'generating', 'Free', 'However,', 'obtained', \"Holland's\", '(EO)', 'clear', 'days', 'algorithms\\nEvolutionary', 'speaks', 'inherently', '(before', 'form', 'unaltered.', 'operators.', 'situation', 'constant.\\n\\nOther', 'Second,', 'time-dependence', 'Certain', 'living', 'all', '(such', 'wherein,', 'easily', 'defining-length', 'Thus,', 'sharing', 'time-consuming.\\nThe', 'sold', 'greatly', 'but', 'repeated', 'instead', 'increased', 'probably', 'radius)', 'every', 'near', 'fuzzy', 'next,', 'Probabilistic', 'population.', '(EA).', 'regulator', 'explanation', 'string).', 'level', 'highly', \"world's\", 'study', 'range', 'function)', 'portion', 'it.', 'data.', 'subsets', 'techniques', 'impressed', 'structures', 'treat', 'Hence', 'last', 'Evolver,', 'reliance', 'areas.\\nAlthough', 'why', 'linked', 'Fogel', 'lower', 'particular', 'genotype)', 'problem', 'optimization,', 'originated', 'inefficient', 'Australian', 'quickly', 'rates/bounds,', 'play', 'shape', 'optimisation', 'seen', 'epistasis,', 'wood,', 'line', 'environment,', 'essential', '[the', 'process', 'methods', 'locally', 'subsequent', 'these', 'samplings.\"Because', 'trial', 'way.', 'convincingly', 'recombination,', 'equivalent', 'temperature', 'long', 'practise', '(225', 'table,', 'objects,', 'Stick', 'genome', 'crests', 'from', 'generated.\\nAlthough', 'sampled,', 'solved', 'robust.', 'airfoils', 'Dominance', 'selection.', 'types,', 'small', 'unconstrained', 'led', 'implies', 'later', 'certain', 'Design', 'developed', 'resources', 'me.', 'cell', 'problems.\\nGenetic', 'Methodologies', 'parametric', 'randomly,', 'modelling', 'sacrifice', 'plateau', 'see', 'surprising', 'individual', \"solution's\", 'condition', '0s', 'Falkenauer', 'simultaneous', 'typically', 'Martello', 'defined', 'iteration', 'part', 'proved', 'adapt.', \"swarm's\", 'Tutorial', 'metaheuristics.\\n\\nSee', 'point', 'product', 'each', 'repetitive', 'In', 'quality', 'computational', 'local', 'uses', 'mining.\\nCultural', 'preference.\\n\\nSwarm', 'real-value', 'order,', 'environments,', 'penalty\",', 'environment.', 'reactive', 'relying', 'domain.', 'validity', 'then', 'magnificent', 'Indeed,', 'accepted.', 'of', '(MA),', '(clustering-based', 'steps', 'bacteriologic', '[crossed', 'toolkit', 'cascaded', 'main', 'General', '(RSO)', 'involve', 'suitability', 'thousands', 'their', 'mutation,', 'Generally,', '(simulated', 'considered', 'climbing', 'hand,', '(1975).', 'interactions.', 'phenotype', 'structural', 'termination', 'really', 'task:\\n\\n[I]t', 'Adaptation', 'fully', 'depending', 'evolution', 'come', 'results,', 'special', 'may', 'easy', 'lowers', 'facilitates', 'formalized', 'evaluate', 'whose', 'cycling', 'Building', 'related', 'approach.', 'linear', 'non-ergodic', 'behavior', 'triggered', 'aerodynamic', 'mainframe-based', 'similar;', 'over],', 'pheromone', 'arbitrary', 'sustain', 'on.', '(CA)', 'samples', 'select', 'simulation', 'alleviated', 'Alternative', 'addition,', 'technique', 'fortresses', 'mid-1980s,', 'action', 'expected', 'stochastically', 'protect', 'version.', 'balancing,', 'critical', 'resistance', 'forms', 'i.e.', 'individual,', 'Diversity', 'Inc.', 'linguistic', '(EP)', 'affected', '1994)', 'perform', 'optimisation.', 'equal', 'ecology', 'homogeneous', 'states.\\nIt', 'colonization-extinction,', 'applied', 'loci', 'I', 'initially', 'intuition', 'others', 'specific', '0', 'recognized', 'Some', 'next.\\n\\nParallel', '(DE)', 'Michael', 'Sean', 'addition', 'artistic', 'funnel', 'particular,', 'since', 'From', 'reached\\nThe', 'function', 'whole', 'idea', 'decidedly', 'nature', 'high-performance', 'two', 'might', 'While', 'meaning', 'replacing', 'adaptively', 'search.\\nAlthough', 'been', 'problem.', 'generate', 'a.k.a.', 'crossovers.', 'Flavors', 'child,', 'paternal', 'requires:\\n\\na', 'generated', '(CE)', 'solution.\\nOther', 'traverse', 'evolve', 'produced,', 'mutation-based', 'them', 'lowest', 'subject', 'concept', 'products\\nIn', 'Each', 'terminating', 'block', 'we', 'Schema', 'name:', 'parameters,', '(SA)', 'minimization,', \"Prisoner's\", 'Written', 'explored', 'problem,', 'CAGA', 'valid,', 'ensures', 'models', 'theorem', 'so-called', 'simulation.', 'very', 'respect', 'standard', 'bodies', 'reprinted', 'generated.', 'could', '(2006)', 'step', 'Another', 'information', '1950,', 'space,', 'yield', 'experimental', 'others,', 'introducing', 'Crossover', 'tuning', 'Pittsburgh,', 'for', 'include:', 'also', 'Provides', 'bin', '(computation', 'tractable', 'means', 'both', 'convergence,', 'Finding', 'perspective', 'aircraft', 'landscape:', 'hypothesis', 'genes.', 'operator', 'adjust', 'preventing', 'until', 'first', 'adopted', 'parameters.', 'evolving', 'right/wrong', 'History', 'limitations', 'place', 'Because', 'while', 'behind', 'controlling', 'issue', 'longer-term', 'desktop', 'properties', 'optimization', 'imaginable', 'became', 'LLGA.\\n\\nProblem', '\"biology', 'search,', '(niche', 'Metaheuristics\",', 'move', 'classifier', 'employed.', 'nontrivial', 'Alan', 'date.\\nInteractive', 'children.\\nOpinion', 'important', 'Emanuel', 'Not', 'held', 'quite', 'are:\\n\\nA', 'ascent', 'events)', 'indexes', 'evaluation.', 'matrix,', 'case,', 'uniform', 'researchers', 'dilemma.', 'images,', 'short-term', 'arrangement', 'selling', 'commercial', 'plane.', 'possible', 'biologists', 'trick,', 'promising', 'towards', 'Mutation', 'favour', 'biologically', 'Typically,', 'solved.', 'complete', 'performs', 'random', 'would', 'Evolution,', 'reader', 'better', 'smaller', 'probability,', 'budget', 'string.', 'components.', 'exponential', 'York', 'An', 'immigrants).', 'Criterion', 'second', 'world', 'examples', 'mutation.\\nOperating', 'human', 'same', 'GEMGA', 'GAs\\nGenetic', 'randomly', 'high-quality', 'networks,', 'Although', 'instance', 'That', '(seen', 'existing', 'Variable', 'exceed', 'Crosby', 'popular', 'hints', 'improve', 'open', 'mutation', 'crossing', 'cellular', 'operations', 'theory\\n\"Essentials', 'although', 'traditional', 'was', 'has', 'partial', 'created', 'the', 'heterogenously', 'text', 'interest', 'built', 'Matrix', 'implicitly', 'Graphical', 'guarantees', 'improvement', 'Times', 'heuristic', 'progress', 'search).\\n\\nRelated', 'representations', 'alternative', 'unnatural', 'consists', 'finding', 'complementary', 'heuristics', 'permitting', 'schemata', 'space', 'overcoming', 'regions', 'faster', 'through', 'engines,', 'hashes,', 'model-guided', 'knowledge', 'positioning', 'Therefore', 'frequently', 'add', 'processes.\\n\\nElitism\\nA', 'flowfieldsIn', 'Instead', 'intermediate', 'GAs.', 'Python', 'links\\nResources\\n[1]', \"individual's\", 'strings.', 'classic', 'agents)', 'property', 'logics.', 'advises', 'Fraser', 'BAs', 'items.', 'filters)\\nPropagation', 'designed.', 'had', 'computing\\nMetaheuristics\\nStochastic', 'sets', 'assigned', 'alphabet,', 'relatively', 'genes,', 'suitable', 'much', 'Electric', 'individuals,', 'For', 'similarity', 'measured', 'parameter.', 'geneticist', 'shares', 'response', 'No', 'trying', 'forgo', 'engine,', 'and', 'get', 'proceeds', 'list', 'prohibitive', 'New', '(0', 'disruptive', 'who', '(which', 'Computer', 'populations', 'papers', 'object,', 'series', 'piles,', 'collector,', 'possible.The', 'algorithm)', 'As', 'inspired', 'analogy', '(GA)', 'De-randomization', 'sampled', 'organism(s)', 'self-tuning', 'encoded', '(EDA)', 'control', 'achieved', 'solution', 'framework', 'provided', 'breeding,', 'size.', 'vectors', 'derivative-free', 'methods\\nThe', 'resemble', 'programs', 'phenotypes)', 'adds', 'signals', 'highest', 'efficiency.', 'selected', 'few', 'heuristic.Goldberg', 'among', 'conducted', 'landscape', 'being', 'research,', 'neighboring', 'position.', 'instance,', 'with', 'efficient', 'called', 'domain', 'Cartesian', 'tends', 'represented', 'exposed', 'worst', 'binary', 'size,', 'mechanism', 'failures', 'encoding', 'Lawrence', 'Natural', 'apparent', 'fits', '(possibly)', 'Advanced', 'There', 'efficiency.A', 'computers.', 'on', 'is,', 'orders', 'beginnings,', 'generation', 'Hans-Paul', 'measures', 'emergent', 'generation,', 'ability', 'generations', 'reason', 'combining', 'pattern', 'engineering.', 'recombines', 'implemented', 'A', '\"child\"', 'computing.\\n\\nAnt', 'confusion', 'currently', 'simulated', 'distance', 'shifted', 'such,', 'state', 'hypermutation),', 'another', 'worth', 'NA', 'Unlike', 'bit-string', '(BBH)', 'particles', 'complexity.', 'reduce', '\"better\"', 'represents', 'probabilities', 'processes', 'programming.', 'analysis', 'variable', 'down', 'reproduction.\\nOther', 'query', 'optimizing', 'dynamics', \"users'\", 'mean', 'proportion', 'This', 'strategies.', 'solutions,', 'added,', 'speciation', 'expression', 'Research', '(normal', 'maternal', 'succeed', 'described', 'efficiently', 'allows', 'average', 'reference', 'suggests', 'Multi', 'Distribution', 'Alex', 'interactive', '1s,', 'packing', 'Many', 'introduction', 'Tree-like', 'variation', 'computing', 'component.', 'etc.,', '(1973).', 'partitioning', 'criteria\\nFixed', 'inspired\",', 'never', 'measurable', 'his', 'produce', 'within', 'elements', 'Several', 'classes', 'Search', 'applications\\nGenetic', 'stochastic', '1)', 'Gray', 'points', 'sample', 'continuous', 'conventional', 'juxtaposition', '1990,', 'specialized', 'annealing', 'typical', 'mutation.\\nFor', 'bits', 'It', 'new', 'practicality', 'discrete', 'algorithm,', 'understand.', 'Prominent', 'split', '1995.', '(also', 'annealing,', 'MATLAB', 'problem;', 'compared', 'AGAs)', 'Genetic', 'maximisation'}): 1, frozenset({'', 'practice,', 'zero', 'details\\nThere', 'invented', 'been', 'involved', '−\\n', 'greedy', 'does', 'optimizations', 'h(n)=0}\\n', 'Good', '(Updated)\".', 'reading\\nNilsson,', '≤', 'h(x).\\n\\nPseudocode\\nThe', 'Los', 'notion', 'cannot', 'other', 'generated', 'entirely', 'generalization', 'biggest', 'leading', 'an', 'lowest', 'general', 'there', 'between', 'g(n),', 'again.', 'follows:\\nWhen', 'consistent,', 'we', 'attempts', '2\\n', '(FSA*)\\nGeneralized', 'speaking,', 'many', '}^{*}}\\n', 'recently', 'reachable', 'terms', 'problem-specific.', 'map', 'performance', 'minimum', 'want', 'Specifically,', 'cost).', 'California:', 'theorem', 'Planning', 'have', 'cheapest', 'Shakey', 'operation', 'Alto,', 'travelled,', 'value.', 'stores', 'run,', 'solving', 'openSet,', '1968', 'very', \"cases\\nDijkstra's\", 'searches.\\n\\nBounded', 'respect', 'standard', 'weighted', 'graphs:', 'edge', 'w(n))h(n)}\\n', 'performed', 'At', 'goal', 'N.', '(where', 'times,', 'actual', 'could', 'predecessor', 'Oftentimes', '\\\\varepsilon', 'step', 'α\\n', 'Rina', 'advice', 'Intelligence.', 'size', 'published', 'definitive', 'space,', 'learning.\\n\\nRelations', 'common', '‘tentative_gScore', 'time', 'running', 'prune', 'n,', 'continue', 'stating', 'b\\n', 'for', 'admissible', 'one', 'also', '(x,', 'approximate', 'estimated', 'bit', 'quality', 'heap,', 'those', 'behave', 'admissibility', 'problems', 'On', 'A*/Static', 'links\\nClear', 'parsing', 'A_{\\\\varepsilon', 'goal;', 'significant', 'algorithm.', 'paragraph),', 'Retrieved', 'diverse', 'd(x,y)>\\\\varepsilon', 'means', 'satisfying', 'use', 'both', 'nodes;', 'exist', 'adapted', 'Cf(n)+Dh_{F}(n)}\\n', '\\\\lambda', 'D', 'grid', '(possibly', 'case.\\nIn', 'P', \"doesn't\", 'test', 'maintaining', 'neighbors', \"Weighting's.\", 'limited', 'margin.', 'log\\n', '&g(\\\\pi', 'discovered', 'optimistic', 'research', 'needs', 'bound', 'w\\n', 'until', 'first', 'such', 'criterion.\\n\\nSee', 'specified', 'O(b^{d})}\\n', '&{\\\\text{otherwise}}\\\\end{cases}}}\\n', 'solution).\\nWhen', 'counter', 'overlook', 'meets', 'Peter', 'Artificial', 'value', '\"A-star\")', 'find', 'updated', 'detail', 'depth', 'infinite,', '(a', '>0}\\n', 'Iterative', 'finite', 'exists.', 'grammars', '″correction″', 'it', 'based', 'travel-routing', 'viewed', 'search\\nAny-angle', 'often', 'paths', 'outperform', 'state,', 'or', 'ISBN', 'movements', 'ties', 'assign', 'problems,', 'shown', 'include', 'openSet', 'references', '15', '\\\\Lambda', 'table', 'depth-first', 'search,', 'gives', 'D*\\nFringe\\nFringe', 'J.', 'move', 'exact', 'performance,', 'point:\\n\\nKey:', 'path)', 'candidate', 'about', 'amortized', 'version', 'required', 'important', '|h(x)-h^{*}(x)|=O(\\\\log', 'must', 'weight', 'One', 'as', 'goals.', 'speed', 'guarantee', 'optimality,', '1968.', 'guaranteed', 'expanded,', 'fixed', 'specific-goal-directed', 'great-circle', 'Dechter', 'FOCAL', 'goal.\\nTypical', 'case,', '>\\n', 'referred', 'by', 'own', 'railroads', 'Alts', 'AlphA*', 'February', 'aims', 'iterations', 'expand.', 'subset', 'B', 'any', 'what', '{\\n', 'possible', 'algorithm', 'computer', 'assignment,', '),', 'applications', 'account.\\nSome', 'algorithms', 'values', 'on,', 'satisfies', 'kept', 'pseudocode', 'x.', 'costs', 'however,', 'promising', 'B\\n', 'constants.', '(NBA*)\\nSimplified', 'memory-bounded', 'denotes', 'g\\n', 'far', '2021.', 'searching', 'circumstances', 'return', 'turn,', 'augmented', 'generated,', 'Nilsson', 'where', 'length', 'better', '<', 'optimally', 'intuitive', 'would', 'node.', 'here', 'also\\nBreadth-first', 'exists', 'λ\\n', 'online', 'which', 'exponential', '(estimated)', 'λ', '8', 'expressed', 'map,', '+', 'An', 'functions.', 'measuring', 'video', 'algorithms,', 'With', 'heuristic.\\n\\nHistory\\nA*', 'A*\\nIterative', 'possibilities', '1\\n', '(IDA*)\\nJump', 'due', 'Fibonacci', 'O\\n', 'hash', 'variety', 'second', 'heuristic.', 'required,', 'expanded', 'loop).', 'using', '(n))\\\\leq', 'same', 'list.\\nAε', 'π\\n', 'd:', \"Pearl's\", 'b*,', 'error', 'cases', 'path-finding\\nVariation', 'actions.', 'Its', 'hold', 'following', 'directly', 'variants', 'empirically', 'Weighting', 'branch', 'f\\n', 'finds', 'that', 'one.', 'instance', 'rather', 'earlier', 'effect', 'node.\\n\\nProperties\\nTermination', 'this', 'preferring', '{d(n)}{N}}&d(n)\\\\leq', 'Bidirectional', 'Adaptive', 'lead', 'continues', \"A*'s\", 'solution,', 'h\\n', 'recover', 'higher', 'aim', 'trade-off', 'number', 'best', 'so', 'solution.\\n\\nAdmissibility\\nA', 'found', 'non-pathological', '″up', 'search', 'next', 'can', 'terminates', \"node's\", 'f', 'search\\nLifelong', 'out', 'criterion', 'debias', 'After', 'arbitrarily', 'cities', 'open', 'deepening', \"Dijkstra's\", 'happens', 'successors', 'expansion,', 'monotone,', 'appears', 'estimate', 'list,', 'is', 'chooses', 'its', 'will', 'into', 'because', 'cases.Peter', 'allowing', 'connected', 'implementation', 'operations', 'graph', 'discovered,', 'memory', 'N+1=1+b^{*}+(b^{*})^{2}+\\\\dots', 'sphere)', 'NLP.\\nOther', 'completeness,', 'without', 'words,', 'support', 'complete,', 'more', 'Thus', 'was', 'anticipated', 'has', 'edge),', 'describes', 'b', '⋯\\n', 'systems,', 'created', 'the', 'optimality', 'up', 'removed', 'games,', 'real-world', 'science', 'in', 'queue.', 'criterion.', 'nodes.', 'h*', 'well', 'paper', 'However,', 'extending', 'goal.The', 'admissible.', 'constants.\\nAlphA*', 'determine', 'overestimates', 'Angeles.\\n\\nImplementation', 'To', 'solution.', 'interesting', '>', '1).\\nThe', 'decrease', 'extension', 'Alternatively,', 'guarantees', \"Shakey's\", '(pronounced', 'be', 'Pearl.\\nThey', 'heuristic', '″non-pathological″', 'apart', 'A*-like', 'all,', '{\\\\textstyle', 'straight-line', 'again.\\n\\nExample\\nAn', 'returns', 'search\\nDepth-first', 'C', 'least', 'International)', 'all', 'away', 'becomes', 'has.', 'A\\n', 'target.', 'alternative', 'loop,', 'easily', 'Thus,', 'edges', 'finding', 'usual', 'major', 'cost/distance', 'Tioga', 'unbounded', 'drawback', 'years', 'entry', 'suitably', 'n\\n', 'merely', 'practical', 'heuristics', 'but', 'call', 'h(n),', 'visual', 'f(n)=g(n)+h(n)}\\n', 'space', 'effective', 'most', 'repeated', 'b*', 'depends', 'h(x)=0}\\n', '.', 'faster', 'exploring', 'every', 'dynamic', 'exist.\\nThe', 'through', 'h', 'h^{*}(x))}\\n', 'combination', 'steps,', 'now', 'Judea', 'originating', 'time.\\n\\nSpecial', 'infinite', 'Bertram', 'building', 'A′', 'h(n)', 'showed', '}(n)=(1+w_{\\\\alpha', 'study', 'example,', 'y)', 'route', 'f(x)', 'n.', 'node.\\nAs', 'newly', 'source', 'SRI', '+\\n', 'possibly', 'ε', 'predecessor.', \"d'(x,\", 'algorithm.\\nIt', 'pseudocode,', 'planning.', 'algorithms\\nWhat', '(GAA*)\\nIncremental', 'sequence', 'optimal,', 'cheaper', ',\\n', 'ε-admissible.\\nThere', 'does,', 'eventually', '}(n)={\\\\begin{cases}\\\\lambda', 'had', 'heuristic\"', 'D.C.', 'sets', 'suggested', 'least-cost', 'Company.', 'smallest', 'ha(n)', 'equal)', 'traveled,', 'Manhattan', 'Washington,', 'x', 'lower', 'extended.', 'different', 'if', 'd', 'problem', 'terminate.\\nThe', 'when', 'they', 'development', 'physically', 'planning,', 'parent.', 'backtrack', 'For', '(LPA*)\\nNew', 'generally', 'keep', 'safely', 'ignore', 'blue:', 'positive', 'When', 'seen', 'formulated', 'g}\\n', 'green:', 'complexity', 'h(x)', 'selects', 'correspond', '(1', 'proposed', 'fringe', 'already', 'ε-admissible', 'traversal', 'corresponding', 'reduced', 'essential', 'and', 'roughly', 'relaxation\\nWhile', 'process', 'get', 'taken', '(which', 'determined', 'these', 'graph.\\nDynamic', 'heap', 'g+h}\\n', 'polynomial', 'gScore[neighbor]’', 'consistency', '(4-way', 'assumes', '~\\n', 'path.', 'equivalent', 'once', '=', 'algorithm:\\n\\nRemark:', 'definitions', 'appear', 'h(n).', 'satisfied.\\nAt', 'original', 'Dijkstra', 'plan', 'completeness\\nOn', 'no', 'even', 'fringe.', '(now', 'low', 'algorithms:\\n\\nWeighted', 'fail', 'search.\\nCompared', 'Both', 'from', 'elements,', 'SMA*.\\n\\nApplications\\nA*', 'O(bd),', 'reached', 'extend', 'rule', 'per', 'uninformed', 'N,', 'solution', 'recent', 'solving\\n\\n', 'extend.', 'programming.\\nA*', 'Nils', 'significantly', 'Λ\\n', 'logarithm', 'takes', 'occurs', 'ε)', 'expanding', 'roads', 'efficiency.', 'few', 'guided', 'among', 'relaxing', 'track', 'being', 'always', '–', 'later', 'large', 'certain', 'otherwise\\n', '(not', 'lower-cost', 'sampling', 'Informational', 'guide', 'considering', 'A*\\nD*\\nField', 'Path-Finding', 'search\\nReduced', 'goal,', 'optimistic.\\n\\nOptimality', 'bounded', 'with', 'efficient', 'memory.', 'called', 'initialized', 'along', 'result', 'bidirectional', 'algebra.The', 'game,', 'visited\\nThe', 'affect', 'like', 'hF', 'selected,', '{n}})\\\\\\\\\\\\Lambda', 'state).', 'node', '(avoiding', 'still', 'sum,', 'condition', 'end', 'binary', 'expansions', 'complexity,', 'worst', 'equally', 'subsequently', 'meritorious', 'informed', 'branching', 'part', 'false', 'iteration', 'situations.', 'achieves', 'proved', 'originally', 'bound.\\n\\nVariants\\nAnytime', 'Publishing', 'case', '{\\\\displaystyle', 'on', 'changed', 'point', 'paths,', 'Λ', 'not', 'octile', 'etc.).', 'keeps', 'each', 'claiming', 'A*', 'check', 'Graph', 'In', 'uniform-cost', 'a', 'h(x)}\\n', 'hence', 'minimizes\\n\\n', 'Af(n)+Bh_{F}(n)}\\n', 'decrease-priority', 'situations', '(HPA*)\\nBrian', 'uses', 'ending', 'eligible', ',', 'error.\\n\\n', 'explanation,', 'shortest', 'LIFO', 'N\\n', '\"perfect', 'example', 'heuristic.\\nThe', 'optimal', 'nodes,', 'Memory', 'position', 'outperformed', 'only', 'path', 'shortest-path', 'implemented', ')\\n', 'Special', 'concepts', 'Institute', 'Traverser', 'A', 'then', 'quite—see', 'D\\n', 'true', 'robot', 'conditions', 'Saving', 'known', 'of', 'goal)', 'designed', 'Principles', 'w_{\\\\alpha', 'JavaScript', 'distance', 'A*,', 'grow', 'algorithm.\\n\\nDescription\\nA*', 'consistency\\nAlgorithm', 'inconsistent', 'problems.\\nOptimal', 'good', 'pre-process', 'state', '(SMA*)\\nTheta*A*', 'another', 'mobile', 'approaches;', 'including', 'selection', 'simple', 'ignores', 'main', 'If', 'General', 'entire', 'details', 'graphs', 'expense', 'worse', 'approach', 'implementation.', 'function,', 'promote', 'turns', 'searches,', 'implementations', 'factor', 'g', 'g({\\\\tilde', 'condition:\\n\\n', 'necessary', 'their', 'ha', 'π(n)', 'x\\n', 'f(n)=g(n)+(1+\\\\varepsilon', '}\\n', 'revised', 'Grinstead.', 'considered', 'compute', 'given', '=\\n', 'used', '(thus', 'node.\\n\\nComplexity\\nThe', '\\\\leq', 'angle\\n\\nNotes\\nReferences\\nFurther', 'constants', 'behaves', 'weights', 'additional', 'termination', 'bd', 'parent', 'depending', 'Algorithm', 'Stanford', 'Hart', 'mean', 'This', '+(b^{*})^{d}.}\\n', '\\n', 'special', 'start;', 'tree,', 'exploitation', 'stopping', 'terminate', 'Roughly', 'time,', 'expanded).', 'having', 'h(y)', 'node,', 'whose', 'Research', 'itself', 'd(x,', 'described', 'orange:', 'y\\n', 'efficiently', 'efficiency', 'us', '}(n))f(n)}\\n', 'allows', 'constant', 'average', 'handles', 'reference', 'ha(n),', 'ε\\n', 'N', 'chosen.', 'priority', 'f_{\\\\alpha', 'consistent', 'queue', 'added', 'best-first', 'global', 'F\\n', '(but', 'problems.', 'contained', 'estimates', 'select', 'to', 'Alts,', '\\u2061\\n', 'relaxation,', 'Palo', 'Hierarchical', 'f}\\n', 'C\\n', 'than', 'N\\\\\\\\0&{\\\\text{otherwise}}\\\\end{cases}}}\\n', 'non-negative', 'queue,', 'time.', 'P.', 'w(n)={\\\\begin{cases}1-{\\\\frac', 'thoughts', 'tie-breaking', 'times', 'processing', 'starting', 'target', 'action', 'logarithmic', 'Archived', 'd\\n', 'g(n)', 'tree', 'returned', 'way', 'n', 'available', 'i.e.', '\"A*', 'never', 'consistent.', 'accordingly,', '(\\n', 'nodes', 'hw(n)', 'elements', 'Hart,', 'broken', 'tie-breaking″.', 'pathfinding', 'Every', 'Search', '≤\\n', 'graph,', 'The', 'perform', '8-way).\\nIf', '1', 'stochastic', '|\\n', 'Raphael', 'project,', 'node:', 'note', 'equal', 'care', 'take', '2020.', 'gave', '∗\\n', 'fewer', 'state;', 'start', 'sum', 'admissible)', '–,', 'path.\\nSampled', 'are', 'A*\\nBlock', 'examine', 'single', 'attain', '978-0-935382-01-3.\\n\\nExternal', 'It', 'new', '(1980).', 'specific', 'path,', 'possibility', '″proof″', 'represent', 'proof', 'set', 'expand', 'admissible,', 'algorithm,', 'points.', 'fields', 'neighbors.', 'd(n)}\\n', 'predecessor,', 'pathological', 'contrived', 'Dynamic', 'at', 'efficiency),', '−', 'value).', 'applications.', 'not,', 'some', 'since', '(least', 'nodes)', 'manner,', 'goal.', 'ñ', '0\\n', 'said', 'maps', '.\\n', 'function', 'Pearl', '(the', 'pointers', 'heuristic,', 'costs,', 'two', '(each', 'might', 'meaning', 'cost'}): 1, frozenset({'', 'path', ')\\n', 'filled', 'then', 'farthest', 'subtrees,', 'structures', 'trees', 'searching', 'generalizations', 'key.', 'child,', 'greater', 'of', 'return', 'other', 'Binary', 'children,', 'where', '<', 'an', 'potentially', 'O(log', 'maintain', 'node.', 'else', 'ternary', 'pair', 'depth.', 'Each', 'max.right', 'which', 'B-trees', 'right.', 'self-balancing', '2\\n', 'balance.\\nSearch', 'we', 'particular', 'search-tree', '(a,b)-tree', '2\\\\leq', 'data', 'several', 'entire', 'n).\\n\\nTernary', '1\\n', 'key,', 'set.', 'high', 'ordered', 'if', 'minimum', 'References', 'range,', 'n)', 'tree\\nA', 'they', 'have', 'type', 'child-nodes', 'children', 'their', 'For', 'optimized', 'balanced', 'node.key\\n', 'stores', 'same', 'key\\n', 'sorted', 'right.\\n\\nMinimum\\nfindMinimum(node)\\n', 'max.key\\n\\nSee', '3', 'max.right\\n', 'necessarily', 'height', 'given', 'variable', 'used', 'following', '2', 'currentNode', 'search-recursive(key,', 'node.right)\\n', 'While', 'that', 'databases.\\nThe', 'reasonably', 'pre-defined', 'involves', 'commonly', 'and', 'order', 'located', 'time', 'structure', 'number', '\\n', 'application', 'right', 'tree,', 'trees,', 'search', 'say', 'can', 'implement', \"node's\", 'worst-case', 'B-tree', 'balanced,', 'for', 'b\\n', 'also', 'max', 'node\\n\\nIterative\\nsearchIterative(key,', 'itself', 'node-based', 'Trees\\nBinary', \"subtree's\", 'child.', 'less', 'contains', ':=', 'attempt', '=', 'currentNode.left\\n', 'depths.', 'tree\\nDepth-first', 'decided', 'science,', 'systems', 'is', 'left', 'its', 'it.\\nThe', 'will', 'low', 'max\\nIn', 'maximum', 'from', 'elements,', 'operations', 'to', 'key\\nAssuming', 'root', 'character', 'leaves', 'ordered,', 'test', '\\nThe', 'blocks', 'than', 'third', 'b', 'has', 'passing', 'space.', 'formats.\\n\\nRecursive\\nsearch-recursive(key,', 'the', '{\\\\frac', 'locate', 'min', 'subtrees', 'read', 'min.left\\n', 'tree', 'in', 'small', 'way', 'node.left)\\n', 'Tree', 'find', 'right.The', 'n', 'while', 'n).\\n\\nSearching', '>', '(\\n', 'NULL\\n', 'key', 'large', 'it', 'within', 'elements.\\n\\nB-tree\\nB-trees', 'generalized', 're-balanced', 'often', 'locating', 'algorithm', 'Search', 'nodes:', 'be', 'a\\\\leq', 'node)\\n', '≤\\n', 'allow', 'The', 'data,', 'with', 'string', 'advantage', 'insertion', 'efficient', 'equal', 'take', 'min.key\\n\\nMaximum\\nfindMaximum(node)\\n', 'deletion', 'length,', 'node.\\nSearching', 'applied', 'formula:\\n', 'least', 'all', 'trees.\\nThe', 'algorithms', 'EMPTY_TREE\\n', 'exception', 'array.', 'currentNode.key', 'node', 'are', 'end', 'Various', 'binary', 'algorithms\\nSearching', 'node\\n', 'single', 'tree.', '==', 'must', 'left,', 'whether', 'but', 'specific', 'as', 'These', 'comparable', 'most', 'n).\\n\\n(a,b)-tree\\nAn', 'also\\nTrie\\nBinary', 'currentNode.right\\n\\nSearching', 'min.left', 'need', 'trees.\\nDue', 'currentNode\\n', '{\\\\displaystyle', 'on', 'children.\\na', 'at', 'not', 'frequently', 'either', 'is,', 'each', 'complexity', 'In', 'some', 'search\\n\\n\\n==', 'a', 'associative', 'location.\\n\\nTypes', 'exist,', 'qualify', '{(b+1)}{2}}}\\n', 'keys', 'uses', 'waste', 'function', 'idea', 'else\\n', 'range', 'do', 'any', 'two', 'location,', 'computer', 'key–value', 'meaning', '+\\n', 'a\\n', 'possible', 'nodes,'}): 1, frozenset({'', '(and', 'f.', 'More', '\"terminating', 'does', 'filesystem.\\n\\nThis', 'a\\\\cdot', 'between', 'SQL\\nKleene–Rosser', 'streams', 'code.', 'intended', 'Below', 'many', 'legibility', 'beginning', '(as', 'performance', 'Programs)', 'associated', 'operation', 'Language', 'recursion', 'evaluation', 'type.\\n\\nBecause', '(How', 'actual', 'below', 'content', '\\\\varepsilon', 'recursion.', 'efficient,', 'achievable.\\nCompare', 'size', 'itself,', 'common', 'time', '\"generative\".', 'traversal\\nSince', 'say', 'Note', 'alternative:\\n\\nMany', 'Other', 'one', 'develop', 'fatal', 'recursive', 'used).', '&&', 'heap,', 'bottom)\\nHybrid', '(n-1)&{\\\\mbox{if', 'combine', 'T\\n', 'essentially', 'zero,', 'languages,', 'allocation', 'define', 'generatively', 'such', 'recursing', 'complete;', 'value', 'grammars', 'finite', 'position,', 'based', '(immediately', 'implementation,', 'view', 'stack;', 'input(s)', 'specify', 'you', '(i.e.,', 'table', 'depth-first', 'sort.\\n\\nRecursion', 'absence', 'under', 'runtime', 'filesystem', 'Structural', '(without', 'guaranteed', 'calculate', '}}y=0\\\\\\\\\\\\gcd(y,\\\\operatorname', 'referred', 'structure.', 'size.\\nA', 'requires', 'own', 'checked', 'functions\\nPrimitive', 'i.e.,', 'initial', 'occur', 'similar', '(that', 'Examples', 'f(n)=O(n^{\\\\log', 'any', '{\\n', 'computer', 'stack', 'ideas', 'construction', 'values', 'sums;', '(e.g.', 'complex', 'f(n)', 'mutually', 'procedure', 'reversed,', 'node.', '_{b}a+\\\\varepsilon', 'here', 'template', 'which', 'hybrid', 'With', 'input,', 'also\\nFunctional', 'bottom)', 'Big-O', 'compile', 'constructs;', 'using', 'sorted', '(n,t)&={\\\\begin{cases}t&{\\\\mbox{if', 'peg,', '}}n>1\\\\\\\\\\\\end{cases}}}\\n', 'remainder\\n', 'queries', '(structural', 'directly', 'one.', 'c\\n', 'cause', 'solution,', 'number', 'center', 'right', 'disks', 'next', 'search', 'empty,', 'pieces', 'wildmat', 'f', 'produces', 'tree_contains', 'instructions', '2h', 'happens', 'guaranteed.\\nIn', 'its', 'f(n,', 'growth', 'into', 'because', 'allowing', 'relative', 'more', 'natural', 'corecursion:', 'testing', 'suffers', 'up', 'science', 'recursion\\nSome', 'coinductive', 'choosing', 'avoiding', '>', 'possible;', 'decrease', 'algorithms\\nA', 'be', 'sort', '(AND)', '91', 'insertion', 'counterparts.', 'tactic', '\\nIf', 'rely', '\\\\gcd(x,y)={\\\\begin{cases}x&{\\\\mbox{if', 'relation', 'alone,', '≠\\n', 'expressions.', 'time.\\n\\n\"Recursive', 'languages.', 'most', 'depends', 'immediately', 'stream', 'operators,', 'Ackermann', 'condition,', 'separation', 'demonstrates', 'switch', 'infinite', '(single', 'sub-problems,', 'reached.\\nGeneratively', 'example,', 'do', 'dynamically', 'purposes', '+\\n', 'Boolean', 'pick', 'miss', 'themselves', 'require', 'strings,', 'What', 'greater', 'simulate', 'array', 'above.\\n\\nThe', \"criterion'\", 'b_{0}=1}\\n', 'regarded', '\"factorial\"', 'namely', 'builds', '(i.e.', 'f(n)=\\\\Omega', 'top)\\nShort-circuiting', 'search.', 'regarding', 'again.\\nIndirect', '(or', 'When', '6)', 'contrast,', 'values,', 'equation', 'difficult', 'reduced', 'precision', 'saved', 'application', 'multiple', 'number,', 'heap', 'elimination', 'short-circuiting,', 'once', 'recursion\\nRecursion\\nSierpiński', 'permits', 'head(s)', 'therefore', 'maximum', 'even', 'before', 'rule', 'per', 'parameters', 'deferred', 'xn', 'XML', 'pointer', 'formula.\\n\\nBinary', 'Notice', '(master', 'takes', 'syntax', 'always', 'style,', 'large', 'itself).', 'previous', 'considering', 'recursively.\\nFunction', 'allow', 'working', 'typically,', 'algorithms;', 'tree.', 'divisor', 'advantages', 'definition', 'form;', 'stack?\\nFunction', 'establishes', 'recursion.\\n\\nIndirect', 'contents.', 'Traversing', 'check', 'overall', 'search\\nA', 'variable,', 'managed', 'and,', 'evaluated', 'example', 'symmetric', 'functions;', 'variables),', 'tail-recursive.', 'call)', 'cases,', 'concepts', 'case\\nShort-circuiting', 'Short-circuiting', 'memoization.\\n\\nBase', 'grow', 'quantity', 'c', 'recurse', 'stack.\\n\\nRecursive', 'including', 'simple', 'References', 'implementations', 'factor', 'improved', 'calls', 'kind', 'f,', 'work', 'necessarily', 'used', 'programming,', 'stacked', 'transformed', 'separately,', 'notable', '(x,y))&{\\\\mbox{if', 'provides', 'made,', 'itself', 'efficiency', 'able', 'slowness', 'clarity', '2h+1−1', 'self-reference', 'Like', '((3', 'help', 'procedures.', 'than', '(here,', 'preferable', 'itself.', 'nested', 'way', 'desired', 'n', 'available', 'C,', 'immediate', 'greatest', 'classify', '≤\\n', 'program.Conversely,', 'overflows;', '8)),', 'function.\\n\\nAll', 'note', 'order.\\n\\nFilesystem', 'recursion\\nRecursive', 'generative', ':\\n\\n', 'These', 'step.', 'preferred,', '(for', 'entails', 'anonymous', '−', 'some', 'manner,', 'functional', 'especially', 'drawbacks', '0,', '}}n>0\\\\\\\\\\\\end{cases}}}\\n', 'translates', 'equations', 'a\\n', 'repetitions.\\nMost', '_{b}a})}\\n', 'involved', 'AND', 'search;', 'method.', 'other', 'exhibits', 'entirely', 'body', 'leading', 'f(n)=\\\\Theta', 'an', '\"compute', 'there', '(5', 'generates', 'routinely', 'variants,', 'cuts', 'structurally', 'benefit', 'difference', 'useful', 'programmer', 'solving', 'shows', 'numbers', 'performed', 'Implementing', 'enoughOn', 'inspection,', 'current', 'specifies', 'three', 'order', 'structure', 'running', 'programming\\nComputational', 'direct', '1)!.', 'environment', 'b\\n', 'procedures\\nFactorial\\nA', 'encountered,', 'design', 'diameters.', 'significant', 'use', 'magnitude', 'approximation', '(often', 'resulting', 'sub-problems', 'maintaining', 'sufficiently', 'log\\n', 'recursion\\nSingle', 'methods,', 'starts', 'lines', 'C:\\n\\nRecursive', \"array's\", '>0}\\n', 'indirectly', 'it', '(n)={\\\\begin{cases}1&{\\\\mbox{if', 'terminated.\\n\\nMultiply', 'favor', 'today', 'puzzle', 'or', 'child', 'leaf', 'string', 'arguably', 'shown', 'basis', 'iterative', 'express', 'steps.\\n\\nTowers', 'exact', 'computation', 'statement,', 'solutions', 'pegs', 'infinitely', 'function.\\nThe', 'case\".\\nThe', 'factorial', 'successive', 'overhead.', 'as', 'computes', 'fixed', 'intuitively,', 'avoid', 'children)', 'context,', 'functions:\\n\\nFunction', 'traversing', 'recognize', 'definition;', '}}y>0\\\\\\\\\\\\end{cases}}}\\n', 'effort', 'print', 'curve\\nMcCarthy', 'though', 'consideration', 'program', 'treated', 'where', '(see', 'referring', 'recursively.\\n\\nGreatest', 'object', 'recurrence', 'called,', \"caller's\", '+', 'rewritten', '2h+1', 'Fibonacci', 'O(n)', 'operate', 'Java)', 'self-references', 'iteration).', 'trick', 'self-referential', 'recursion\\nRecursion', 'unknown', 'derives', \"'stopping\", 'frowned', 'cases', '(either', 'analysis.\\n\\nImplementation', 'shared', 'constructs', 'shortcut', 'branch', 'auxiliary', 'f\\n', 'paradox\\nOpen', 'rather', 'purpose,', 'this', 'h\\n', 'found', 'so', 'can', 'inductively', 'computed', '}}n=0\\\\\\\\n\\\\cdot', 'sort,', 'basic', 'making', 'sort.', 'arbitrarily', 'result,', '\"structural\"', 'objects.', 'false\\nrecursive', 'is', 'filesystem.', 'sub-tree).\\n\\nOperations', 'flow', 'objects', '{fact_{acc}}', '(function)\\n\\nNotes\\n\\n\\n==', 'simply', 'implementation', 'code', 'switching', 'space\\nIn', 'support', 'Thus', 'b', 'in', '}}n=1\\\\\\\\2\\\\cdot', 'requiring', 'initialize', 'HtDP', 'modifications', 'evaluates', '1\\nFunction', 'right),', 'procedures', 'Therefore,', 'Typically', 'unchanged', 'primarily', 'recurring),', '}}n>0\\\\\\\\\\\\end{cases}}\\\\end{aligned}}}\\n', '\"error', 'unbounded', 'n\\n', 'practical', 'as:\\n\\nThe', 'dynamic', 'recursing,', 'Clojure)', 'construct', 'Chains', 'results', 'building', '\"check', 'manipulating', 'for.\\nRepeatedly', 'turn', '(to', 'flow,', 'result.', 'Null).\\nIn', ',\\n', 'eventually', 'term.\\n\\nShortcut', 'from.\\nCorecursion', '(shown', 'mainstream', 'case.', 'written', 'via', 'solve', 'preorder', 'strings.\\n\\nThis', 'different', 'if', 'when', 'recursion.\\nGenerative', 'they', 'type', 'children', 'scenario', 'generally', 'savings', 'larger', 'positive', 'further', 'time-complexity', 'FUNCTIONS.\\nThus,', 'prevent', 'already', 'Neglecting', 'that,', 'indirect', 'illustrated', 'used,', 'Consequently,', 'below)', 'recursion)\\nAn', 'recursion:\\n\\nExpressive', 'less', 'functions.\\n\\nAnonymous', 'taking', 'y', 'class', 'Similarly', '=', 'theory', 'original', 'divisor\\nThe', 'examples.', 'no', 'illustrates', 'pass.', 'reason,', 'fact\\n', 'proving', 'specification,', 'recursively.', 'opened', 'adaptive', 'coinduction,', 'simplified', 'thus', 'lies', 'x\\\\%y}\\n', '–', 'elimination,', 'match,\\notherwise,', 'whereas', 'specification', 'returns.', 'characteristic', 'memory.', 'computation,', 'result', 'model', 'like', 'node', 'do)', 'discussion.\\nThe', 'complexity,', 'addition:\\n\\nThis', 'step.\\nBy', 'short', 'terminate,', 'central', 'successor', 'track.', 'Turing', 'Krauss', 'works', 'recombining)', 'not', 'desired,', 'technique,', 'hence', 'complexity', 'a', 'and/or', 'iterated,', 'iteration.\\n\\nStack', 'integers,', 'tail', '*', 'position', 'only', '⋅\\n', 'and\\n', 'known', 'designed', 'Binary', 'initialization', 'expressions', 'context', 'piece', 'DFS', 'computations', 'If', 'entire', 'function,', 'overflows,', 'instances', 'approach', '(n-1,nt)&{\\\\mbox{if', 'gets', 'base', '\\nAlso', 'calls,', 'valid', 'method,', '(they', 'challenging.', '_{b}a-\\\\varepsilon', 'whilst', 'given', '=\\n', 'placed', 'hanoi\\n', 'match,', 'Rich', 'this.\\n\\nWrapper', 'these),', '\\n', 'avoids', 'tend', 'terminate', 'employ', '0!', 'contains', 'ε\\n', 'input.', 'algorithms.', 'terms.\"\\n\\nThe', 'They', 'to', 'eliminates', 'functions\\nTak', 'various', 'passing', 'performance.\\n\\nTail-recursive', 'time.', 'Quicksort,', 'top', 'tree', 'negligible;', 'gcd,', 'care.', 'profiling', 'Example', 'nodes', 'pointers:', 'receives', 'authors', 'programmer:', 'The', 'sum', 'xn-1)', 'assigning', 'elegance,', 'capabilities.\\n\\nPerformance', 'exception', 'nearly', 'Starting', 'are', 'specifically', 'powerful', 'single', 'prime', 'belongs', 'small.', 'gcd', 'expressions,', 'create', 'set', 'strings', 'half.', 'childrenIn', 'corecursion', 'solves', 'Which', 'pathological', 'feed', 'at', 'trivially', 'appropriate', 'example)', 'procedure.\\n\\nBinary', 'versus', '(so', 'leaves),', 'loop', 'pointers', 'operator,', 'arguments', 'cost', 'Indirect', 'RECURSIVE', 'zero', '−\\n', 'languages', 'latter', 'calls:\\n\\nAt', 'inside', 'divide', '(particularly', 'Hybrid', 'concrete', 'memoization,', '(nth', 'outweigh', 'recursively', 'terms', 'chain', 'practice', 'n)}\\n', 'have', 'matching', 'expressive:', 'stores', 'presented', '(inductively', 'height', 'programming', 'languages:\\n\\nThe', 'All', 'defining', 'aka', 'step),', 'components', 'manage', 'our', '(finite)', 'responding', 'definition:\\n\\n', 'executed', 'were', 'By', '-', 'those', 'otherwise,', 'problems', 'boolean.', 'vulnerable', 'files', 'variables', 'types', 'third', 'element', 'designers', 'Hanoi\\nThe', 'independently', 'empty', 'representing', 'depth', '2,', 'often', 'prints', 'box', 'contents', 'problems,', 'include', 'malicious', 'operations.', 'recursion,', 'version', 'be,', 'must', 'data]', 'server', 'provide', 'either', 'inductive', 'by', 'etc.', 'extra', 'other.', 'upon,', 'moves', '(non-Null).', 'simulating', 'what', 'algorithm', 'call),', 'algorithms', 'simple,', 'into),', 'trees', 'searching', 'emphasis,', 'return', 'overflow', 'precise)', 'call.', '<', '2\\nFunction', 'divisor,', 'programs,', 'requirements;', 'data', 'several', 'Multiple', '1\\n', 'Such', 'due', 'above', 'accumulator', 'adjusted', 'effectively', 'string,', 'errors.', 'problem\\nHierarchical', 'stored', 'loops.\\n\\nThe', 'respectively.', 'particularly', 'tail(s)', 'usually', 'reached.', 'that', '1/1!', '0;', 'involves', 'program,', 'off', 'method', 'prior', 'O', 'how', 'validate', 'recursive.', '\"while\"', 'sometimes', 'fact,', 'scope.', 'array,', 'little', 'list,', 'tail-recursive', 'will', 'case\\nA', 'O(1)', 'thence', 'memory', 'understand', 'concern', 'problems\\nMultiply', 'without', 'Hanoi', 'results.', 'limit', 'x/y}\\n', '1/3!', 'search\\nThe', 'creation', 'for.\\nRecursion', 'However,', 'fractals,', 'clear', '(DFS)', 'relation:\\n\\n', 'again', 'inherently', 'Euclidean', '\"structural', 'form', 'data,', 'caveat', 'recursive-only', '\\\\gcd(x,0)=x}\\n', 'C', 'all', '(such', 'method;', 'build', 'easily', 'here).\\n\\nTypes', 'directly),', 'but', 'call', 'Neither', 'repeated', 'searched', 'instead', 'circuit,', 'malware', 'near', 's', '{remainder}', '(n-1)+1&{\\\\mbox{if', 'level', 'highly', 'informally,', 'portion', 'short-circuited', 'templates', 'it.', 'data.', 'techniques', 'complicated', '1.\\nShort-circuiting', 'structures', 'non-recursive', 'nature.', 'wildcards', 'recursion\\nMost', 'tiled', 'short-circuit', 'linked', 'straightforwardly', 'quicksort,', 'returning', 'x', 'jumps', 'particular', 'b_{n}=nb_{n-1}}\\n', 'step,', 'Java,', '(left', 'problem', '(2', 'inefficient', \"language's\", 'after', 'recurse.In', 'expresses', 'academia.\\n\\nDepth-first', 'seen', '0}\\n', '2', 'gcd\\n', 'otherwise', 'decreases', 'mitigated', 'idiom', 'exceptions', 'corresponding', 'computability', 'theoretically', 'half', 'logic', 'illustrate', 'process', 'methods', 'parameter', 'these', 'x.\\nFor', 'used.', 'recurse\",', 'again,', 'memory,', 'list_print', 'equivalent', 'long', 'recursively.\\n\\nAs', '{\\\\begin{aligned}\\\\operatorname', 'pass', 'data:\\n\\n[Functions', 'Even', 'self-referencing', 'from', 'f(n/b)\\\\leq', 'growing', 'solved', 'solution.\\n\\nRefactoring', 'directories', 'term', 'occurs', 'system', 'small', 'differ', 'stacks', 'Design', 'developed', 'index.', '\"traverse\"', 'see', 'structured', 'equally', \"stack's\", 'traversals,', 'typically', 'defined', 'iteration', 'peg', 'proved', 'form\\n\\nThen', 'case', 'point', '(usually)', 'product', 'each', 'index', 'In', 'computational', ',', 'multiplication', 'recursion.\\nWrapper', 'hanoi:\\n\\n', 'walks', 'then', 'h_{1}=1}\\n', 'integer).', 'of', 'includes', 'caused', 'recursion\".', 'refer', 'recursion.\\n\\nStructural', 'steps', 'inputs', 'merge', 'variant,', 'Null', 'divides', 'NULL).', 'n(n', 'once,', 'applicable', 'their', 'disk', 'x\\n', 'data;', 'considered', 'typical.', '})}\\n', 'compute', '\\n\\n', 'expression.\\n\\nCoinductively', 'power\\nMost', 'structural', 'termination', 'feature', '(Functions', 'special', 'may', 'integration.\\nThis', 'Null,', 'calling', 'node,', 'sizes', 'e', 'whose', 'related', 'linear', 'constant', 'done', 'recurs', 'grammar', 'strings.\\nAnother', 'original,', 'eliminate', 'framed', 'left', 'evidently', 'looping', 'wildcards,', 'language.', 'savings.\\nConceptually,', 'technique', 'stack,', 'execute', 'logarithmic', 'checking', 'definition.', 'demonstrate', 'statements', 'recursive,', 'this.)', '\"for\"', 'overhead', '(\\n', 'returns,', 'malware,', 'step:', 'treats', 'Every', '{hanoi}', '1', 'perform', 'trees\\nBelow', 'threaded', 'equal', 'applied', 'stack.\\nMultiple', 'approximation\"', 'recur', 'unknown.', 'acting', 'saves', 'managing', '==', 'structure—namely,', '0', 'possibility', 'Some', '\\\\operatorname', 'functions', 'addition', 'since', 'remains', '(non-empty', '(f(n))}\\n', '3,', 'remainder', 'creating', \"Salz'\", 'function', 'swapped.\\nIn', 'accessor', 'look', 'two', 'might', 'meaning', 'constructs,', 'replacing', 'n!', 'been', 'derived', 'problem.', 'generate', 'nth', 'refined,', 'perfect', 'mutual', 'completeness)', 'recursions', 'this:\\n\\nA', 'traverse', 'them', 'fundamentally', 'subject', 'interpreter', 'Backus–Naur', 'calls.', 'terminating', 'we', '2\\n', 'Timsort,', 'Θ\\n', 'calls;', 'lists', 'consume', 'separate', '(n^{\\\\log', 'algebraic', 'trees.', 'covered', 'case\"', 'very', 'handling', 'standard', 'function\\nA', 'stack.\\n\\nThe', '(n,1)\\\\\\\\\\\\operatorname', 'recursively.\\nThe', 'simpler', 'step', 'input', 'information', 'space,', 'refers', 'n,', 'lazy', 'for', 'include:', 'also', 'traversal,', 'rewriting', 'short-circuiting', 'imperative', 'notation.', 'mathematical', 'sort/insertion', 'partitioning,', 'definition,', 'means', 'both', '(at', 'case.\\nIn', 'T(n)=\\\\Theta', 'corecursion,', 'incurring', 'first', 'until', 'parameters.', 'place', 'evaluating', 'Because', 'while', 'behind', 'fact', \"function's\", 'optimization', 'small,', 'Tower', 'statement.', 'recursion.\\n\\nVulnerability\\nBecause', 'sum)\".\\n\\nRecursive', 'smaller)', 'argument', 'search,', 'move', 'grammar,', 'academia.', 'filesystem.\\n\\nTime-efficiency', 'breaking', 'important', 'required', '1/0!', 'One', 'definitions:', '(and,', 'need', 'tree;', 'case,', '>\\n', 'Towers', 'specifically,', 'corresponds', 'targets', 'satisfy', 'normal', 'explicitly', 'data\\nAn', 'private', 'tail—and', 'possible', '\"base', 'arithmetic', 'on,', 'pseudocode', 'section', 'output', \"program's\", 'complete', 'would', 'Haskell', 'smaller', 'functions\\nTail-recursive', 'components.', '/\\n', 'exponential', 'expressed', 'An', 'c\\\\cdot', 'made', 'xbase:\\n\\nFor', 'well-known', 'O\\n', 'implied', 'decompose', 'second', 'examples', 'f(n)}\\n', 'compound', 'same', 'wrapper', 'construct,', 'hold', 'converted', 'algorithms\\nThe', 'processing,', '(one', 'That', 'incorrectly,', 'fails.', 'defined)', 'actually', 'field', 'factorial,', 'case)', 'number.\\nSimilarly', 'include:\\n\\nWrapper', 'theorem)\\nIf', 'in-order', 'Recurrence', 'replaced', 'replacement', 'operations', 'value.\\n\\nLinked', 'says', 'although', 'obvious', 'has', 'partial', 'space.', 'pass.\\nExample', 'distinction', 'created', 'the', 'conditions:', 'removed', 'singly', 'implicitly', 'Alternatively,', '(pointing', 'head', 'advantage', 'above:\\n\\nThis', '}}n=0\\\\\\\\\\\\operatorname', 'definitions.\\n\\nInductively', '(an', 'number),', 'becomes', 'sophisticated', 'alternative', 'recursion.\\n\\nSee', 'consists', 'iteratively', 'Ω\\n', 'time),', 'job', 'gradually', 'tests', 'sub-tree)', 'problems)', 'space', '%\\n', 'faster', 'divide-and-conquer', 'compare', 'knowledge', 'add', 'steps,', 'breaks', \"Newton's\", 'significance', '(STRUCTURALLY)', 'recursively,', 'solely', '(allocate', 'is:\\n\\nbase', 'Python', 'strings.', 'classic', 'property', 'efficiency.\\n\\nHybrid', 'final', 'enumerate', 'sequence', 'children,', 'name.', 'static', 'smallest', 'reasons,', 'underlying', 'suitable', 'processes—are', '1!', 'poor', 'issues\\nIn', 'much', 'cutting', 'For', '\"level', 'execution\\nConsider', 't:\\n\\n', '3', 'response', 'handle', 'traversal', 'write', 'and', 'list', '(which', 'for,', 'implementations:\\n\\nAlthough', 'series', 'operation,', 'language', 'As', '\"next\"', 'ones.', 'definitions', 'science,', 'control', 'induction:', 'solution', 'number:\\n\\n', 'pure', 'completes.', 'management,', '\"rtraverse\"', 'programs', 'here,', 'noticeable.\\nAs', 'tracking', 'y\\\\neq', 'call,', 'efficiency.', 'properly', 'track', 'being', 'position.', 'algorithm\\nRecursive', 't\\n', 'case:', 'compiler', 'search.\\nSingle', 'instance,', 'with', 'efficient', 'old', 'called', 'Non-recursive', 'domain', 'loops', 'boolean,', 'indirectly).', 'worst', 'binary', 'mechanism', 'types\\nMany', 'iterative,', 'corecursive', '(possibly)', 'collecting', 'function\\nμ-recursive', 'There', '{\\\\displaystyle', 'on', 'is,', '\\\\gcd(x,y)=\\\\gcd(y,x\\\\%y)}\\n', 'keeps', 'orders', 'midpoint,', 'strings;', 'repeatedly', 'ending', 'follows', 'fundamental', 'reason', 'fast', '||', 'implemented', ')\\n', 'A', 'true', 'naively', 'midpoint', 'Big', 'state', 'another', 'lookup', 'indexing', '(calls', '{fact}', 'instead:\\n\\ncheck', 'lists,', 'g', 'reduce', 'represents', 'iteration,', 'power', 'lines,', '...)', 'processes', 'term,', 'functions,', 'variable', 'mergesort,', 'Recursive', 'previously', 'down', 'explicit', 'recursion\"', 'overwhelm', '(root', 'naturally', 'tail-recursive;', 'h,', 'that:\\n', 'This', 'tree,', 'as:\\n\\nNote', 'added,', 'Standard', 'both,', 'skip', 'expression', '(OR)', 'described', 'y\\n', 'circumstances—for', 'loop.\\nFor', 'function.', 'allows', 'directory', '(n)&=\\\\operatorname', '\"Arm\\'s-length', 'constitutes', '\\u2061\\n', 'syntax):\\n\\nThe', 'iteration\\nRecursion', 'computing', 'Scheme;', 'moved', 'access', 'notion.', 'h_{n}=2h_{n-1}+1}\\n', 'corecursion\\nA', 'vary,', 'never', '_{b}a}\\\\log', 'within', 'elements', 'pass-by-reference.\\n\\nShort-circuiting', 'time.\\n\\nOrder', 'interpreted', 'smaller.', 'approved,', 'efficiency,', \"arm's-length\", 'start', 'temporary', 'Recursion', 'array.', 'typical', 'n+1,', 'short-circuiting.', 'It', 'new', '1,', 'science.\\nThe', 'proof', 'combined', 'lists\\nBelow', 'algorithm,', 'optimization.\\n\\nRecursive', '1/2!', 'struct', 'thus:\\n\\nIf', '(also', '0\\n', 'compared', 'contrast', 'multiplying', 'integers):\\n\\nA'}): 1, frozenset({'sentinel\\nThe', '', '−\\n', 'been', '4.\\nIncrease', '≤', 'method.', 'other', 'unsuccessfully.\\n\\nAnalysis\\nFor', 'an', 'them', 'search),', 'un-ordered', 'pays', 'Vol.', 'construct).\\nEither', '2\\n', 'many', 'beginning', 'performance', 'searches.\\n\\nSee', 'practice', 'have', 'unsuccessfully.\\n\\nWith', 'value.', 'search\\nHash', 'very', 'establish', 'content', 'step', 'target.\\nSet', 'needed.\\nIf', 'order', 'time', 'structure', 'also\\nTernary', 'others,', 'n,', 'way,', 'By', 'one', 'for', '-', 'exceeds', 'needed,', 'frequently,', 'On', 'subroutine', 'both', 'use', 'reach', 'sequentially', 'element', 'record', 'arrays,', 'probabilities\\nThe', '}}k=0\\\\\\\\[5pt]\\\\displaystyle', 'until', 'such', 'first', 'Should', '{n+1}{2}}}\\n', 'place', 'value', 'find', 'tables,', '(a', 'ed.).', 'it', 'L1', 'often', 'or', '2.\\nIf', 'ISBN', 'is\\n\\n', 're-organization', 'search,', 'absence', 'table\\nIf', 'reaches', 'as', 'Sorting', 'orderings', 'requires', 'by', 'extra', 'initial', 'L', '{\\n', 'computer', 'algorithm', '....', 'matches', 'algorithms', 'values', 'though', 'searching', 'return', 'distributed,', '{\\\\begin{cases}n&{\\\\mbox{if', 'where', 'length', '<', 'faster.', 'probability,', 'which', 'i.', 'target,', 'data', 'improves', '1\\n', 'above', 'hash', 'second', 'else.', 'trouble', 'same', 'T', 'concluding', 'usually', 'following', '(sort)', 'k\\n', 'finds', 'that', 'instance', 'this', 'found', 'number', 'best', '100', 'infeasible', 'search', 'can', 'terminates', 'method', 'worst-case', 'equals', 'basic', 'sought', 'making', '2.', 'geometrically', 'result,', 'items,', 'match', 'list),', 'list,', 'is', 'its', 'will', 'because', '(1998).', 'Ln', 'more', 'has', '{n+1}{k+1}}&{\\\\mbox{if', 'the', 'in', 'However,', 'sort', 'be', 'Therefore,', 'Ln−1,', 'all', 'build', 'target.', '\\\\displaystyle', 'finding', 'n\\n', 'practical', 'but', 'most', 'repeated', 'adding', 'searched', '.', 'faster', 'medium-sized', 'near', 'n.\\\\end{cases}}}\\n', '{(n+2)(n-1)}{2n}}}\\n', 'eliminated', 'example,', '+\\n', 'problem\\n\\nReferences\\nCitations\\nWorks\\nKnuth,', 'it.', 'greater', 'unsuccessfully.\\n\\nIn', 'O(n).\\n\\nNon-uniform', 'go', 'rarely', '0-201-89685-0', 'if', 'when', 'records', 'much', 'worth.\\nAs', 'quickly', 'Li', 'For', 'list.\\nWhen', 'larger', '3', 'algorithm\\nGiven', 'Searching.', 'arrays', '(or', 'Programming.', '2', 'end.', 'corresponding', 'and', 'methods', 'list', 'Computer', 'these', 'Reading,', '(around', 'needed.', 'Else,', 'once', '=', 'theory', 'science,', 'even', 'value)', 'from', 'elements,', '(2nd', 'per', 'T,', 'significantly', 'asymptotically', '1.\\nIf', 'k\\\\leq', 'Addison-Wesley', 'occurs', 'table\\nLinear', 'few', 'prepare', 'O(1).\\n\\nApplication\\nLinear', 'being', 'large', 'comparisons,', 'allow', 'with', 'efficient', 'worst', 'end', 'still', 'binary', 'MA:', 'equally', 'short', 'checks', 'comparable', 'case', '{\\\\displaystyle', 'on', 'not', 'each', 'check', 'index', 'list.\\nSet', 'In', 'desirable', 'likely,', 'a', 'iteration:', 'if-then-else', 'uses', 'lists.\\n\\nAlgorithm\\nA', 'arranged', '...', 'implement,', 'Linear', 'only', ')\\n', 'searched,', 'then', 'vary.', 'known', 'of', 'pre-process', '≥', 'Otherwise,', 'simple', 'If', 'ordered', 'performing', 'valid', 'once,', 'makes', 'probabilities', 'n+1/2', '=\\n', '\\n\\n', 'likely', 'comparison', 'runs', 'less)', 'enough,', '0.\\nIf', 'list.\\nIn', 'This', '\\n', 'may', 'other,', 'unsuccessfully.\\n\\nBasic', 'linear', 'average', 'i.\\nIncrease', 'comparisons', 'contained', 'to', 'than', 'variation', 'i', 'times', '{\\\\frac', 'target', 'expected', 'sentinel', 'desired', 'n', 'anything', 'Donald', '(\\n', 'affected', 'within', 'elements', 'schemes,', 'Art', '≤\\n', 'The', '1', 'decreasing', 'equal', 'points', 'are', 'k', 'single', 'items', 'L.\\nSet', 'It', 'searched.A', 'successfully;', '1,', 'L0', '(for', 'change', 'sense', 'at', 'particular,', 'Professional.', '}}1\\\\leq', 'some', '0\\n', '.\\n', 'list.', 'whole', 'two', 'might', 'cost', 'sequential'}): 1}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "FPtree.display() # Depth First Search (DFS)"
      ],
      "metadata": {
        "id": "gLsqQQ-sVoG-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae8d3149-1fc6-4d04-ec0a-8394be388a37"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "item: root, freq: 1,[[item: time, freq: 2,[[item: computer, freq: 2,[[item: which, freq: 2,[[item: number, freq: 2,[[item: search, freq: 2,[[item: its, freq: 2,[[item: be, freq: 2,[[item: most, freq: 2,[[item: large, freq: 2,[[item: than, freq: 2,[[item: some, freq: 2,[[item: other, freq: 2,[[item: an, freq: 2,[[item: it, freq: 2,[[item: as, freq: 2,[[item: where, freq: 2,[[item: can, freq: 2,[[item: is, freq: 2,[[item: in, freq: 2,[[item: if, freq: 2,[[item: not, freq: 2,[[item: a, freq: 2,[[item: to, freq: 2,[[item: The, freq: 2,[[item: are, freq: 2,[[item: single, freq: 2,[[item: at, freq: 2,[[item: have, freq: 2,[[item: often, freq: 2,[[item: algorithm, freq: 2,[[item: algorithms, freq: 2,[[item: that, freq: 2,[[item: will, freq: 2,[[item: all, freq: 2,[[item: but, freq: 2,[[item: from, freq: 2,[[item: each, freq: 2,[[item: In, freq: 2,[[item: then, freq: 2,[[item: of, freq: 2,[[item: equal, freq: 2,[[item: two, freq: 2,[[item: for, freq: 2,[[item: same, freq: 2,[[item: has, freq: 2,[[item: the, freq: 2,[[item: For, freq: 2,[[item: and, freq: 2,[[item: with, freq: 2,[[item: efficient, freq: 2,[[item: binary, freq: 2,[[item: on, freq: 2,[[item: many, freq: 1,[[item: performance, freq: 1,[[item: one, freq: 1,[[item: such, freq: 1,[[item: value, freq: 1,[[item: find, freq: 1,[[item: any, freq: 1,[[item: values, freq: 1,[[item: because, freq: 1,[[item: more, freq: 1,[[item: example,, freq: 1,[[item: greater, freq: 1,[[item: even, freq: 1,[[item: allow, freq: 1,[[item: simple, freq: 1,[[item: used, freq: 1,[[item: way, freq: 1,[[item: order, freq: 1,[[item: structure, freq: 1,[[item: use, freq: 1,[[item: or, freq: 1,[[item: this, freq: 1,[[item: found, freq: 1,[[item: practical, freq: 1,[[item: when, freq: 1,[[item: they, freq: 1,[[item: node, freq: 1,[[item: complexity, freq: 1,[[item: only, freq: 1,[[item: known, freq: 1,[[item: entire, freq: 1,[[item: given, freq: 1,[[item: must, freq: 1,[[item: by, freq: 1,[[item: data, freq: 1,[[item: list,, freq: 1,[[item: However,, freq: 1,[[item: repeated, freq: 1,[[item: these, freq: 1,[[item: uses, freq: 1,[[item: their, freq: 1,[[item: function, freq: 1,[[item: might, freq: 1,[[item: meaning, freq: 1,[[item: been, freq: 1,[[item: we, freq: 1,[[item: very, freq: 1,[[item: step, freq: 1,[[item: also, freq: 1,[[item: both, freq: 1,[[item: until, freq: 1,[[item: first, freq: 1,[[item: search,, freq: 1,[[item: possible, freq: 1,[[item: second, freq: 1,[[item: operations, freq: 1,[[item: faster, freq: 1,[[item: being, freq: 1,[[item: worst, freq: 1,[[item: This, freq: 1,[[item: within, freq: 1,[[item: elements, freq: 1,[[item: It, freq: 1,[[item: does, freq: 1,[[item: between, freq: 1,[[item: minimum, freq: 1,[[item: size, freq: 1,[[item: common, freq: 1,[[item: finite, freq: 1,[[item: based, freq: 1,[[item: requires, freq: 1,[[item: own, freq: 1,[[item: initial, freq: 1,[[item: using, freq: 1,[[item: solution,, freq: 1,[[item: best, freq: 1,[[item: right, freq: 1,[[item: next, freq: 1,[[item: terminates, freq: 1,[[item: into, freq: 1,[[item: allowing, freq: 1,[[item: up, freq: 1,[[item: science, freq: 1,[[item: decrease, freq: 1,[[item: depends, freq: 1,[[item: do, freq: 1,[[item: (or, freq: 1,[[item: reduced, freq: 1,[[item: application, freq: 1,[[item: maximum, freq: 1,[[item: low, freq: 1,[[item: rule, freq: 1,[[item: always, freq: 1,[[item: including, freq: 1,[[item: implementations, freq: 1,[[item: efficiency, freq: 1,[[item: take, freq: 1,[[item: These, freq: 1,[[item: entirely, freq: 1,[[item: there, freq: 1,[[item: solving, freq: 1,[[item: performed, freq: 1,[[item: significant, freq: 1,[[item: shown, freq: 1,[[item: exact, freq: 1,[[item: fixed, freq: 1,[[item: though, freq: 1,[[item: rather, freq: 1,[[item: so, freq: 1,[[item: basic, freq: 1,[[item: making, freq: 1,[[item: result,, freq: 1,[[item: implementation, freq: 1,[[item: support, freq: 1,[[item: dynamic, freq: 1,[[item: building, freq: 1,[[item: different, freq: 1,[[item: generally, freq: 1,[[item: larger, freq: 1,[[item: already, freq: 1,[[item: less, freq: 1,[[item: theory, freq: 1,[[item: no, freq: 1,[[item: –, freq: 1,[[item: result, freq: 1,[[item: like, freq: 1,[[item: still, freq: 1,[[item: position, freq: 1,[[item: designed, freq: 1,[[item: function,, freq: 1,[[item: approach, freq: 1,[[item: valid, freq: 1,[[item: contains, freq: 1,[[item: nodes, freq: 1,[[item: sum, freq: 1,[[item: set, freq: 1,[[item: terms, freq: 1,[[item: By, freq: 1,[[item: -, freq: 1,[[item: those, freq: 1,[[item: problems, freq: 1,[[item: element, freq: 1,[[item: problems,, freq: 1,[[item: include, freq: 1,[[item: either, freq: 1,[[item: trees, freq: 1,[[item: length, freq: 1,[[item: several, freq: 1,[[item: due, freq: 1,[[item: above, freq: 1,[[item: usually, freq: 1,[[item: involves, freq: 1,[[item: method, freq: 1,[[item: without, freq: 1,[[item: easily, freq: 1,[[item: near, freq: 1,[[item: it., freq: 1,[[item: structures, freq: 1,[[item: particular, freq: 1,[[item: problem, freq: 1,[[item: seen, freq: 1,[[item: process, freq: 1,[[item: methods, freq: 1,[[item: equivalent, freq: 1,[[item: small, freq: 1,[[item: iteration, freq: 1,[[item: proved, freq: 1,[[item: point, freq: 1,[[item: considered, freq: 1,[[item: termination, freq: 1,[[item: special, freq: 1,[[item: may, freq: 1,[[item: whose, freq: 1,[[item: linear, freq: 1,[[item: perform, freq: 1,[[item: applied, freq: 1,[[item: specific, freq: 1,[[item: since, freq: 1,[[item: them, freq: 1,[[item: standard, freq: 1,[[item: space,, freq: 1,[[item: means, freq: 1,[[item: place, freq: 1,[[item: while, freq: 1,[[item: move, freq: 1,[[item: important, freq: 1,[[item: case,, freq: 1,[[item: would, freq: 1,[[item: exponential, freq: 1,[[item: An, freq: 1,[[item: instance, freq: 1,[[item: created, freq: 1,[[item: alternative, freq: 1,[[item: finding, freq: 1,[[item: space, freq: 1,[[item: much, freq: 1,[[item: list, freq: 1,[[item: (which, freq: 1,[[item: solution, freq: 1,[[item: efficiency., freq: 1,[[item: few, freq: 1,[[item: called, freq: 1,[[item: is,, freq: 1,[[item: implemented, freq: 1,[[item: A, freq: 1,[[item: state, freq: 1,[[item: another, freq: 1,[[item: variable, freq: 1,[[item: described, freq: 1,[[item: allows, freq: 1,[[item: average, freq: 1,[[item: never, freq: 1,[[item: Search, freq: 1,[[item: new, freq: 1,[[item: algorithm,, freq: 1,[[item: (and, freq: 1,[[item: notion, freq: 1,[[item: general, freq: 1,[[item: intended, freq: 1,[[item: attempts, freq: 1,[[item: (as, freq: 1,[[item: high, freq: 1,[[item: evaluation, freq: 1,[[item: commonly, freq: 1,[[item: published, freq: 1,[[item: Other, freq: 1,[[item: algorithm., freq: 1,[[item: combine, freq: 1,[[item: essentially, freq: 1,[[item: blocks, freq: 1,[[item: limited, freq: 1,[[item: languages,, freq: 1,[[item: needs, freq: 1,[[item: define, freq: 1,[[item: references, freq: 1,[[item: you, freq: 1,[[item: J., freq: 1,[[item: performance,, freq: 1,[[item: candidate, freq: 1,[[item: speed, freq: 1,[[item: structure., freq: 1,[[item: i.e.,, freq: 1,[[item: iterations, freq: 1,[[item: occur, freq: 1,[[item: similar, freq: 1,[[item: subset, freq: 1,[[item: construction, freq: 1,[[item: (e.g., freq: 1,[[item: however,, freq: 1,[[item: complex, freq: 1,[[item: procedure, freq: 1,[[item: pair, freq: 1,[[item: online, freq: 1,[[item: algorithms,, freq: 1,[[item: hybrid, freq: 1,[[item: Its, freq: 1,[[item: higher, freq: 1,[[item: items,, freq: 1,[[item: natural, freq: 1,[[item: describes, freq: 1,[[item: testing, freq: 1,[[item: nodes., freq: 1,[[item: determine, freq: 1,[[item: effective, freq: 1,[[item: adding, freq: 1,[[item: operators,, freq: 1,[[item: combination, freq: 1,[[item: pick, freq: 1,[[item: require, freq: 1,[[item: array, freq: 1,[[item: search., freq: 1,[[item: regarding, freq: 1,[[item: proposed, freq: 1,[[item: difficult, freq: 1,[[item: multiple, freq: 1,[[item: therefore, freq: 1,[[item: permits, freq: 1,[[item: parameters, freq: 1,[[item: length,, freq: 1,[[item: working, freq: 1,[[item: definition, freq: 1,[[item: originally, freq: 1,[[item: overall, freq: 1,[[item: and,, freq: 1,[[item: evaluated, freq: 1,[[item: Linear, freq: 1,[[item: optimal, freq: 1,[[item: cases,, freq: 1,[[item: conditions, freq: 1,[[item: good, freq: 1,[[item: selection, freq: 1,[[item: worse, freq: 1,[[item: necessary, freq: 1,[[item: kind, freq: 1,[[item: makes, freq: 1,[[item: work, freq: 1,[[item: programming,, freq: 1,[[item: likely, freq: 1,[[item: comparison, freq: 1,[[item: Algorithm, freq: 1,[[item: provides, freq: 1,[[item: able, freq: 1,[[item: Like, freq: 1,[[item: problems., freq: 1,[[item: help, freq: 1,[[item: processing, freq: 1,[[item: items, freq: 1,[[item: especially, freq: 1,[[item: waste, freq: 1,[[item: cannot, freq: 1,[[item: maintain, freq: 1,[[item: generates, freq: 1,[[item: variants,, freq: 1,[[item: useful, freq: 1,[[item: difference, freq: 1,[[item: numbers, freq: 1,[[item: current, freq: 1,[[item: three, freq: 1,[[item: direct, freq: 1,[[item: implement, freq: 1,[[item: approximate, freq: 1,[[item: environment, freq: 1,[[item: bit, freq: 1,[[item: design, freq: 1,[[item: research, freq: 1,[[item: starts, freq: 1,[[item: Artificial, freq: 1,[[item: child, freq: 1,[[item: arguably, freq: 1,[[item: iterative, freq: 1,[[item: computation, freq: 1,[[item: solutions, freq: 1,[[item: about, freq: 1,[[item: successive, freq: 1,[[item: avoid, freq: 1,[[item: applications, freq: 1,[[item: (see, freq: 1,[[item: potentially, freq: 1,[[item: object, freq: 1,[[item: lead, freq: 1,[[item: continues, freq: 1,[[item: criterion, freq: 1,[[item: objects, freq: 1,[[item: simply, freq: 1,[[item: well, freq: 1,[[item: initialize, freq: 1,[[item: modifications, freq: 1,[[item: solution., freq: 1,[[item: away, freq: 1,[[item: primarily, freq: 1,[[item: construct, freq: 1,[[item: results, freq: 1,[[item: possibly, freq: 1,[[item: case., freq: 1,[[item: via, freq: 1,[[item: solve, freq: 1,[[item: planning,, freq: 1,[[item: arrays, freq: 1,[[item: further, freq: 1,[[item: selects, freq: 1,[[item: prevent, freq: 1,[[item: used,, freq: 1,[[item: class, freq: 1,[[item: attempt, freq: 1,[[item: appear, freq: 1,[[item: reached, freq: 1,[[item: Nils, freq: 1,[[item: adaptive, freq: 1,[[item: whereas, freq: 1,[[item: along, freq: 1,[[item: model, freq: 1,[[item: game,, freq: 1,[[item: selected,, freq: 1,[[item: Turing, freq: 1,[[item: and/or, freq: 1,[[item: integers,, freq: 1,[[item: implement,, freq: 1,[[item: Institute, freq: 1,[[item: context, freq: 1,[[item: global, freq: 1,[[item: algorithms., freq: 1,[[item: They, freq: 1,[[item: starting, freq: 1,[[item: broken, freq: 1,[[item: decreasing, freq: 1,[[item: Starting, freq: 1,[[item: whether, freq: 1,[[item: belongs, freq: 1,[[item: represent, freq: 1,[[item: strings, freq: 1,[[item: change, freq: 1,[[item: appropriate, freq: 1,[[item: versus, freq: 1,[[item: loop, freq: 1,[[item: (the, freq: 1,[[item: programming, freq: 1,[[item: defining, freq: 1,[[item: components, freq: 1,[[item: our, freq: 1,[[item: way,, freq: 1,[[item: were, freq: 1,[[item: diverse, freq: 1,[[item: types, freq: 1,[[item: updated, freq: 1,[[item: operations., freq: 1,[[item: provide, freq: 1,[[item: other., freq: 1,[[item: moves, freq: 1,[[item: satisfies, freq: 1,[[item: programs,, freq: 1,[[item: Such, freq: 1,[[item: effectively, freq: 1,[[item: stored, freq: 1,[[item: particularly, freq: 1,[[item: variants, freq: 1,[[item: reached., freq: 1,[[item: aim, freq: 1,[[item: how, freq: 1,[[item: understand, freq: 1,[[item: systems,, freq: 1,[[item: clear, freq: 1,[[item: inherently, freq: 1,[[item: form, freq: 1,[[item: (such, freq: 1,[[item: Thus,, freq: 1,[[item: instead, freq: 1,[[item: every, freq: 1,[[item: level, freq: 1,[[item: highly, freq: 1,[[item: study, freq: 1,[[item: range, freq: 1,[[item: portion, freq: 1,[[item: data., freq: 1,[[item: techniques, freq: 1,[[item: linked, freq: 1,[[item: lower, freq: 1,[[item: inefficient, freq: 1,[[item: quickly, freq: 1,[[item: essential, freq: 1,[[item: long, freq: 1,[[item: solved, freq: 1,[[item: later, freq: 1,[[item: certain, freq: 1,[[item: Design, freq: 1,[[item: developed, freq: 1,[[item: see, freq: 1,[[item: condition, freq: 1,[[item: typically, freq: 1,[[item: defined, freq: 1,[[item: part, freq: 1,[[item: product, freq: 1,[[item: quality, freq: 1,[[item: computational, freq: 1,[[item: steps, freq: 1,[[item: main, freq: 1,[[item: General, freq: 1,[[item: structural, freq: 1,[[item: depending, freq: 1,[[item: related, freq: 1,[[item: select, freq: 1,[[item: technique, freq: 1,[[item: action, freq: 1,[[item: expected, freq: 1,[[item: i.e., freq: 1,[[item: affected, freq: 1,[[item: 0, freq: 1,[[item: Some, freq: 1,[[item: addition, freq: 1,[[item: particular,, freq: 1,[[item: whole, freq: 1,[[item: idea, freq: 1,[[item: While, freq: 1,[[item: replacing, freq: 1,[[item: problem., freq: 1,[[item: generate, freq: 1,[[item: child,, freq: 1,[[item: generated, freq: 1,[[item: traverse, freq: 1,[[item: lowest, freq: 1,[[item: subject, freq: 1,[[item: Each, freq: 1,[[item: terminating, freq: 1,[[item: theorem, freq: 1,[[item: respect, freq: 1,[[item: could, freq: 1,[[item: information, freq: 1,[[item: others,, freq: 1,[[item: include:, freq: 1,[[item: parameters., freq: 1,[[item: Because, freq: 1,[[item: behind, freq: 1,[[item: optimization, freq: 1,[[item: promising, freq: 1,[[item: complete, freq: 1,[[item: better, freq: 1,[[item: smaller, freq: 1,[[item: probability,, freq: 1,[[item: components., freq: 1,[[item: examples, freq: 1,[[item: That, freq: 1,[[item: open, freq: 1,[[item: although, freq: 1,[[item: was, freq: 1,[[item: partial, freq: 1,[[item: implicitly, freq: 1,[[item: guarantees, freq: 1,[[item: heuristic, freq: 1,[[item: consists, freq: 1,[[item: heuristics, freq: 1,[[item: through, freq: 1,[[item: knowledge, freq: 1,[[item: frequently, freq: 1,[[item: add, freq: 1,[[item: Python, freq: 1,[[item: strings., freq: 1,[[item: classic, freq: 1,[[item: property, freq: 1,[[item: had, freq: 1,[[item: sets, freq: 1,[[item: suitable, freq: 1,[[item: response, freq: 1,[[item: get, freq: 1,[[item: Computer, freq: 1,[[item: series, freq: 1,[[item: As, freq: 1,[[item: control, freq: 1,[[item: programs, freq: 1,[[item: among, freq: 1,[[item: position., freq: 1,[[item: instance,, freq: 1,[[item: domain, freq: 1,[[item: mechanism, freq: 1,[[item: (possibly), freq: 1,[[item: There, freq: 1,[[item: orders, freq: 1,[[item: reason, freq: 1,[[item: distance, freq: 1,[[item: reduce, freq: 1,[[item: represents, freq: 1,[[item: probabilities, freq: 1,[[item: processes, freq: 1,[[item: down, freq: 1,[[item: mean, freq: 1,[[item: added,, freq: 1,[[item: expression, freq: 1,[[item: Research, freq: 1,[[item: efficiently, freq: 1,[[item: reference, freq: 1,[[item: variation, freq: 1,[[item: computing, freq: 1,[[item: stochastic, freq: 1,[[item: points, freq: 1,[[item: typical, freq: 1,[[item: (also, freq: 1,[[item: compared, freq: 1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][item: , freq: 1,[[item: many, freq: 1,[[item: performance, freq: 1,[[item: one, freq: 1,[[item: such, freq: 1,[[item: value, freq: 1,[[item: any, freq: 1,[[item: values, freq: 1,[[item: because, freq: 1,[[item: more, freq: 1,[[item: example,, freq: 1,[[item: +\n",
            ", freq: 1,[[item: greater, freq: 1,[[item: even, freq: 1,[[item: allow, freq: 1,[[item: simple, freq: 1,[[item: used, freq: 1,[[item: way, freq: 1,[[item: n, freq: 1,[[item: ≤\n",
            ", freq: 1,[[item: order, freq: 1,[[item: structure, freq: 1,[[item: use, freq: 1,[[item: or, freq: 1,[[item: this, freq: 1,[[item: found, freq: 1,[[item: practical, freq: 1,[[item: when, freq: 1,[[item: they, freq: 1,[[item: =, freq: 1,[[item: node, freq: 1,[[item: complexity, freq: 1,[[item: only, freq: 1,[[item: known, freq: 1,[[item: entire, freq: 1,[[item: given, freq: 1,[[item: \n",
            ", freq: 1,[[item: must, freq: 1,[[item: by, freq: 1,[[item: searching, freq: 1,[[item: return, freq: 1,[[item: <, freq: 1,[[item: data, freq: 1,[[item: 1\n",
            ", freq: 1,[[item: list,, freq: 1,[[item: However,, freq: 1,[[item: repeated, freq: 1,[[item: these, freq: 1,[[item: their, freq: 1,[[item: (\n",
            ", freq: 1,[[item: function, freq: 1,[[item: might, freq: 1,[[item: meaning, freq: 1,[[item: been, freq: 1,[[item: we, freq: 1,[[item: 2\n",
            ", freq: 1,[[item: very, freq: 1,[[item: step, freq: 1,[[item: also, freq: 1,[[item: both, freq: 1,[[item: first, freq: 1,[[item: until, freq: 1,[[item: search,, freq: 1,[[item: possible, freq: 1,[[item: second, freq: 1,[[item: operations, freq: 1,[[item: faster, freq: 1,[[item: being, freq: 1,[[item: worst, freq: 1,[[item: {\\displaystyle, freq: 1,[[item: )\n",
            ", freq: 1,[[item: This, freq: 1,[[item: within, freq: 1,[[item: elements, freq: 1,[[item: It, freq: 1,[[item: does, freq: 1,[[item: between, freq: 1,[[item: size, freq: 1,[[item: common, freq: 1,[[item: finite, freq: 1,[[item: based, freq: 1,[[item: requires, freq: 1,[[item: own, freq: 1,[[item: initial, freq: 1,[[item: {\n",
            ", freq: 1,[[item: node., freq: 1,[[item: using, freq: 1,[[item: solution,, freq: 1,[[item: right, freq: 1,[[item: next, freq: 1,[[item: into, freq: 1,[[item: allowing, freq: 1,[[item: up, freq: 1,[[item: science, freq: 1,[[item: >, freq: 1,[[item: decrease, freq: 1,[[item: depends, freq: 1,[[item: do, freq: 1,[[item: (or, freq: 1,[[item: reduced, freq: 1,[[item: application, freq: 1,[[item: once, freq: 1,[[item: maximum, freq: 1,[[item: rule, freq: 1,[[item: per, freq: 1,[[item: always, freq: 1,[[item: check, freq: 1,[[item: including, freq: 1,[[item: implementations, freq: 1,[[item: itself, freq: 1,[[item: efficiency, freq: 1,[[item: These, freq: 1,[[item: entirely, freq: 1,[[item: there, freq: 1,[[item: solving, freq: 1,[[item: performed, freq: 1,[[item: b\n",
            ", freq: 1,[[item: significant, freq: 1,[[item: shown, freq: 1,[[item: exact, freq: 1,[[item: fixed, freq: 1,[[item: though, freq: 1,[[item: rather, freq: 1,[[item: so, freq: 1,[[item: basic, freq: 1,[[item: making, freq: 1,[[item: result,, freq: 1,[[item: implementation, freq: 1,[[item: support, freq: 1,[[item: b, freq: 1,[[item: n\n",
            ", freq: 1,[[item: dynamic, freq: 1,[[item: building, freq: 1,[[item: different, freq: 1,[[item: generally, freq: 1,[[item: larger, freq: 1,[[item: already, freq: 1,[[item: less, freq: 1,[[item: theory, freq: 1,[[item: no, freq: 1,[[item: –, freq: 1,[[item: result, freq: 1,[[item: like, freq: 1,[[item: position, freq: 1,[[item: designed, freq: 1,[[item: If, freq: 1,[[item: function,, freq: 1,[[item: approach, freq: 1,[[item: valid, freq: 1,[[item: =\n",
            ", freq: 1,[[item: contains, freq: 1,[[item: tree, freq: 1,[[item: nodes, freq: 1,[[item: sum, freq: 1,[[item: set, freq: 1,[[item: cost, freq: 1,[[item: −\n",
            ", freq: 1,[[item: terms, freq: 1,[[item: stores, freq: 1,[[item: By, freq: 1,[[item: -, freq: 1,[[item: those, freq: 1,[[item: problems, freq: 1,[[item: element, freq: 1,[[item: problems,, freq: 1,[[item: include, freq: 1,[[item: either, freq: 1,[[item: trees, freq: 1,[[item: several, freq: 1,[[item: due, freq: 1,[[item: above, freq: 1,[[item: usually, freq: 1,[[item: involves, freq: 1,[[item: method, freq: 1,[[item: without, freq: 1,[[item: easily, freq: 1,[[item: near, freq: 1,[[item: it., freq: 1,[[item: structures, freq: 1,[[item: particular, freq: 1,[[item: problem, freq: 1,[[item: seen, freq: 1,[[item: 2, freq: 1,[[item: corresponding, freq: 1,[[item: process, freq: 1,[[item: methods, freq: 1,[[item: equivalent, freq: 1,[[item: occurs, freq: 1,[[item: small, freq: 1,[[item: equally, freq: 1,[[item: iteration, freq: 1,[[item: proved, freq: 1,[[item: case, freq: 1,[[item: point, freq: 1,[[item: considered, freq: 1,[[item: termination, freq: 1,[[item: special, freq: 1,[[item: may, freq: 1,[[item: whose, freq: 1,[[item: linear, freq: 1,[[item: 1, freq: 1,[[item: perform, freq: 1,[[item: applied, freq: 1,[[item: since, freq: 1,[[item: them, freq: 1,[[item: standard, freq: 1,[[item: space,, freq: 1,[[item: n,, freq: 1,[[item: means, freq: 1,[[item: place, freq: 1,[[item: while, freq: 1,[[item: move, freq: 1,[[item: important, freq: 1,[[item: case,, freq: 1,[[item: would, freq: 1,[[item: exponential, freq: 1,[[item: An, freq: 1,[[item: created, freq: 1,[[item: alternative, freq: 1,[[item: space, freq: 1,[[item: much, freq: 1,[[item: 3, freq: 1,[[item: list, freq: 1,[[item: (which, freq: 1,[[item: science,, freq: 1,[[item: solution, freq: 1,[[item: efficiency., freq: 1,[[item: called, freq: 1,[[item: is,, freq: 1,[[item: implemented, freq: 1,[[item: A, freq: 1,[[item: state, freq: 1,[[item: another, freq: 1,[[item: variable, freq: 1,[[item: tree,, freq: 1,[[item: described, freq: 1,[[item: allows, freq: 1,[[item: never, freq: 1,[[item: new, freq: 1,[[item: algorithm,, freq: 1,[[item: 0\n",
            ", freq: 1,[[item: (and, freq: 1,[[item: intended, freq: 1,[[item: beginning, freq: 1,[[item: (as, freq: 1,[[item: operation, freq: 1,[[item: evaluation, freq: 1,[[item: actual, freq: 1,[[item: content, freq: 1,[[item: \\varepsilon, freq: 1,[[item: say, freq: 1,[[item: Other, freq: 1,[[item: heap,, freq: 1,[[item: combine, freq: 1,[[item: essentially, freq: 1,[[item: languages,, freq: 1,[[item: define, freq: 1,[[item: grammars, freq: 1,[[item: you, freq: 1,[[item: table, freq: 1,[[item: depth-first, freq: 1,[[item: absence, freq: 1,[[item: guaranteed, freq: 1,[[item: referred, freq: 1,[[item: structure., freq: 1,[[item: i.e.,, freq: 1,[[item: occur, freq: 1,[[item: similar, freq: 1,[[item: construction, freq: 1,[[item: (e.g., freq: 1,[[item: complex, freq: 1,[[item: procedure, freq: 1,[[item: here, freq: 1,[[item: hybrid, freq: 1,[[item: With, freq: 1,[[item: sorted, freq: 1,[[item: directly, freq: 1,[[item: one., freq: 1,[[item: f, freq: 1,[[item: happens, freq: 1,[[item: natural, freq: 1,[[item: testing, freq: 1,[[item: sort, freq: 1,[[item: insertion, freq: 1,[[item: operators,, freq: 1,[[item: infinite, freq: 1,[[item: pick, freq: 1,[[item: require, freq: 1,[[item: array, freq: 1,[[item: search., freq: 1,[[item: regarding, freq: 1,[[item: When, freq: 1,[[item: difficult, freq: 1,[[item: multiple, freq: 1,[[item: heap, freq: 1,[[item: permits, freq: 1,[[item: therefore, freq: 1,[[item: parameters, freq: 1,[[item: takes, freq: 1,[[item: considering, freq: 1,[[item: working, freq: 1,[[item: tree., freq: 1,[[item: definition, freq: 1,[[item: overall, freq: 1,[[item: and,, freq: 1,[[item: evaluated, freq: 1,[[item: example, freq: 1,[[item: cases,, freq: 1,[[item: concepts, freq: 1,[[item: grow, freq: 1,[[item: References, freq: 1,[[item: factor, freq: 1,[[item: kind, freq: 1,[[item: work, freq: 1,[[item: necessarily, freq: 1,[[item: programming,, freq: 1,[[item: provides, freq: 1,[[item: able, freq: 1,[[item: Like, freq: 1,[[item: help, freq: 1,[[item: desired, freq: 1,[[item: available, freq: 1,[[item: note, freq: 1,[[item: (for, freq: 1,[[item: −, freq: 1,[[item: manner,, freq: 1,[[item: especially, freq: 1,[[item: a\n",
            ", freq: 1,[[item: involved, freq: 1,[[item: method., freq: 1,[[item: leading, freq: 1,[[item: generates, freq: 1,[[item: variants,, freq: 1,[[item: difference, freq: 1,[[item: useful, freq: 1,[[item: numbers, freq: 1,[[item: current, freq: 1,[[item: three, freq: 1,[[item: running, freq: 1,[[item: direct, freq: 1,[[item: environment, freq: 1,[[item: design, freq: 1,[[item: maintaining, freq: 1,[[item: log\n",
            ", freq: 1,[[item: starts, freq: 1,[[item: >0}\n",
            ", freq: 1,[[item: child, freq: 1,[[item: string, freq: 1,[[item: arguably, freq: 1,[[item: iterative, freq: 1,[[item: computation, freq: 1,[[item: solutions, freq: 1,[[item: successive, freq: 1,[[item: avoid, freq: 1,[[item: (see, freq: 1,[[item: object, freq: 1,[[item: +, freq: 1,[[item: Fibonacci, freq: 1,[[item: cases, freq: 1,[[item: branch, freq: 1,[[item: f\n",
            ", freq: 1,[[item: h\n",
            ", freq: 1,[[item: arbitrarily, freq: 1,[[item: objects, freq: 1,[[item: simply, freq: 1,[[item: Thus, freq: 1,[[item: initialize, freq: 1,[[item: modifications, freq: 1,[[item: Therefore,, freq: 1,[[item: primarily, freq: 1,[[item: unbounded, freq: 1,[[item: construct, freq: 1,[[item: results, freq: 1,[[item: ,\n",
            ", freq: 1,[[item: eventually, freq: 1,[[item: case., freq: 1,[[item: via, freq: 1,[[item: solve, freq: 1,[[item: type, freq: 1,[[item: children, freq: 1,[[item: positive, freq: 1,[[item: further, freq: 1,[[item: prevent, freq: 1,[[item: used,, freq: 1,[[item: class, freq: 1,[[item: original, freq: 1,[[item: adaptive, freq: 1,[[item: whereas, freq: 1,[[item: memory., freq: 1,[[item: model, freq: 1,[[item: complexity,, freq: 1,[[item: short, freq: 1,[[item: Turing, freq: 1,[[item: hence, freq: 1,[[item: and/or, freq: 1,[[item: integers,, freq: 1,[[item: Binary, freq: 1,[[item: context, freq: 1,[[item: terminate, freq: 1,[[item: ε\n",
            ", freq: 1,[[item: algorithms., freq: 1,[[item: They, freq: 1,[[item: passing, freq: 1,[[item: time., freq: 1,[[item: exception, freq: 1,[[item: Starting, freq: 1,[[item: belongs, freq: 1,[[item: strings, freq: 1,[[item: pathological, freq: 1,[[item: appropriate, freq: 1,[[item: versus, freq: 1,[[item: loop, freq: 1,[[item: pointers, freq: 1,[[item: zero, freq: 1,[[item: practice, freq: 1,[[item: height, freq: 1,[[item: programming, freq: 1,[[item: defining, freq: 1,[[item: components, freq: 1,[[item: our, freq: 1,[[item: were, freq: 1,[[item: types, freq: 1,[[item: third, freq: 1,[[item: depth, freq: 1,[[item: operations., freq: 1,[[item: version, freq: 1,[[item: provide, freq: 1,[[item: extra, freq: 1,[[item: other., freq: 1,[[item: moves, freq: 1,[[item: what, freq: 1,[[item: programs,, freq: 1,[[item: Such, freq: 1,[[item: effectively, freq: 1,[[item: stored, freq: 1,[[item: particularly, freq: 1,[[item: reached., freq: 1,[[item: how, freq: 1,[[item: memory, freq: 1,[[item: understand, freq: 1,[[item: clear, freq: 1,[[item: inherently, freq: 1,[[item: form, freq: 1,[[item: data,, freq: 1,[[item: C, freq: 1,[[item: (such, freq: 1,[[item: build, freq: 1,[[item: call, freq: 1,[[item: searched, freq: 1,[[item: instead, freq: 1,[[item: level, freq: 1,[[item: highly, freq: 1,[[item: portion, freq: 1,[[item: data., freq: 1,[[item: techniques, freq: 1,[[item: linked, freq: 1,[[item: x, freq: 1,[[item: inefficient, freq: 1,[[item: long, freq: 1,[[item: solved, freq: 1,[[item: Design, freq: 1,[[item: developed, freq: 1,[[item: see, freq: 1,[[item: typically, freq: 1,[[item: defined, freq: 1,[[item: product, freq: 1,[[item: index, freq: 1,[[item: computational, freq: 1,[[item: ,, freq: 1,[[item: steps, freq: 1,[[item: once,, freq: 1,[[item: x\n",
            ", freq: 1,[[item: compute, freq: 1,[[item: \n",
            "\n",
            ", freq: 1,[[item: structural, freq: 1,[[item: node,, freq: 1,[[item: related, freq: 1,[[item: constant, freq: 1,[[item: left, freq: 1,[[item: technique, freq: 1,[[item: logarithmic, freq: 1,[[item: Every, freq: 1,[[item: ==, freq: 1,[[item: 0, freq: 1,[[item: possibility, freq: 1,[[item: Some, freq: 1,[[item: addition, freq: 1,[[item: replacing, freq: 1,[[item: problem., freq: 1,[[item: generate, freq: 1,[[item: traverse, freq: 1,[[item: subject, freq: 1,[[item: terminating, freq: 1,[[item: information, freq: 1,[[item: include:, freq: 1,[[item: case.\n",
            "In, freq: 1,[[item: parameters., freq: 1,[[item: Because, freq: 1,[[item: behind, freq: 1,[[item: optimization, freq: 1,[[item: required, freq: 1,[[item: One, freq: 1,[[item: need, freq: 1,[[item: >\n",
            ", freq: 1,[[item: on,, freq: 1,[[item: pseudocode, freq: 1,[[item: complete, freq: 1,[[item: smaller, freq: 1,[[item: components., freq: 1,[[item: expressed, freq: 1,[[item: O\n",
            ", freq: 1,[[item: examples, freq: 1,[[item: hold, freq: 1,[[item: That, freq: 1,[[item: although, freq: 1,[[item: partial, freq: 1,[[item: space., freq: 1,[[item: removed, freq: 1,[[item: implicitly, freq: 1,[[item: Alternatively,, freq: 1,[[item: advantage, freq: 1,[[item: becomes, freq: 1,[[item: consists, freq: 1,[[item: knowledge, freq: 1,[[item: add, freq: 1,[[item: steps,, freq: 1,[[item: Python, freq: 1,[[item: strings., freq: 1,[[item: classic, freq: 1,[[item: property, freq: 1,[[item: sequence, freq: 1,[[item: children,, freq: 1,[[item: smallest, freq: 1,[[item: suitable, freq: 1,[[item: response, freq: 1,[[item: traversal, freq: 1,[[item: series, freq: 1,[[item: As, freq: 1,[[item: definitions, freq: 1,[[item: control, freq: 1,[[item: programs, freq: 1,[[item: track, freq: 1,[[item: position., freq: 1,[[item: instance,, freq: 1,[[item: domain, freq: 1,[[item: mechanism, freq: 1,[[item: (possibly), freq: 1,[[item: There, freq: 1,[[item: keeps, freq: 1,[[item: orders, freq: 1,[[item: ending, freq: 1,[[item: reason, freq: 1,[[item: true, freq: 1,[[item: g, freq: 1,[[item: reduce, freq: 1,[[item: represents, freq: 1,[[item: processes, freq: 1,[[item: down, freq: 1,[[item: added,, freq: 1,[[item: expression, freq: 1,[[item: y\n",
            ", freq: 1,[[item: ⁡\n",
            ", freq: 1,[[item: computing, freq: 1,[[item: start, freq: 1,[[item: array., freq: 1,[[item: typical, freq: 1,[[item: 1,, freq: 1,[[item: proof, freq: 1,[[item: (also, freq: 1,[[item: compared, freq: 1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][item: other, freq: 2,[[item: an, freq: 2,[[item: have, freq: 2,[[item: time, freq: 2,[[item: for, freq: 2,[[item: it, freq: 2,[[item: often, freq: 2,[[item: as, freq: 2,[[item: algorithm, freq: 1,[[item: computer, freq: 1,[[item: algorithms, freq: 1,[[item: where, freq: 1,[[item: which, freq: 1,[[item: same, freq: 1,[[item: that, freq: 1,[[item: number, freq: 1,[[item: search, freq: 1,[[item: can, freq: 1,[[item: is, freq: 1,[[item: its, freq: 1,[[item: will, freq: 1,[[item: has, freq: 1,[[item: the, freq: 1,[[item: in, freq: 1,[[item: be, freq: 1,[[item: all, freq: 1,[[item: but, freq: 1,[[item: most, freq: 1,[[item: if, freq: 1,[[item: For, freq: 1,[[item: and, freq: 1,[[item: from, freq: 1,[[item: large, freq: 1,[[item: with, freq: 1,[[item: efficient, freq: 1,[[item: binary, freq: 1,[[item: on, freq: 1,[[item: not, freq: 1,[[item: each, freq: 1,[[item: In, freq: 1,[[item: a, freq: 1,[[item: then, freq: 1,[[item: of, freq: 1,[[item: to, freq: 1,[[item: than, freq: 1,[[item: The, freq: 1,[[item: equal, freq: 1,[[item: are, freq: 1,[[item: single, freq: 1,[[item: at, freq: 1,[[item: some, freq: 1,[[item: two, freq: 1,[[item: , freq: 1,[[item: been, freq: 1,[[item: we, freq: 1,[[item: 2\n",
            ", freq: 1,[[item: many, freq: 1,[[item: performance, freq: 1,[[item: very, freq: 1,[[item: step, freq: 1,[[item: one, freq: 1,[[item: also, freq: 1,[[item: use, freq: 1,[[item: both, freq: 1,[[item: until, freq: 1,[[item: first, freq: 1,[[item: such, freq: 1,[[item: value, freq: 1,[[item: find, freq: 1,[[item: or, freq: 1,[[item: search,, freq: 1,[[item: must, freq: 1,[[item: by, freq: 1,[[item: any, freq: 1,[[item: possible, freq: 1,[[item: values, freq: 1,[[item: searching, freq: 1,[[item: return, freq: 1,[[item: <, freq: 1,[[item: 1\n",
            ", freq: 1,[[item: second, freq: 1,[[item: this, freq: 1,[[item: found, freq: 1,[[item: list,, freq: 1,[[item: because, freq: 1,[[item: operations, freq: 1,[[item: more, freq: 1,[[item: However,, freq: 1,[[item: practical, freq: 1,[[item: repeated, freq: 1,[[item: faster, freq: 1,[[item: example,, freq: 1,[[item: +\n",
            ", freq: 1,[[item: when, freq: 1,[[item: they, freq: 1,[[item: complexity, freq: 1,[[item: these, freq: 1,[[item: =, freq: 1,[[item: even, freq: 1,[[item: being, freq: 1,[[item: node, freq: 1,[[item: worst, freq: 1,[[item: {\\displaystyle, freq: 1,[[item: uses, freq: 1,[[item: only, freq: 1,[[item: )\n",
            ", freq: 1,[[item: known, freq: 1,[[item: simple, freq: 1,[[item: entire, freq: 1,[[item: their, freq: 1,[[item: given, freq: 1,[[item: used, freq: 1,[[item: This, freq: 1,[[item: \n",
            ", freq: 1,[[item: way, freq: 1,[[item: n, freq: 1,[[item: (\n",
            ", freq: 1,[[item: elements, freq: 1,[[item: ≤\n",
            ", freq: 1,[[item: It, freq: 1,[[item: function, freq: 1,[[item: might, freq: 1,[[item: meaning, freq: 1,[[item: −\n",
            ", freq: 1,[[item: does, freq: 1,[[item: entirely, freq: 1,[[item: there, freq: 1,[[item: between, freq: 1,[[item: terms, freq: 1,[[item: minimum, freq: 1,[[item: stores, freq: 1,[[item: solving, freq: 1,[[item: standard, freq: 1,[[item: performed, freq: 1,[[item: size, freq: 1,[[item: space,, freq: 1,[[item: common, freq: 1,[[item: n,, freq: 1,[[item: b\n",
            ", freq: 1,[[item: those, freq: 1,[[item: problems, freq: 1,[[item: significant, freq: 1,[[item: means, freq: 1,[[item: finite, freq: 1,[[item: based, freq: 1,[[item: problems,, freq: 1,[[item: shown, freq: 1,[[item: include, freq: 1,[[item: move, freq: 1,[[item: exact, freq: 1,[[item: important, freq: 1,[[item: fixed, freq: 1,[[item: case,, freq: 1,[[item: own, freq: 1,[[item: {\n",
            ", freq: 1,[[item: length, freq: 1,[[item: would, freq: 1,[[item: node., freq: 1,[[item: exponential, freq: 1,[[item: An, freq: 1,[[item: due, freq: 1,[[item: using, freq: 1,[[item: following, freq: 1,[[item: instance, freq: 1,[[item: rather, freq: 1,[[item: solution,, freq: 1,[[item: best, freq: 1,[[item: so, freq: 1,[[item: next, freq: 1,[[item: terminates, freq: 1,[[item: into, freq: 1,[[item: allowing, freq: 1,[[item: implementation, freq: 1,[[item: without, freq: 1,[[item: support, freq: 1,[[item: b, freq: 1,[[item: created, freq: 1,[[item: up, freq: 1,[[item: science, freq: 1,[[item: >, freq: 1,[[item: decrease, freq: 1,[[item: alternative, freq: 1,[[item: easily, freq: 1,[[item: finding, freq: 1,[[item: n\n",
            ", freq: 1,[[item: space, freq: 1,[[item: depends, freq: 1,[[item: dynamic, freq: 1,[[item: building, freq: 1,[[item: different, freq: 1,[[item: problem, freq: 1,[[item: generally, freq: 1,[[item: seen, freq: 1,[[item: already, freq: 1,[[item: corresponding, freq: 1,[[item: reduced, freq: 1,[[item: process, freq: 1,[[item: (which, freq: 1,[[item: equivalent, freq: 1,[[item: once, freq: 1,[[item: no, freq: 1,[[item: low, freq: 1,[[item: elements,, freq: 1,[[item: rule, freq: 1,[[item: per, freq: 1,[[item: solution, freq: 1,[[item: occurs, freq: 1,[[item: efficiency., freq: 1,[[item: few, freq: 1,[[item: always, freq: 1,[[item: –, freq: 1,[[item: called, freq: 1,[[item: result, freq: 1,[[item: like, freq: 1,[[item: still, freq: 1,[[item: end, freq: 1,[[item: equally, freq: 1,[[item: iteration, freq: 1,[[item: proved, freq: 1,[[item: case, freq: 1,[[item: point, freq: 1,[[item: check, freq: 1,[[item: position, freq: 1,[[item: implemented, freq: 1,[[item: A, freq: 1,[[item: designed, freq: 1,[[item: state, freq: 1,[[item: another, freq: 1,[[item: including, freq: 1,[[item: If, freq: 1,[[item: approach, freq: 1,[[item: function,, freq: 1,[[item: implementations, freq: 1,[[item: considered, freq: 1,[[item: =\n",
            ", freq: 1,[[item: termination, freq: 1,[[item: special, freq: 1,[[item: tree,, freq: 1,[[item: whose, freq: 1,[[item: itself, freq: 1,[[item: described, freq: 1,[[item: efficiency, freq: 1,[[item: allows, freq: 1,[[item: average, freq: 1,[[item: tree, freq: 1,[[item: never, freq: 1,[[item: nodes, freq: 1,[[item: Search, freq: 1,[[item: perform, freq: 1,[[item: 1, freq: 1,[[item: take, freq: 1,[[item: sum, freq: 1,[[item: new, freq: 1,[[item: specific, freq: 1,[[item: set, freq: 1,[[item: algorithm,, freq: 1,[[item: since, freq: 1,[[item: 0\n",
            ", freq: 1,[[item: cost, freq: 1,[[item: zero, freq: 1,[[item: involved, freq: 1,[[item: ≤, freq: 1,[[item: notion, freq: 1,[[item: cannot, freq: 1,[[item: generated, freq: 1,[[item: leading, freq: 1,[[item: lowest, freq: 1,[[item: general, freq: 1,[[item: attempts, freq: 1,[[item: theorem, freq: 1,[[item: operation, freq: 1,[[item: value., freq: 1,[[item: respect, freq: 1,[[item: actual, freq: 1,[[item: could, freq: 1,[[item: \\varepsilon, freq: 1,[[item: published, freq: 1,[[item: running, freq: 1,[[item: approximate, freq: 1,[[item: bit, freq: 1,[[item: quality, freq: 1,[[item: heap,, freq: 1,[[item: On, freq: 1,[[item: algorithm., freq: 1,[[item: diverse, freq: 1,[[item: case.\n",
            "In, freq: 1,[[item: test, freq: 1,[[item: maintaining, freq: 1,[[item: limited, freq: 1,[[item: log\n",
            ", freq: 1,[[item: research, freq: 1,[[item: needs, freq: 1,[[item: Artificial, freq: 1,[[item: updated, freq: 1,[[item: depth, freq: 1,[[item: (a, freq: 1,[[item: >0}\n",
            ", freq: 1,[[item: grammars, freq: 1,[[item: ISBN, freq: 1,[[item: references, freq: 1,[[item: table, freq: 1,[[item: depth-first, freq: 1,[[item: J., freq: 1,[[item: performance,, freq: 1,[[item: candidate, freq: 1,[[item: about, freq: 1,[[item: version, freq: 1,[[item: required, freq: 1,[[item: One, freq: 1,[[item: speed, freq: 1,[[item: guaranteed, freq: 1,[[item: >\n",
            ", freq: 1,[[item: referred, freq: 1,[[item: iterations, freq: 1,[[item: subset, freq: 1,[[item: what, freq: 1,[[item: applications, freq: 1,[[item: on,, freq: 1,[[item: satisfies, freq: 1,[[item: pseudocode, freq: 1,[[item: however,, freq: 1,[[item: promising, freq: 1,[[item: better, freq: 1,[[item: here, freq: 1,[[item: online, freq: 1,[[item: expressed, freq: 1,[[item: +, freq: 1,[[item: algorithms,, freq: 1,[[item: With, freq: 1,[[item: Fibonacci, freq: 1,[[item: O\n",
            ", freq: 1,[[item: hash, freq: 1,[[item: cases, freq: 1,[[item: Its, freq: 1,[[item: hold, freq: 1,[[item: directly, freq: 1,[[item: variants, freq: 1,[[item: branch, freq: 1,[[item: f\n",
            ", freq: 1,[[item: finds, freq: 1,[[item: one., freq: 1,[[item: lead, freq: 1,[[item: continues, freq: 1,[[item: h\n",
            ", freq: 1,[[item: higher, freq: 1,[[item: aim, freq: 1,[[item: node's, freq: 1,[[item: f, freq: 1,[[item: criterion, freq: 1,[[item: arbitrarily, freq: 1,[[item: open, freq: 1,[[item: happens, freq: 1,[[item: memory, freq: 1,[[item: Thus, freq: 1,[[item: was, freq: 1,[[item: describes, freq: 1,[[item: systems,, freq: 1,[[item: removed, freq: 1,[[item: nodes., freq: 1,[[item: well, freq: 1,[[item: determine, freq: 1,[[item: solution., freq: 1,[[item: Alternatively,, freq: 1,[[item: guarantees, freq: 1,[[item: heuristic, freq: 1,[[item: C, freq: 1,[[item: least, freq: 1,[[item: away, freq: 1,[[item: becomes, freq: 1,[[item: target., freq: 1,[[item: Thus,, freq: 1,[[item: unbounded, freq: 1,[[item: heuristics, freq: 1,[[item: call, freq: 1,[[item: effective, freq: 1,[[item: ., freq: 1,[[item: every, freq: 1,[[item: through, freq: 1,[[item: combination, freq: 1,[[item: steps,, freq: 1,[[item: infinite, freq: 1,[[item: study, freq: 1,[[item: possibly, freq: 1,[[item: sequence, freq: 1,[[item: ,\n",
            ", freq: 1,[[item: eventually, freq: 1,[[item: had, freq: 1,[[item: sets, freq: 1,[[item: smallest, freq: 1,[[item: x, freq: 1,[[item: lower, freq: 1,[[item: planning,, freq: 1,[[item: positive, freq: 1,[[item: When, freq: 1,[[item: selects, freq: 1,[[item: proposed, freq: 1,[[item: traversal, freq: 1,[[item: essential, freq: 1,[[item: get, freq: 1,[[item: heap, freq: 1,[[item: definitions, freq: 1,[[item: appear, freq: 1,[[item: original, freq: 1,[[item: reached, freq: 1,[[item: Nils, freq: 1,[[item: significantly, freq: 1,[[item: takes, freq: 1,[[item: among, freq: 1,[[item: track, freq: 1,[[item: later, freq: 1,[[item: certain, freq: 1,[[item: considering, freq: 1,[[item: memory., freq: 1,[[item: along, freq: 1,[[item: game,, freq: 1,[[item: selected,, freq: 1,[[item: condition, freq: 1,[[item: complexity,, freq: 1,[[item: part, freq: 1,[[item: originally, freq: 1,[[item: keeps, freq: 1,[[item: hence, freq: 1,[[item: ending, freq: 1,[[item: ,, freq: 1,[[item: example, freq: 1,[[item: optimal, freq: 1,[[item: nodes,, freq: 1,[[item: path, freq: 1,[[item: concepts, freq: 1,[[item: Institute, freq: 1,[[item: true, freq: 1,[[item: conditions, freq: 1,[[item: distance, freq: 1,[[item: grow, freq: 1,[[item: good, freq: 1,[[item: pre-process, freq: 1,[[item: selection, freq: 1,[[item: main, freq: 1,[[item: General, freq: 1,[[item: worse, freq: 1,[[item: factor, freq: 1,[[item: g, freq: 1,[[item: necessary, freq: 1,[[item: x\n",
            ", freq: 1,[[item: compute, freq: 1,[[item: depending, freq: 1,[[item: Algorithm, freq: 1,[[item: mean, freq: 1,[[item: terminate, freq: 1,[[item: node,, freq: 1,[[item: Research, freq: 1,[[item: y\n",
            ", freq: 1,[[item: efficiently, freq: 1,[[item: constant, freq: 1,[[item: reference, freq: 1,[[item: ε\n",
            ", freq: 1,[[item: global, freq: 1,[[item: problems., freq: 1,[[item: contained, freq: 1,[[item: select, freq: 1,[[item: ⁡\n",
            ", freq: 1,[[item: time., freq: 1,[[item: times, freq: 1,[[item: processing, freq: 1,[[item: starting, freq: 1,[[item: target, freq: 1,[[item: action, freq: 1,[[item: logarithmic, freq: 1,[[item: available, freq: 1,[[item: i.e., freq: 1,[[item: broken, freq: 1,[[item: Every, freq: 1,[[item: stochastic, freq: 1,[[item: note, freq: 1,[[item: start, freq: 1,[[item: possibility, freq: 1,[[item: represent, freq: 1,[[item: proof, freq: 1,[[item: pathological, freq: 1,[[item: −, freq: 1,[[item: manner,, freq: 1,[[item: .\n",
            ", freq: 1,[[item: (the, freq: 1,[[item: pointers, freq: 1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][item: computer, freq: 1,[[item: algorithm, freq: 1,[[item: algorithms, freq: 1,[[item: where, freq: 1,[[item: which, freq: 1,[[item: same, freq: 1,[[item: that, freq: 1,[[item: number, freq: 1,[[item: search, freq: 1,[[item: can, freq: 1,[[item: is, freq: 1,[[item: its, freq: 1,[[item: will, freq: 1,[[item: has, freq: 1,[[item: the, freq: 1,[[item: in, freq: 1,[[item: be, freq: 1,[[item: all, freq: 1,[[item: but, freq: 1,[[item: most, freq: 1,[[item: if, freq: 1,[[item: For, freq: 1,[[item: and, freq: 1,[[item: from, freq: 1,[[item: large, freq: 1,[[item: with, freq: 1,[[item: efficient, freq: 1,[[item: binary, freq: 1,[[item: on, freq: 1,[[item: not, freq: 1,[[item: each, freq: 1,[[item: In, freq: 1,[[item: a, freq: 1,[[item: then, freq: 1,[[item: of, freq: 1,[[item: to, freq: 1,[[item: than, freq: 1,[[item: The, freq: 1,[[item: equal, freq: 1,[[item: are, freq: 1,[[item: single, freq: 1,[[item: at, freq: 1,[[item: some, freq: 1,[[item: two, freq: 1,[[item: , freq: 1,[[item: been, freq: 1,[[item: 2\n",
            ", freq: 1,[[item: many, freq: 1,[[item: performance, freq: 1,[[item: very, freq: 1,[[item: step, freq: 1,[[item: order, freq: 1,[[item: structure, freq: 1,[[item: one, freq: 1,[[item: both, freq: 1,[[item: use, freq: 1,[[item: until, freq: 1,[[item: such, freq: 1,[[item: first, freq: 1,[[item: value, freq: 1,[[item: find, freq: 1,[[item: or, freq: 1,[[item: search,, freq: 1,[[item: by, freq: 1,[[item: values, freq: 1,[[item: searching, freq: 1,[[item: return, freq: 1,[[item: <, freq: 1,[[item: data, freq: 1,[[item: 1\n",
            ", freq: 1,[[item: second, freq: 1,[[item: this, freq: 1,[[item: found, freq: 1,[[item: list,, freq: 1,[[item: because, freq: 1,[[item: more, freq: 1,[[item: However,, freq: 1,[[item: practical, freq: 1,[[item: repeated, freq: 1,[[item: faster, freq: 1,[[item: example,, freq: 1,[[item: +\n",
            ", freq: 1,[[item: greater, freq: 1,[[item: when, freq: 1,[[item: these, freq: 1,[[item: =, freq: 1,[[item: even, freq: 1,[[item: being, freq: 1,[[item: allow, freq: 1,[[item: worst, freq: 1,[[item: {\\displaystyle, freq: 1,[[item: uses, freq: 1,[[item: only, freq: 1,[[item: )\n",
            ", freq: 1,[[item: known, freq: 1,[[item: simple, freq: 1,[[item: This, freq: 1,[[item: \n",
            ", freq: 1,[[item: n, freq: 1,[[item: (\n",
            ", freq: 1,[[item: within, freq: 1,[[item: elements, freq: 1,[[item: ≤\n",
            ", freq: 1,[[item: It, freq: 1,[[item: might, freq: 1,[[item: −\n",
            ", freq: 1,[[item: them, freq: 1,[[item: n,, freq: 1,[[item: By, freq: 1,[[item: -, freq: 1,[[item: element, freq: 1,[[item: place, freq: 1,[[item: requires, freq: 1,[[item: initial, freq: 1,[[item: {\n",
            ", freq: 1,[[item: though, freq: 1,[[item: length, freq: 1,[[item: above, freq: 1,[[item: usually, freq: 1,[[item: following, freq: 1,[[item: instance, freq: 1,[[item: best, freq: 1,[[item: terminates, freq: 1,[[item: method, freq: 1,[[item: basic, freq: 1,[[item: making, freq: 1,[[item: result,, freq: 1,[[item: finding, freq: 1,[[item: n\n",
            ", freq: 1,[[item: near, freq: 1,[[item: it., freq: 1,[[item: much, freq: 1,[[item: larger, freq: 1,[[item: 3, freq: 1,[[item: (or, freq: 1,[[item: 2, freq: 1,[[item: corresponding, freq: 1,[[item: methods, freq: 1,[[item: list, freq: 1,[[item: once, freq: 1,[[item: theory, freq: 1,[[item: science,, freq: 1,[[item: elements,, freq: 1,[[item: per, freq: 1,[[item: occurs, freq: 1,[[item: few, freq: 1,[[item: end, freq: 1,[[item: still, freq: 1,[[item: equally, freq: 1,[[item: case, freq: 1,[[item: check, freq: 1,[[item: If, freq: 1,[[item: valid, freq: 1,[[item: =\n",
            ", freq: 1,[[item: may, freq: 1,[[item: linear, freq: 1,[[item: average, freq: 1,[[item: 1, freq: 1,[[item: 0\n",
            ", freq: 1,[[item: cost, freq: 1,[[item: ≤, freq: 1,[[item: method., freq: 1,[[item: beginning, freq: 1,[[item: practice, freq: 1,[[item: value., freq: 1,[[item: content, freq: 1,[[item: others,, freq: 1,[[item: way,, freq: 1,[[item: On, freq: 1,[[item: (a, freq: 1,[[item: ISBN, freq: 1,[[item: absence, freq: 1,[[item: extra, freq: 1,[[item: probability,, freq: 1,[[item: hash, freq: 1,[[item: finds, freq: 1,[[item: worst-case, freq: 1,[[item: items,, freq: 1,[[item: sort, freq: 1,[[item: Therefore,, freq: 1,[[item: build, freq: 1,[[item: target., freq: 1,[[item: adding, freq: 1,[[item: searched, freq: 1,[[item: ., freq: 1,[[item: quickly, freq: 1,[[item: arrays, freq: 1,[[item: Computer, freq: 1,[[item: significantly, freq: 1,[[item: short, freq: 1,[[item: comparable, freq: 1,[[item: index, freq: 1,[[item: implement,, freq: 1,[[item: Linear, freq: 1,[[item: pre-process, freq: 1,[[item: ordered, freq: 1,[[item: once,, freq: 1,[[item: makes, freq: 1,[[item: probabilities, freq: 1,[[item: \n",
            "\n",
            ", freq: 1,[[item: likely, freq: 1,[[item: comparison, freq: 1,[[item: contained, freq: 1,[[item: variation, freq: 1,[[item: times, freq: 1,[[item: {\\frac, freq: 1,[[item: target, freq: 1,[[item: expected, freq: 1,[[item: desired, freq: 1,[[item: affected, freq: 1,[[item: decreasing, freq: 1,[[item: points, freq: 1,[[item: items, freq: 1,[[item: 1,, freq: 1,[[item: (for, freq: 1,[[item: change, freq: 1,[[item: particular,, freq: 1,[[item: .\n",
            ", freq: 1,[[item: whole, freq: 1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][item: then, freq: 1,[[item: of, freq: 1,[[item: other, freq: 1,[[item: where, freq: 1,[[item: an, freq: 1,[[item: which, freq: 1,[[item: if, freq: 1,[[item: have, freq: 1,[[item: For, freq: 1,[[item: same, freq: 1,[[item: that, freq: 1,[[item: and, freq: 1,[[item: time, freq: 1,[[item: number, freq: 1,[[item: search, freq: 1,[[item: can, freq: 1,[[item: for, freq: 1,[[item: is, freq: 1,[[item: its, freq: 1,[[item: will, freq: 1,[[item: from, freq: 1,[[item: to, freq: 1,[[item: than, freq: 1,[[item: has, freq: 1,[[item: the, freq: 1,[[item: in, freq: 1,[[item: large, freq: 1,[[item: it, freq: 1,[[item: often, freq: 1,[[item: algorithm, freq: 1,[[item: be, freq: 1,[[item: The, freq: 1,[[item: with, freq: 1,[[item: efficient, freq: 1,[[item: equal, freq: 1,[[item: all, freq: 1,[[item: algorithms, freq: 1,[[item: are, freq: 1,[[item: binary, freq: 1,[[item: single, freq: 1,[[item: but, freq: 1,[[item: as, freq: 1,[[item: most, freq: 1,[[item: on, freq: 1,[[item: at, freq: 1,[[item: not, freq: 1,[[item: each, freq: 1,[[item: In, freq: 1,[[item: some, freq: 1,[[item: a, freq: 1,[[item: two, freq: 1,[[item: computer, freq: 1,[[item: , freq: 1,[[item: )\n",
            ", freq: 1,[[item: searching, freq: 1,[[item: greater, freq: 1,[[item: return, freq: 1,[[item: <, freq: 1,[[item: 2\n",
            ", freq: 1,[[item: we, freq: 1,[[item: data, freq: 1,[[item: entire, freq: 1,[[item: 1\n",
            ", freq: 1,[[item: they, freq: 1,[[item: their, freq: 1,[[item: given, freq: 1,[[item: used, freq: 1,[[item: order, freq: 1,[[item: structure, freq: 1,[[item: \n",
            ", freq: 1,[[item: also, freq: 1,[[item: =, freq: 1,[[item: operations, freq: 1,[[item: way, freq: 1,[[item: find, freq: 1,[[item: n, freq: 1,[[item: (\n",
            ", freq: 1,[[item: within, freq: 1,[[item: ≤\n",
            ", freq: 1,[[item: allow, freq: 1,[[item: node, freq: 1,[[item: must, freq: 1,[[item: {\\displaystyle, freq: 1,[[item: complexity, freq: 1,[[item: uses, freq: 1,[[item: function, freq: 1,[[item: any, freq: 1,[[item: meaning, freq: 1,[[item: +\n",
            ", freq: 1,[[item: possible, freq: 1,[[item: structures, freq: 1,[[item: trees, freq: 1,[[item: node., freq: 1,[[item: particular, freq: 1,[[item: several, freq: 1,[[item: minimum, freq: 1,[[item: stores, freq: 1,[[item: 3, freq: 1,[[item: variable, freq: 1,[[item: following, freq: 1,[[item: 2, freq: 1,[[item: involves, freq: 1,[[item: application, freq: 1,[[item: right, freq: 1,[[item: tree,, freq: 1,[[item: b\n",
            ", freq: 1,[[item: itself, freq: 1,[[item: less, freq: 1,[[item: contains, freq: 1,[[item: science,, freq: 1,[[item: low, freq: 1,[[item: maximum, freq: 1,[[item: elements,, freq: 1,[[item: b, freq: 1,[[item: tree, freq: 1,[[item: small, freq: 1,[[item: while, freq: 1,[[item: >, freq: 1,[[item: Search, freq: 1,[[item: take, freq: 1,[[item: applied, freq: 1,[[item: end, freq: 1,[[item: specific, freq: 1,[[item: These, freq: 1,[[item: either, freq: 1,[[item: is,, freq: 1,[[item: do, freq: 1,[[item: path, freq: 1,[[item: child,, freq: 1,[[item: Binary, freq: 1,[[item: children,, freq: 1,[[item: potentially, freq: 1,[[item: maintain, freq: 1,[[item: pair, freq: 1,[[item: Each, freq: 1,[[item: high, freq: 1,[[item: ordered, freq: 1,[[item: References, freq: 1,[[item: type, freq: 1,[[item: children, freq: 1,[[item: sorted, freq: 1,[[item: necessarily, freq: 1,[[item: height, freq: 1,[[item: While, freq: 1,[[item: commonly, freq: 1,[[item: say, freq: 1,[[item: implement, freq: 1,[[item: node's, freq: 1,[[item: worst-case, freq: 1,[[item: attempt, freq: 1,[[item: left, freq: 1,[[item: test, freq: 1,[[item: blocks, freq: 1,[[item: third, freq: 1,[[item: passing, freq: 1,[[item: space., freq: 1,[[item: {\\frac, freq: 1,[[item: data,, freq: 1,[[item: string, freq: 1,[[item: advantage, freq: 1,[[item: insertion, freq: 1,[[item: length,, freq: 1,[[item: least, freq: 1,[[item: exception, freq: 1,[[item: array., freq: 1,[[item: tree., freq: 1,[[item: ==, freq: 1,[[item: whether, freq: 1,[[item: comparable, freq: 1,[[item: need, freq: 1,[[item: frequently, freq: 1,[[item: waste, freq: 1,[[item: idea, freq: 1,[[item: range, freq: 1,[[item: a\n",
            ", freq: 1,[[item: nodes,, freq: 1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(FPtree.children)\n",
        "print(FPtree.children[\"time\"].children)\n",
        "print(FPtree.children[\"time\"].children['computer'].children)\n",
        "print(FPtree.children[\"time\"].children['computer'].children[\"which\"].children)\n",
        "print(FPtree.children[\"time\"].children['computer'].children[\"which\"].children[\"number\"].children)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I29mCPbYoCD-",
        "outputId": "078edb3c-cb22-4933-a224-e55e5ac7902d"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'time': <__main__.FPTree.Node object at 0x7fcf5f8a1550>, 'other': <__main__.FPTree.Node object at 0x7fcf5f7a0590>, 'then': <__main__.FPTree.Node object at 0x7fcf5f7c9090>}\n",
            "{'computer': <__main__.FPTree.Node object at 0x7fcf5f8a13d0>}\n",
            "{'which': <__main__.FPTree.Node object at 0x7fcf5f8a1090>}\n",
            "{'number': <__main__.FPTree.Node object at 0x7fcf5f8a10d0>}\n",
            "{'search': <__main__.FPTree.Node object at 0x7fcf5f8a12d0>}\n"
          ]
        }
      ]
    }
  ]
}