Randomized Algorithms (Spring 2010)/Problem Set 1

2010-03-28T12:02:33Z

172.25.50.3: /* Problem 0 (10 points) */

刘正 MF0933021

==Problem 1 (10 points)==
[MR]-1.1

* Suppose that you are given a coin for which the probability of HEADS, say <math>p</math>, is ''unknown''. How can you use this coin to generate unbiased (i.e., <math>\Pr[\mathrm{HEADS}]=\Pr[\mathrm{TAILS}]=1/2</math>) coin-flips? Give a scheme for which the expected number of flips of the biased coin for extracting one unbiased coin-flip is no more than <math>\frac{1}{p(1-p)}</math>.

:('''Hint''': Consider two consecutive flips of the biased coin.)

* (Bonus problem) Devise an extension of the scheme that extracts the largest possible number of independent, unbiased coin-flips from a given number of flips of the biased coin.

==Problem 2 (10 points)==
The original Karger's algorithm returns a min-cut with probability <math>\ge\frac{2}{n(n-1)}</math> after <math>n-2</math> contractions.
We have seen that by running the original Karger's algorithm for multiple times, the probability of success can be improved. Consider the following variation. Starting with a graph with <math>n</math> vertices, first contract the graph down to <math>k</math> vertices using Karger's algorithm. Make <math>\ell</math> copies of the graph with <math>k</math> vertices, and now run Karger's algorithm independently on these <math>\ell</math> copies. Return the smallest returned cut of these <math>\ell</math> instances.
* What is the total number of contractions?
* What is the probability of finding a min-cut?
* Try to optimize the probability of success subject to the constraint of using no more than <math>2n</math> contractions.

==Problem 3 (10 points)==
Recall the following definitions:
{|border="1"
|'''Definition 2:''' The class '''NP''' consists of all decision problems <math>f</math> that have a polynomial time deterministic algorithm <math>V</math> such that for any input <math>x</math>,
:<math>f(x)=1</math> if and only if <math>\exists y</math>, <math>V(x,y)=1</math>, where the size of <math>y</math> is within polynomial of the size of <math>x</math>.
|}

{|border="1"
|'''Definition 4:''' The class '''ZPP''' consists of all decision problems <math>f</math> that have a randomized algorithm <math>A</math> running in expected polynomial time for any input such that for any input <math>x</math>, <math>A(x)=f(x)</math>.
|}

{|border="1"
|'''Definition 5:''' The class '''RP''' consists of all decision problems <math>f</math> that have a randomized algorithm <math>A</math> running in worst-case polynomial time such that for any input <math>x</math>,
*if <math>f(x)=1</math>, then <math>\Pr[A(x)=1]\ge 1-1/2</math>;
*if <math>f(x)=0</math>, then <math>\Pr[A(x)=0]=1</math>.
|}

Prove that '''ZPP'''<math>\subseteq</math>'''NP''' and '''RP'''<math>\subseteq</math>'''NP'''.

('''Hint''': Notice that a randomized algorithm <math>A</math> on input <math>x</math> can be represented as a deterministic algorithm <math>D</math> with two inputs: <math>x</math> and a sequence <math>s</math> of random bits.)

==Problem 4 (10 points)==
A parallel computer consists of <math>n</math> processors and <math>n</math> memory modules. During a step, each processor sends a memory request to one of the memory modules, and each memory modul answer the request if it receives exactly one request. Note that a memory module may receive more than one requests. There are two schemes for dealing with conflicted memory requests:
# Upon receiving more than one requests, a memory module does not answer any request.
# Upon receiving more than one requests, a memory module answers one of the received requests.
Assuming that each processor sends a request to a memory module chosen uniformly and independently at random:
:(a) with the first scheme, what is the expected number of processors whose requests are answered?
:(b) with the second scheme, what is the expected number of processors whose requests are answered?
:(c) We upgrade the memory of the machine, so that a memory module that receives either one or two requests can answer its request(s); modules that receive more than two requests will answer two requests and discard the rest. What is the expected number of processors whose requests are answered?

(You may assume the approximation <math>\left(1-\frac{1}{n}\right)^n\approx\frac{1}{e}</math>.)

TCS Wiki - User contributions [en]

Randomized Algorithms (Spring 2010)/Problem Set 1