Algorithms For Dummies (For Dummies (Computer/Tech))

Title Page
Copyright Page
Table of Contents
Introduction
	About This Book
	Foolish Assumptions
	Icons Used in This Book
	Beyond the Book
	Where to Go from Here
Part 1 Getting Started with Algorithms
	Chapter 1 Introducing Algorithms
		Describing Algorithms
			The right way to make toast: Defining algorithm uses
			Finding algorithms everywhere
		Using Computers to Solve Problems
			Getting the most out of modern CPUs and GPUs
			Working with special-purpose chips
			Networks: Sharing is more than caring
			Leveraging available data
		Distinguishing between Issues and Solutions
			Being correct and efficient
			Discovering there is no free lunch
			Adapting the strategy to the problem
			Describing algorithms in a lingua franca
			Facing problems that are like brick walls, only harder
		Structuring Data to Obtain a Solution
			Understanding a computer’s point of view
			Arranging data makes the difference
	Chapter 2 Considering Algorithm Design
		Starting to Solve a Problem
			Modeling real-world problems
			Finding solutions and counterexamples
			Standing on the shoulders of giants
		Dividing and Conquering
			Avoiding brute-force solutions
			Keeping it simple, silly (KISS)
			Breaking down a problem is usually better
		Learning that Greed Can Be Good
			Applying greedy reasoning
			Reaching a good solution
		Computing Costs and Following Heuristics
			Representing the problem as a space
			Going random and being blessed by luck
			Using a heuristic and a cost function
		Evaluating Algorithms
			Simulating using abstract machines
			Getting even more abstract
			Working with functions
	Chapter 3 Working with Google Colab
		Defining Google Colab
			Understanding what Google Colab does
			Getting familiar with Google Colab features
		Working with Notebooks
			Creating a new notebook
			Opening existing notebooks
			Saving notebooks
		Performing Common Tasks
			Creating code cells
			Creating text cells
			Creating special cells
			Editing cells
			Moving cells
		Using Hardware Acceleration
		Executing the Code
		Getting Help
	Chapter 4 Performing Essential Data Manipulations Using Python
		Performing Calculations Using Vectors and Matrixes
			Understanding scalar and vector operations
			Performing vector multiplication
			Creating a matrix is the right way to start
			Multiplying matrixes
			Defining advanced matrix operations
		Creating Combinations the Right Way
			Distinguishing permutations
			Shuffling combinations
			Facing repetitions
		Getting the Desired Results Using Recursion
			Explaining recursion
			Eliminating tail call recursion
		Performing Tasks More Quickly
			Considering divide and conquer
			Distinguishing between different possible solutions
	Chapter 5 Developing a Matrix Computation Class
		Avoiding the Use of NumPy
		Understanding Why Using a Class is Important
		Building the Basic Class
			Creating a matrix
			Printing the resulting matrix
			Accessing specific matrix elements
			Performing scalar and matrix addition
			Performing multiplication
		Manipulating the Matrix
			Transposing a matrix
			Calculating the determinant
			Flattening the matrix
Part 2 Understanding the Need to Sort and Search
	Chapter 6 Structuring Data
		Determining the Need for Structure
			Making it easier to see the content
			Matching data from various sources
			Considering the need for remediation
		Stacking and Piling Data in Order
			Ordering in stacks
			Using queues
			Finding data using dictionaries
		Working with Trees
			Understanding the basics of trees
			Building a tree
		Representing Relations in a Graph
			Going beyond trees
			Building graphs
	Chapter 7 Arranging and Searching Data
		Sorting Data Using Merge Sort and Quick Sort
			Understanding why sorting data is important
			Employing better sort techniques
		Using Search Trees and the Heap
			Considering the need to search effectively
			Building a binary search tree
			Performing specialized searches using a binary heap
		Relying on Hashing
			Putting everything into buckets
			Avoiding collisions
			Creating your own hash function
Part 3 Exploring the World of Graphs
	Chapter 8 Understanding Graph Basics
		Explaining the Importance of Networks
			Considering the essence of a graph
			Finding graphs everywhere
			Showing the social side of graphs
			Understanding subgraphs
		Defining How to Draw a Graph
			Distinguishing the key attributes
			Drawing the graph
		Measuring Graph Functionality
			Counting edges and vertexes
			Computing centrality
		Putting a Graph in Numeric Format
			Adding a graph to a matrix
			Using sparse representations
			Using a list to hold a graph
	Chapter 9 Reconnecting the Dots
		Traversing a Graph Efficiently
			Creating the graph
			Applying breadth-first search
			Applying depth-first search
			Determining which application to use
		Sorting the Graph Elements
			Working on Directed Acyclic Graphs (DAGs)
			Relying on topological sorting
		Reducing to a Minimum Spanning Tree
			Getting the minimum spanning tree historical context
			Working with unweighted versus weighted graphs
			Creating a minimum spanning tree example
			Discovering the correct algorithms to use
			Introducing priority queues
			Leveraging Prim’s algorithm
			Testing Kruskal’s algorithm
			Determining which algorithm works best
		Finding the Shortest Route
			Defining what it means to find the shortest path
			Adding a negative edge
			Explaining Dijkstra’s algorithm
			Explaining the Bellman-Ford algorithm
			Explaining the Floyd-Warshall algorithm
	Chapter 10 Discovering Graph Secrets
		Envisioning Social Networks as Graphs
			Clustering networks in groups
			Discovering communities
		Navigating a Graph
			Counting the degrees of separation
			Walking a graph randomly
	Chapter 11 Getting the Right Web page
		Finding the World in a Search Engine
			Searching the Internet for data
			Considering how to find the right data
		Explaining the PageRank Algorithm
			Understanding the reasoning behind the PageRank algorithm
			Explaining the nuts and bolts of PageRank
		Implementing PageRank
			Implementing a Python script
			Struggling with a naive implementation
			Introducing boredom and teleporting
			Looking inside the life of a search engine
			Considering other uses of PageRank
		Going Beyond the PageRank Paradigm
			Introducing semantic queries
			Using AI for ranking search results
Part 4 Wrangling Big Data
	Chapter 12 Managing Big Data
		Transforming Power into Data
			Understanding Moore’s implications
			Finding data everywhere
			Getting algorithms into business
		Streaming Flows of Data
			Analyzing streams with the right recipe
			Reserving the right data
		Sketching an Answer from Stream Data
			Filtering stream elements by heart
			Demonstrating the Bloom filter
			Finding the number of distinct elements
			Learning to count objects in a stream
	Chapter 13 Parallelizing Operations
		Managing Immense Amounts of Data
			Understanding the parallel paradigm
			Distributing files and operations
			Employing the MapReduce solution
		Working Out Algorithms for MapReduce
			Setting up a MapReduce simulation
			Inquiring by mapping
	Chapter 14 Compressing and Concealing Data
		Making Data Smaller
			Understanding encoding
			Considering the effects of compression
			Choosing a particular kind of compression
			Choosing your encoding wisely
			Encoding using Huffman compression
			Remembering sequences with LZW
		Hiding Your Secrets with Cryptography
			Substituting characters
			Working with AES encryption
Part 5 Challenging Difficult Problems
	Chapter 15 Working with Greedy Algorithms
		Deciding When It Is Better to Be Greedy
			Understanding why greedy is good
			Keeping greedy algorithms under control
			Considering NP complete problems
		Finding Out How Greedy Can Be Useful
			Arranging cached computer data
			Competing for resources
			Revisiting Huffman coding
	Chapter 16 Relying on Dynamic Programming
		Explaining Dynamic Programming
			Obtaining a historical basis
			Making problems dynamic
			Casting recursion dynamically
			Leveraging memoization
		Discovering the Best Dynamic Recipes
			Looking inside the knapsack
			Touring around cities
			Approximating string search
	Chapter 17 Using Randomized Algorithms
		Defining How Randomization Works
			Considering why randomization is needed
			Understanding how probability works
			Understanding distributions
			Simulating the use of the Monte Carlo method
		Putting Randomness into your Logic
			Calculating a median using quick select
			Doing simulations using Monte Carlo
			Ordering faster with quick sort
	Chapter 18 Performing Local Search
		Understanding Local Search
			Knowing the neighborhood
		Presenting local search tricks
			Explaining hill climbing with n-queens
			Discovering simulated annealing
			Avoiding repeats using Tabu Search
		Solving Satisfiability of Boolean Circuits
			Solving 2-SAT using randomization
			Implementing the Python code
			Realizing that the starting point is important
	Chapter 19 Employing Linear Programming
		Using Linear Functions as a Tool
			Grasping the basic math you need
			Learning to simplify when planning
			Working with geometry using simplex
			Understanding the limitations
		Using Linear Programming in Practice
			Setting up PuLP at home
			Optimizing production and revenue
	Chapter 20 Considering Heuristics
		Differentiating Heuristics
			Considering the goals of heuristics
			Going from genetic to AI
		Routing Robots Using Heuristics
			Scouting in unknown territories
			Using distance measures as heuristics
		Explaining Path Finding Algorithms
			Creating a maze
			Looking for a quick best-first route
			Going heuristically around by A*
Part 6 The Part of Tens
	Chapter 21 Ten Algorithms That Are Changing the World
		Using Sort Routines
		Looking for Things with Search Routines
		Shaking Things Up with Random Numbers
		Performing Data Compression
		Keeping Data Secret
		Changing the Data Domain
		Analyzing Links
		Spotting Data Patterns
		Dealing with Automation and Automatic Responses
		Creating Unique Identifiers
	Chapter 22 Ten Algorithmic Problems Yet to Solve
		Solving Problems Quickly
		Solving 3SUM Problems More Efficiently
		Making Matrix Multiplication Faster
		Determining Whether an Application Will End
		Creating and Using One-Way Functions
		Multiplying Really Large Numbers
		Dividing a Resource Equally
		Reducing Edit Distance Calculation Time
		Playing the Parity Game
		Understanding Spatial Issues
Index
EULA