# Appendix A: Review of Necessary Mathematics
Except for the material that is marked![](https://box.kancloud.cn/87b73a0cb58b36071f716933fe76096c_26x25.jpg) or ![](https://box.kancloud.cn/576b90f1492785a824314dfb25ca815f_24x28.jpg) this text does not require that you have a strong background in mathematics. In particular, it is not assumed that you have studied calculus. However, a certain amount of mathematics is necessary for the analysis of algorithms. This appendix reviews that necessary mathematics. You may already be familiar with much or all of this material.
## A.1 Notation
Sometimes we need to refer to the smallest integer that is greater than or equal to a real number *x*. We denote that integer by ⌈*x*⌉. For example,
![](https://box.kancloud.cn/3cd98dfa6caff573dbecc592356fedbf_365x72.jpg)
We call ⌈*x*⌉ the ***ceiling*** for *x*. For any integer *n*, ⌈*n*⌉ = *n*. We also sometimes need to refer to the largest integer that is less than or equal to a real number *x*. We denote that integer by ⌊*x*⌋. For example,
![](https://box.kancloud.cn/904245e0411ff9cd165be2e2b10e4daa_366x73.jpg)
We call ⌊*x*⌋ the ***floor*** for *x*. For any integer *n*, ⌊*n*⌋ = *n*.
When we are able to determine only the approximate value of a desired result, we use the symbol ≇, which means "equals approximately." For example, you should be familiar with the number π, which is used in the computation of the area and circumference of a circle. The value of π is not given by any finite number of decimal digits because we could go on generating more digits forever. (Indeed, there is not even a pattern as there is in ⅓ = 0.3333333….) Because the first six digits of π are 3.14159, we write
![](https://box.kancloud.cn/d337304b8389cdd0a899fae420fa126f_101x16.jpg)
We use the symbol ≠ to mean "does not equal." For example, if we want to state that the values of the variables *x* and *y* are not equal, we write
![](https://box.kancloud.cn/6d39eabf515bd028ad3a097e6c0ea144_51x20.jpg)
Often we need to refer to the sum of like terms. This is straightforward if there are not many terms. For example, if we need to refer to the sum of the first seven positive integers, we simply write
![](https://box.kancloud.cn/a908293b82bf9e9e3c55f9ad472294db_201x16.jpg)
If we need to refer to the sum of the squares of the first seven positive integers, we simply write
![](https://box.kancloud.cn/00eb7ab109cc84c306e8841d48360600_257x22.jpg)
This method works well when there are not many terms. However, it is not satisfactory if, for example, we need to refer to the sum of the first 100 positive integers. One way to do this is to write the first few terms, a general term, and the last term. That is, we write
![](https://box.kancloud.cn/b74f9a23ab463576c4cbddf386ea09b3_208x18.jpg)
If we need to refer to the sum of the squares of the first 100 positive integers, we could write
![](https://box.kancloud.cn/5dd7fc90a32c0d6d0557f631954a1ad7_241x21.jpg)
Sometimes when the general term is clear from the first few terms, we do not bother to write that term. For example, for the sum of the first 100 positive integers we could simply write
![](https://box.kancloud.cn/6343cc3087dfb17f94658b54b089c605_138x16.jpg)
When it is instructive to show some of the terms, we write out some of them. However, a more concise method is to use the greek letter Σ, which is pronounced ***sigma***. For example, we use Σ to represent the sum of the first 100 positive integers as follows:
![](https://box.kancloud.cn/1f5c9eaf66d64a2ed7ccd4dd5be0258c_39x56.jpg)
This notation means that while the variable *i* is taking values from 1 to 100, we are summing its values. Similarly, the sum of the squares of the first 100 positive integers can be represented by
![](https://box.kancloud.cn/35c3ce827a579934bd942727c7380d96_48x56.jpg)
Often we want to denote the case in which the last integer in the sum is an arbitrary integer *n*. Using the methods just illustrated, we can represent the sum of the first *n* positive integers by
![](https://box.kancloud.cn/03c8b366d256dd2dd85e4a174189f897_313x53.jpg)
Similarly, the sum of the squares of the first *n* positive integers can be represented by
![](https://box.kancloud.cn/8b4661ea3106d148e375fa213c3d8d71_353x54.jpg)
Sometimes we need to take the sum of a sum. For example,
![](https://box.kancloud.cn/6c26c90aed2d10e5cdbd66c092684252_400x74.jpg)
Similarly, we can take the sum of a sum of a sum, and so on.
Finally, we sometimes need to refer to an entity that is larger than any real number. We call that entity ***infinity*** and denote it by ∞. For any real number *x*, we have
![](https://box.kancloud.cn/d3a832c6d11ad81616ec8d54ca514384_61x15.jpg)
- Table of Contents
- BackCover
- Foundations of Algorithms Using C++ Pseudocode, Third Edition
- Preface
- Chapter Contents
- Pedagogy
- Course Outlines
- Acknowledgments
- Errors
- Chapter 1: Algorithms - Efficiency, Analysis, and Order
- 1.2 The Importance of Developing Efficient Algorithms
- 1.3 Analysis of Algorithms
- 1.4 Order
- 1.5 Outline of This Book
- Exercises
- Chapter 2: Divide-and-Conquer
- 2.1 Binary Search
- 2.2 Mergesort
- 2.3 The Divide-and-Conquer Approach
- 2.4 Quicksort (Partition Exchange Sort)
- 2.5 Strassen's Matrix Multiplication Algorithm
- 2.6 Arithmetic with Large Integers
- 2.7 Determining Thresholds
- 2.8 When Not to Use Divide-and-Conquer
- Exercises
- Chapter 3: Dynamic Programming
- 3.1 The Binomial Coefficient
- 3.2 Floyd's Algorithm for Shortest Paths
- 3.3 Dynamic Programming and Optimization Problems
- 3.4 Chained Matrix Multiplication
- 3.5 Optimal Binary Search Trees
- 3.6 The Traveling Salesperson Problem
- Exercises
- Chapter 4: The Greedy Approach
- 4.1 Minimum Spanning Trees
- 4.2 Dijkstra's Algorithm for Single-Source Shortest Paths
- 4.3 Scheduling
- 4.4 Huffman Code
- 4.5 The Greedy Approach versus Dynamic Programming: The Knapsack Problem
- Exercises
- Chapter 5: Backtracking
- 5.2 The n-Queens Problem
- 5.3 Using a Monte Carlo Algorithm to Estimate the Efficiency of a Backtracking Algorithm
- 5.4 The Sum-of-Subsets Problem
- 5.5 Graph Coloring
- 5.6 The Hamiltonian Circuits Problem
- 5.7 The 0-1 Knapsack Problem
- Exercises
- Chapter 6: Branch-and-Bound
- 6.1 Illustrating Branch-and-Bound with the 0 - 1 Knapsack problem
- 6.2 The Traveling Salesperson Problem
- 6.3 Abductive Inference (Diagnosis)
- Exercises
- Chapter 7: Introduction to Computational Complexity - The Sorting Problem
- 7.2 Insertion Sort and Selection Sort
- 7.3 Lower Bounds for Algorithms that Remove at Most One Inversion per Comparison
- 7.4 Mergesort Revisited
- 7.5 Quicksort Revisited
- 7.6 Heapsort
- 7.6.1 Heaps and Basic Heap Routines
- 7.6.2 An Implementation of Heapsort
- 7.7 Comparison of Mergesort, Quicksort, and Heapsort
- 7.8 Lower Bounds for Sorting Only by Comparison of Keys
- 7.8.1 Decision Trees for Sorting Algorithms
- 7.8.2 Lower Bounds for Worst-Case Behavior
- 7.8.3 Lower Bounds for Average-Case Behavior
- 7.9 Sorting by Distribution (Radix Sort)
- Exercises
- Chapter 8: More Computational Complexity - The Searching Problem
- 8.1 Lower Bounds for Searching Only by Comparisons of Keys
- 8.2 Interpolation Search
- 8.3 Searching in Trees
- 8.4 Hashing
- 8.5 The Selection Problem: Introduction to Adversary Arguments
- Exercises
- Chapter 9: Computational Complexity and Interactability - An Introduction to the Theory of NP
- 9.2 Input Size Revisited
- 9.3 The Three General Problem Categories
- 9.4 The Theory of NP
- 9.5 Handling NP-Hard Problems
- Exercises
- Chapter 10: Number-Theoretic Algorithms
- 10.1 Number Theory Review
- 10.2 Computing the Greatest Common Divisor
- 10.3 Modular Arithmetic Review
- 10.4 Solving Modular Linear Equations
- 10.5 Computing Modular Powers
- 10.6 Finding Large Prime Numbers
- 10.7 The RSA Public-Key Cryptosystem
- Exercises
- Chapter 11: Introduction to Parallel Algorithms
- 11.1 Parallel Architectures
- 11.2 The PRAM Model
- Exercises
- Appendix A: Review of Necessary Mathematics
- A.2 Functions
- A.3 Mathematical Induction
- A.4 Theorems and Lemmas
- A.5 Logarithms
- A.6 Sets
- A.7 Permutations and Combinations
- A.8 Probability
- Exercises
- Appendix B: Solving Recurrence Equations - With Applications to Analysis of Recursive Algorithms
- B.2 Solving Recurrences Using the Characteristic Equation
- B.3 Solving Recurrences by Substitution
- B.4 Extending Results for n, a Power of a Positive Constant b, to n in General
- B.5 Proofs of Theorems
- Exercises
- Appendix C: Data Structures for Disjoint Sets
- References
- Index
- Index_B
- Index_C
- Index_D
- Index_E
- Index_F
- Index_G
- Index_H
- Index_I
- Index_J
- Index_K
- Index_L
- Index_M
- Index_N
- Index_O
- Index_P
- Index_Q
- Index_R
- Index_S
- Index_T
- Index_U
- Index_V
- Index_W-X
- Index_Y
- Index_Z
- List of Figures
- List of Tables
- List of Algorithms, Examples, and Theorems
- List of Sidebars