1. More Mathematical Techniques

2. Special Number Sequences
Fibonacci numbers
Fib(0) = 0, Fib(1) = 1, Fib(n) = Fib(n-1)+Fib(n-2)
Dynamic Programming is usually used
But, there are faster methods – matrix powers
Sometimes require Java Bigints to use
Zeckendorf’s Theorem:
Every positive integer can be written as a sum of Fibonacci numbers, no two of which are consecutive.
Can determine this greedily – choosing largest possible at each step
Pisano Period
Last digit/Last 2 digits/Last 3 digits/Last 4 digits repeat with period 60/300/1500/15000

3. Special Number Sequences
Binomial Coefficients
Coefficients of powers of a binomial (x+y)n
kth coefficient is C(n,k) – i.e. n choose k – which is n!/[(n-k)!k!]
Notice C(n,k) = C(n,n-k)
Can find with Pascal’s Triangle
Row 1 is 1
Row 2 is 1 1
Row 3 is 1 2 1
Row 4 is
Each row is 1 longer. End values are 1, those in middle are sum of 2 above it
Good if need all numbers
Can use a Dynamic Programming approach:
C(n, k) = C(n-1,k-1) + C(n-1,k)
Good if you need most but not all numbers.

4. Special Number Sequences
Catalan Numbers
Cat(n) = C(2n,n)/(n+1) Cat(0) = 1
Cat(n+1) = Cat(n) * [(2n+2)(2n+1)]/[(n+2)(n+1)]
Useful for several problems:
Number of distinct binary trees with n vertices
Number of expressions containing n pairs of parentheses that are correctly matched
Number of ways n+1 factors can be parenthesized fully
Number of ways a convex polygon with n+2 sides can be triangulated
Number of monotonic paths on an nxn grid that don’t pass diagonal

5. Prime Numbers To test if a number is prime
Could check divisibility by all numbers < sqrt(n)
Could check divisibility by all ODD numbers < sqrt(n)
Could check divisibility by all PRIME numbers < sqrt(n)
To generate primes, could repeatedly test, then add on to list as new ones are found
Useful if you just are testing one number, and it’s large.
Or, use Sieve of Erastothenes to find all primes in some range
Mark all numbers as primes to start; start pointer at 1
Repeat:
Pick next prime number (on first iteration, this will be 2, then 3, then 5)
Mark all multiples of that number as not prime (increment by that amount, marking not prime)

6. GCD and LCM GCD: gcd(a,b) LCM: lcm(a,b) Use Euclid’s algorithm
If b == 0, return a, otherwise:
return gcd(b, a%b)
Notice that gcd(a,b,c) = gcd(a,gcd(b,c)), etc.
LCM: lcm(a,b)
calculate lcm(a,b) = a*(b/gcd(a,b))
Notice you wan to divide by gcd first, to avoid intermediate overflow

7. Extended Euclid Algorithm
Can tell x, y in a Diophantine equation: ax + by = c
d = gcd(a,b). d must divide c
First solution via extended Euclid algorithm Euclid(a,b):
If b == 0, x=1, y=0, d = a
extendedEuclid(b, a%b)
x1 = y
y1 = x – (a/b)*y
x=x1
y=y1
That gives only the first (of an infinite number) valid solution, x0, y0
Others are x = x0 + (b/d) n; y =y0 + (a/d) n

8. Combinatorics See the discussion earlier about binomial coefficients
Choosing k objects from a set of n: C(n, k)
Number of ways to permute objects = n!
Note: factorial can only be computed to ~20!, and that’s with long longs
So, must cancel out factorials when possible.
Number of permutations on n objects where there are more than one with same value: n!/[n1! n2! n3!...nk!]
Choose k objects from n, but allow k to be chosen more than once
C(n+k-1, k)

9. Combinatorics examples
Given an nxm grid, how many rectangles can be made on the grid?
Choose 2 vertical lines, choose 2 horizontal lines, then all combinations
C(n,2)*C(m,2)
Divide k balls into n boxes
C(n+k-1, k)
How many paths on a lattice from lower left to upper right, assuming monotonic
Use Dynamic Programming: 1 way to get to (0,0) and each (i,0) and (0, j)
Then, paths to (i,j) = paths to (i-1, j) plus paths to (i, j-1)

10. Finding Repeating Cycles
Sometimes you have a sequence in which the sequence begins repeating.
Want to find point at which the repeating sequences start: This is m
Want to find the length of the sequence. This is l
Can store each value computed. Then, when new value is generated, see if you already found it.
If you need the actual value when first found, store in a map.
Value gives m, can subtract from current value to get l
If you just need to know if a repetition exists, store in a set.

11. Floyd’s Cycle-Finding
Notice that if l is the cycle length, then for i > m, xi = xi+kl
Just let kl = i. SO, xi = x2i
Can iterate two pointers: a lower one that increases by 1 per step, and an upper one that increases by 2 per step
When the two values match, you have i, 2i. So kl = i.
To find m, start one pointer at i, and one at beginning. Then, increment them both by 1. When they match, the first is at m.
Finally, you can get l by setting one pointer to m and one to m+1, then increment the bigger pointer until it matches m. That difference is l.

12. Game Playing
Can determine who will win a (simple) game by exploring the game space.
Use a minimax tree.
Generate possible moves at each level
Player 1 will pick the best from available choices (win if possible)
Player 2 will pick the worst move from player 1’s perspective (i.e. make player 1 lose if possible)
If each plays optimally, who will win?
Can determine if you explore entire tree, or enough to ensure a choice is known at any level
In real games (probably not contest), you can use alpha-beta pruning to speed things up.