Outline

• Using Slidy
• Probabilistic Analysis - The Hiring Problem
• Review Probability

Using Slidy

• The slides for this class are HTML files.
• They are made to look like slides using a Javascript called Slidy.
• The following keystrokes do useful things in Slidy:
  • h - help (see all the commands)
  • f - fullscreen (gets rid of the links at the bottom of the window
  • space - advance a slide
  • left/right arrows - forward or back a slide
  • up/down arrows - scroll within a slide
  • a - show all slides at once for printing

The Hiring Problem

We will now begin our investigation of randomized algorithms with a toy problem:

• You want to hire an office assistant from an employment agency.
• You want to interview candidates and determine if they are better than the current assistant and if so replace the current assistant.
• You are going to eventually interview every candidate from a pool of `n` candidates.
• You want to always have the best person for this job, so you will replace an assistant with a better one as soon as you are done the interview.
• However, there is a cost to fire and then hire someone.
• You want to know the expected price of following this strategy until all `n` candidates have been interviewed.

Pseudo-Code

Hire-Assistant(n)
1 best := dummy candidate
2 for i := 1 to n
3     do interview of candidate i
4         if i is better than best
5             best := i
6             hire candidate i

Total Cost and Cost of Hiring

• Interviewing has a low cost `c_i`.
• Hiring has a high cost `c_h`.
• Let `n` be the number of candidates to be interviewed and let `m` be the number of people hired.
• The total cost then goes as `O(n cdot c_i+m cdot c_h)`
• The number of candidates is fixed so the part of the algorithm we want to focus on is the `m cdot c_h` term.
• This term governs the cost of hiring.

Worst-case Analysis

• In the worst case, everyone we interview turns out to be better than the person we currently have.
• In this case, the hiring cost for the algorithm will be `O(n cdot c_h)`.
• This bad situation presumably doesn't typically happen so it is interesting to ask what happens in the average case.

Probabilistic analysis

• Probabilistic analysis is the use of probability to analyze problems.
• One important issue is what is the distribution of inputs to the problem?
• For instance, we could assume all orderings of candidates are equally likely.
• That is, we consider all functions rank: `[1..n] |-> [1..n]` where `rank[i]` is supposed to be the `i`th candidate that we interview. So `langle rank(1), rank(2), ...rank(n) rangle` should be a permutation of of `langle 1,...,n rangle`.
• There are `n!` many such permutations and we want each to be equally likely.
• If this is the case, the ranks form a uniform random permutation.

Randomized algorithms

• In order to use probabilistic analysis, we need to know something about the distribution of the inputs.
• Unfortunately, often little is known about this distribution.
• We can nevertheless use probability and analysis as a tool for algorithm design by having the algorithm we run do some kind of randomization of the inputs.
• This could be done with a random number generator.
• For example, we could assume we have primitive function Random(a,b) which returns an integer between integers a and b inclusive with equally likelihood.
• Algorithms which make use of such a generator are called randomized algorithms.
• In our hiring example we could try to use such a generator to create a random permutation of the input and then run the hiring algorithm on that.

Distributions

To do probabilistic analysis and to understand randomized algorithms, we need to know a little probability -- so let's review.

• A sample space `S` will for us be some collection on elementary events. For instance, results of coin flips.
• An event `E` is any subset of `S`.
• For example, if `S={HH, TH, HT, T\T}`, an event might be `{TH, HT}`
• A probability distribution `Pr_S{}` on `S` is a mapping from events on `S` to the real numbers satisfying for any events `A` and `B`:
  1. `Pr_S{A} ge 0`
  2. `Pr_S{S} = 1`
  3. `Pr_S{A cup B} = Pr_S{A} + Pr_S{B}` if `A cap B= emptyset`
• Notice `1 = Pr_S{S cup emptyset} = Pr_S{S} + Pr_S{emptyset} = 1 + Pr_S{emptyset}`. So `Pr_S{emptyset} = 0`.
• Let `bar(A)` denote the complement of `A` in `S` -- all the elements of `S` that are not in `A`.
• Notice `1 = Pr_S{S}= Pr_S{bar(A) cup A} = Pr_S{bar(A)} + Pr_S{A}`. So `Pr_S{bar(A)} = 1 - Pr_S{A}`.