Homework Spring 2009

• Monday January 12
• Do a search on the web for "google interview questions" and "microsoft interview questions". List the 3 most algorithmically intersesting examples of purported interview questions that you find. Try the problem that you think is most interesting, and either give your solution, or if you didn't solve the problem, some of your thoughts on the problem. The grading will be more on interestingness of the problems than on the correctness of your solution. So it will not profit you to solve a simple/boring problem.

• Wednesday January 14
  
 
• Problem 3-3 part a
• Problem 3-4

• Friday Janaury 16
• Consider the following definitions for f(n, m) = O(g(n, m))
  • there exists positive constants c, n_0, m_0 such that 0<= f(n, m) <= c * g(n, m) for all (n, m) such that n >= n_0 AND m >= m_0
  • there exists positive constants c, n_0, m_0 such that 0<= f(n, m) <= c * g(n, m) for all (n, m) such that n >= n_0 OR m >= m_0
  • There exists a constant c> 0 such that lim sup_{n -> infinity} lim sup_{m -> infinity} f(n,m)/g(n, m) < c
  • Note that this means that you first take the limit superior with respect to m. The result will be a function of just n. You then take the limit superior of this function with respect to n.
    
  • There exists a constant c> 0 such that lim sup_{m -> infinity} lim sup_{n -> infinity} f(n,m)/g(n, m) < c
  • Note that on the surface that this definition is different than the last on in that the order that you take the limits is switched.
    
  • There exists a constant c> 0 such that for all but finitely many pairs (m, n) it is the case that f(n,m) < c * g(n, m)

  State which definitions are equivalent. Fully justify your answers. Argue about which definition you think is the best one.

• Wednesday January 21 (All proofs of correctness must use an exchange argument)
  
• Consider the problem from section 16.5 in the text except that now each job i has a release time r_i, and job i can not be executed before time r_i. Consider the collection of jobs, along with the subsets of jobs that may be feasibly scheduled. Prove or disprove that this is a matroid.
• You have n jobs where each job has a nonnegative integer release time, and a positive processing time. Consider the greedy algorithm SRPT that starts scheduling jobs from earlier in time to later in time that at each integer time schedules the released ob with the least remaining unprocessed portion left. So this schedule with be preemptive. Prove or disprove that SRPT computes the scheduling with the minimum average response time. Where the response time of a job is the time between when it is released and when it is finished.
• You have n jobs where each job has a nonnegative integer release time,  and a positive processing time. Consider the greedy algorithm SRPT that starts scheduling jobs from earlier in time to later in time that at each integer time schedules the released job with the least remaining unprocessed portion left. So this schedule with be preemptive. Prove or disprove that SRPT computes the scheduling with the minimum slowdown. Where the slowdown of a job is its response time divided by its processing time.
• You have n jobs where each job has a nonnegative integer release time,  a positive processing time and a nonnegative deadline. Consider the greedy algorithm EDF that starts scheduling jobs from earlier in time to later in time that at each integer time schedules the released unfinished job with the earliest deadline. So this schedule with be preemptive. Prove or disprove that EDF finishes each job by its deadline if it is possible to do so.
• You have n jobs where each job has a nonnegative integer release time,  a positive processing time and a nonnegative deadline. Consider the greedy algorithm LLF that starts scheduling jobs from earlier in time to later in time that at each integer time schedules the released unfinished job with the least laxity. The laxity of a job is how many times slots that it does not have to run between the current time and the deadline and can still finish by its deadline. So this schedule with be preemptive. Prove or disprove that LLF finishes each job by its deadline if it is possible to do so.
• You have n jobs where each job has a nonnegative integer release time,  a positive processing time and a nonnegative deadline. Consider the greedy algorithm EDF that starts scheduling jobs from earlier in time to later in time that at each integer time schedules the released, unfinished, non-negative laxity job, with the earliest deadline. So this schedule with be preemptive. Prove or disprove that EDF minimizes the number of jobs that miss their deadline.
  

• Friday January 23
• 15-2
• 15-3

• Monday January 26
  
• 15-1
• 15-7
• Consider the following auction problem. You have n bidders. Bidder i submitted a bid b_i and a seat count c_i. That is they are willing to pay up to b_i dollars to buy c_i tickets to some event.  Given this information you want to assign a price p_i to each person. A person will buy if and only if p_i <= b_i.  You also need that your pricing is monotone in the seat count. So if c_i <= c_j then you must guarantee that p_i <= p_j. Otherwise customers will complain about unfairness. Given these constraints, you want to maximize the profit (which is the sum of the prices that you set). Give an algorithm whose running time is polynomial in n.
• Consider the following auction problem. You have n bidders. Bidder i submitted a bid b_i and a seat count c_i. That is they are willing to pay up to b_i dollars to buy c_i tickets to some event. There is a limit C on the number of seats that you can sell. Given this information you want to assign a price p_i to each person. A person will buy if and only if p_i <= b_i. You need that the total number of bought seats can be at most C. You also need that your pricing is monotone in the seat count. So if c_i <= c_j then you must guarantee that p_i <= p_j. Otherwise customers will complain about unfairness. Given these constraints, you want to maximize the profit (which is the sum of the prices that you set). Give an algorithm whose running time is polynomial in n and C.

• Wednesday January 28
• Give a polynomial time algorithm for the following problem. The input consists of a sequence R = R0, . . . ,Rn of non-negative integers, and an integer k. The number Ri represents the number of users requesting some particular piece of information at time i ( say from a www server. If the server broadcasts this information at some time t, the the requests of all the users who requested the information strictly before time t are satisfied. The server can broadcast this information at most k times. The goal is to pick the k times to broadcast in order to minimize the total time (over all requests) that requests/users have to wait in order to have their requests satisfied.
  
• As an example, assume that the input was R = 3, 4, 0, 5, 2, 7 (so n = 6) and k = 3. Then one possible solution (there is no claim that this is the optimal solution) would be to broadcast at times 2, 4, and 7 (note that it is obvious that in every optimal schedule that there is a broadcast at time n + 1 if Rn 6= 0). The 3 requests at time 1 would then have to wait 1 time unit. The 4 requests at time 2 would then have to wait 2 time units. The 5 requests at time 4 would then have to wait 3 time units.The 2 requests at time 5 would then have to wait 2 time units. The 7 requests at time 6 would then have to wait 1 time units. Thus the total waiting time for this solution would be 3 ∗ 1 + 4 ∗ 2 + 5 ∗ 3 + 2 ∗ 2 + 7 ∗ 1
• This problem is the same as the last one, accept now that we are assuming that the web server contains more than one page. Let there are m pages. So the input is m*n integers, specifying for each of the m times how many requests are made to each page, and an integer k specifying how many broadcasts the server can make in total. Give a polynomial time algorithm to compute when to broadcast so as to minimize the total waiting time.  (€)
  

• Friday January 30
• 28.2-3
• 28.2-4
• 4-4 all parts except part d and part f. Use the master theorem wherever possible (make sure to read the restrictions on when the master theorem can be applied.)    (€)
• Consider the Knapsack problem that was discussed in class. 
  
• Explain how one can actually find the highest valued subset of objects, subject to the weight
  constraint, in time O(n L) and space O(nL). Here n is the number of items and L is the weight constraint.
• Explain how to solve the Knapsack problem using only O(L) memory/space and O(nL) time. You
  need only find the value and weight of the optimal solution, not the actual collection of objects.
• Our goal is now to consider the Knapsack problem, and develop a method for computing the actual
  items to be taken in O(L) space and O(nL) time.
• Consider the following problem. The input is the same as for the knapsack problem, a collection
  of n items I1, . . . , In with weights w1, . . . , wn, and values v1, . . . , vn, and a weight limit L. The
  output is in two parts. First you want to compute the maximum value of a subset S of the n
  items that has weight at most L, as well as the weight of this subset. Let us call this value and
  weight va and wa. Secondly for this subset S you want to compute the weight and value of the
  items in {I1, . . . , In/2} that are in S. Let use call this value and weight vb and wb. So your output
  will be two weights and two values. Give an algorithm for this problem that uses space O(L) and
  time O(nL).
•  Explain how to use the algorithm from the previous subproblem to get a divide and conquer
  algorithm for finding the items in the Knapsack problem a and uses space O(L) and time O(nL).

• Monday February 2
• 4-4 parts d and f. You must use induction
• A collection S of n points in an n by n grid are happy if for each pair of points (x_1, y_1) and (x_2, y_2) in S, there is another point on or in the rectangle where (x_1, y_1) and (x_2, y_2) are opposite corners. By saying that they are on the n by n grid, that means that both coordinates are integers in the range [1, n]. Show that for every set S in the n by n grid, there is a superset T of S such that T is happy, T is contained in the n by n grid, and T contains at most n log n more points than S.  You must give a solution using divide and conquer.  (€)
• Assume you are given a balanced complete binary tree with n nodes. Explain how to map the nodes to an O( sqrt(n)) by O(sqrt(n) ) grid such that the edges from the tree are mapped to non-overlapping axis-parallel straight paths in the grid. You must give a solution using divide and conquer.  (€)
• Assume that you have a linked list of n items and n processors. Each processor has the address of an unique record in the list. Assume that each record as some reasonable extra space for you to use in your computations. Give a log n time algorithm to convert this linked list into an array.  Note that each processor does not a priori know the position in the list of the record that it has a pointer for.
  
• Assume that you have a binary search tree with n items and n nodes. Each processor has the address of an unique record in the tree. Assume each node has a reasonable amount of extra space that you can use. Give a log n time algorithm to compute the depth of each node. For concreteness, say you should write the depth in some field in each node.
• Hint: First convert the tree to a list where each item is listed in the order it would be visited if the tree was a wall and you walked around the outside. Then use the idea from the previous problem.
  

• Wednesday February 4
  
• Problem 14-2
  
• Exercise 14.1-8 (€)

• Friday February 6  (email to Christine by 2:30 if we do not have class)
  
• 8.1-3 (€)
• 8.1-4
• 4-6 (€)
  

• Monday February 9
• 8-6 parts a and b. Then give an adversarial argument that proves an 2n-1 lower bound. Ignore parts c and d, they are more misleading than helpful.  (€)
• I proved in class that time-unaware deterministic processes can not guarantee agreement on  a bit to commit to if even one process can crash. Here we assumed that if all the input bits were the same, the processes would have to agree to that value. Recall that the proof had three parts. A configuration is labeled with the bit 0 (1) if there is a legal future where the processes agree to the bit 0 (1). In the first part, I argued that there is some possible initial configuration labeled by both 0 and 1. In the second part, we fixed this initial configuation, and looked at the tree of possible computational histories (sequences of configurations), and noticed that if there was a root to leaf path where all nodes were labeled both 0 and 1, then this would be a infinite computation on which consensus was not reached. In this third part, we derived a contradiction if there was a node label 0 and 1, but where there was no single child that is labeled with both 0 and 1. Note that in the computation history that we found in the second part, we can not rule out the fact that some message was sent, but was never delivered, since we are assuming no upper bound on the time that it takes to deliver a message. Your task is to make the proof work if every sent message must eventually be delivered. Note that there is no a priori upper bound on how long delivery can take. This will require some modification of the second part of the proof. Note that while this problem is not extremely difficult, it is a step up from the usual homework problems, and is meant to be a bit challenging.

• Wednesday February 11
  
• 5.2-4 (Use linearity of expectation)
  
• 5.2-5 (Use linearity of expectation)
• 8-4 (€)
• 5.4-6. Use linearity of expectations. Give an exact formula. Then simplify the formula to give an simple estimate that is correct to within a multipliciative constant, e.g. Theta(1/sqrt(n)).  (€)

• Friday Februrary 13
• Exercise 1.1 from the handout You might check this link out.  (€)
• Exercise 1.2
  
• Exercise 1.3 from the handout
• Exercise 1.4 form the handout. Use a Chernoff bound
  

• Monday February 16
• 11-1
• 11-2  (€)

• Wednesday February 18

• Consider the red and blue jug problem from problem 8-4 in the text. Assume that if you sorted the jugs by volume, that each permutation is equally likely. Show that the average case time complexity of this problem is then Omega(n log n). That is, every deterministic algorithm has average time complexity Omega(n log n). Conclude using Yao's technique that the expected time complexity of any Las Vegas randomized algorithm is Omega(n log n).
• Consider the red and blue jug problem from problem 8-4 in the text. (€)
• Assume that if you sorted the jugs by volume, that each permutation is equally likely. Show that if a  deterministic algorithm A that always stops in o(n log n) steps, then algorithm A the probability that A is correct for large n is less than 1 percent.
• Show if there is a distribution of the input on which no deterministic algorithm with running time A(n) is correct with probability > 1 percent, then there is no Monte Carlo algorithm with running time A(n) that can be correct with probability > 1 percent.
• Hint: Mimic the proof of Yao's technique/lemma for the case of Las Vegas algorithms. Consider a two dimensional table/matrix T, where entry T(A, I) is 1 if algorithm A is correct on input I, and 0 otherwise.
• Conclude that any Monte Carlo algorithm for this jug problem must have time complexity Omega(n log n).

• Friday February 20
• Consider the following online problem. You given a sequence of bits b_1, ... b_n over time. Each bit is in an envelope. You first see the envelope for b_1, then the envelope for b_2, .... When you get the i^th envelope, you can either look inside to see the bit, or destroy the envelope (in which case you will never know what the bit is).  You know a priori that at least n/2+1 of the bits are 1. You goal is to find an envelope containing a 1 bit. You want to open as few envelopes as possible.  (€)
• Give a deterministic algorithm that will open at most n/2 + O(1)envelopes.
• Show that every deterministic algorithm must open at least n/2 - O(1) envelopes.
• Give a Monte Carlo algorithm that opens O(log n) envelopes.
• Show that every Monte Carlo algorithm must open Omega(log n) envelopes if it is to be incorrect with probability < 1/n.
• Give a Las Vegas algorithm where the expected number of opened envelopes is O(n^(1/2))
• Show that every Las Vegas algorithm must open Omega(n^{1/2}) envelopes in expectation. 
  
• Hint: The previous 5 subproblems are all quite easy. This one is pretty tricky. I would use Yao's technique. But the most obvious distributions will not work.
• 24-2 part c. All you need to do is to explain how to restate this problem as a shortest path problem. Explain which shortest path algorithm (Bellman-Ford or Dijkstra) would be most appropriate to use here.
• 24-3 part a. All you need to do is to explain how to restate this problem as a shortest path problem. Explain which shortest path algorithm (Bellman-Ford or Dijkstra) would be most appropriate to use here.

• Monday February 23
• Prove that Prim's minimum spanning tree algorithm is correct using an exchange argument.
  
• 26-1  (reduce to network flow)
  
• 26-2  (reduce to network flow)  (€)
• 26-3 (reduce to network flow)

• Wednesday February 25
• Show how to modify Dijkstra's shortest path algorithm to find an s-t path where the minimum edge weight is maximized. Recall that one needed an algorithm to find such a path in one of the Karp-Edmonds variations of the Ford-Fulkerson network flow algorithm.
• Consider the problem where the input is an undirected graph, and the goal is to assign a non-negative rational number c_x to each vertex x in such a way that for every edge (x, y) it is the case that c_x + c_y is at least 1. The objective is to minimize the sum of all the c_x's.
  • Show how to express this problem as a linear program. Note that this is a "covering" LP since it can be viewed as trying to put as little stuff into something (here vertices) so that something else (here edges) are covered.
    • Note that if the c_x values had to be integer, then this would be the NP-hard vertex cover problem.
  • Show that there are graphs where there are no integer optimal solutions.
  • Construct the dual to the above linear program.
  • Give a natural English interpretation to the dual. This dual would fall into the category of a "packing" LP.  Packing problems involve trying to put as much stuff into something so that no capacity constraints are violated. Try to have your interpretation include packing.
  • Explain how to give a simple proof that for a particular graph you need the sum of the c_x's in the primal to be at least a certain amount C to be feasible. Your proof may not assume that the audience knows anything about LP.
• Consider the problem of constructing a  maximum cardinality bipartite matching (see section 26.3 in the book)  (€)
• Construct an integer linear program for this problem
• Consider the associated linear program where the integrality requirements are dropped. Explain how to find an integer optimal solution from any rational optimal solution. Hint: Find cycles of edges who associated variables are not integer.
  
• Construct the dual program.
• Give a natural English interpretation of the dual problem (e.g. similar to how we interpreted the dual of the max flow problem as the min cut problem)
• Explain how to give a simple proof that a graph doesn't have a matching of a particular size. You should be able to come up with a method that would convince someone who knows nothing about linear programming.

• Friday Febrary 27
• Consider the problem of scheduling a collection of processes on one processor. Each process J_i has an execution time x_i a release time r_i ,  and a deadline d_i. All these values are positive integers. The goal is to find as large of a multiplier s as possible such that each process must be run for s*x_i units of time after time r_i and before time d_i.. A processor can switch between processes arbitrarily. For example, the processor can run J_1 for a while, then switch to J_2, then back to J_1, then to J_3, etc.  (€)
  • Express this problem as a linear program
  • Construct the dual program.
  • Give a natural English interpretation of the dual problem (e.g. similar to how we interpreted the dual of the max flow problem as the min cut problem).
  • Explain how to give a simple proof that the input is infeasible for a particular multiplier. You should be able to come up with a method that would convince someone who knows nothing about linear programming. But you should use LP duality.
• Consider a two person game specified by an m by n payoff matrix P. The number of possible moves for the row player is m and the number of possible moves for the column player is n. If the row player makes move r, and the column player makes move c, then the row player pays the column player P_{r,c} dollars. Note that P_{r,c} could be negative, in which case really the column player is paying money to the row player. We assume that the game is played sequentially, so that one player specifies his move, the other players sees that move, and then specifies a response move (we will assume that this player makes the best possible response). Obvious each player want to be payed as much money as possible, and if this is not possible, to pay as little as possible. HINT: All of these subproblems are  easy, so if you are heading toward a complicated answer, you might want to reevaluate.  (€)
• Trivial warm-up problems:
  • Give an algorithm that will efficiently compute the best response for the second player
  • Give an algorithm that will efficiently compute the best first move given that the second player makes the best response
  • Either give an example of a payoff  matrix where it is strictly better for each player to go second, or argue that there is no such payoff matrix. HINT: Roshambo
• Now we change the problem so that each player  specifies a probability distribution over his moves, and then the row player pays the column player E[P_{r,c}], where the expectation is taken over the two probability distributions.
  
• Give an algorithm that will efficiently compute the best response for the second player
• Give an algorithm that will efficiently compute the best first move given that the second player makes the best response
• Either give an example of a payoff  matrix where it is strictly better for each player to go second, or argue that there is no such payoff matrix

• Monday March 2
• Do the following easy NP-hardness proofs
• 34.5-1 Show that this problem is NP-hard by reduction from the NP-complete clique problem
• 34.5-2 Show that this problem is NP-hard by reduction from 3-CNF-SAT
• 34.5-3 Show that this problem is NP-hard by reduction from 0-1 integer programming
  
• 34.5-5 Show that this problem is NP-hard by reduction from Subset Sum
• 34.5-6 Show that this problem is NP-hard by reduction from Hamiltonian Cycle
• 34-5-7 Show that this problem is NP-hard by reduction from Hamiltonian Cycle
• 34.5-8 Show that this problem is NP-hard by reduction from 3-CNF-SAT
• 34-2  (€)
  
• 34-1 part b. The decision problem is to determine whether there is an independent set of size at least k.

• Wednesday March 4
• Consider the graph coloring problem defined in problem 34-3
  
• Consider the obvious decision version of this optimization problem: Take as input a graph G, and determine if G is 3-colorable. Show that one can polynomial time reduce the optimization probem to the decision problem
  
• Prove that the 3-coloring problem is NP-hard following the hints/outline given.
  
• Consider problem 34-4  (€)
• Show that the problem of scheduling with profits and deadlines is NP-hard by reduction from subset sum or partition.
  
• do part d

• Wednesday March 18
  
• 35.1-5
• 35-1 Just show that first-fit has approximation ratio at most 2. If the subproblems are useful great, otherwise you can ignore them.
  
• 35-2 part b. Actually for part b all you need to problem is that if there is an approximation algorithm that has approximation ratio 1000 then there is an approximation algorithm with approximation ratio 1.000000001.

• Monday March 23
• 35-5 Just show that the approximation has approximation ratio at most 2. If the subproblems are useful great, otherwise you can ignore them.
• The input to the weighted dominating set problem is a vertex weighted graph G, where the maximum degree of any vertex is D. Assume that the weights are positive. The output should be the least weight dominating set. A dominating set S is a collection of vertices such that every vertex in G is either in S, or is adjacent to a vertex in S. The weight of a set is the sum of the weights of the elements.
  
• Show how to write this problem as an integer linear program
• Show how to deterministically round the linear relaxation to get a polynomial time (D+1)-approximation algorithm for the dominating set problem.
• Hint: Recall the rounding for the Vertex Cover problem.
  
• Now show how to get a Monte Carlo algorithm whose expected approximation ratio is O(log n).
  
• Hint: If the LP variable for a vertex is bigger than 1/log n, then round it up. Round the remaining variables independently. Explain why this works. Use the theorem for multiplicative form of Chernoff bound (relative error).
  
• Explain how to improve this to get a Las Vegas algorithm whose expected approximatino ratio is O(log n).  Make sure to justify your answers.
  

• Wednesday March 25
  
• We consider the list update problem under the following simplest possible model. If the item accessed is the k^th item in the list, then this costs k, and the accessed item can be moved to any of the first k positions of the list for free. We consider the BIT algorithm. BIT maintains a bit for each itemt that is initially uniformly and independently at random set to 0 with probability 1/2 and set to 1 with probability 1/2. Every time an item is accessed BIT toggles the bit of the accessed item. If the bit was a zero before the change, then BIT moves the item to the front of the list. If the bit was a one, then BIT doesn't move the item.
• Prove that BIT is 7/4 competitive (in expectation). Use the potential function as the number of type 1 inversions plus twice the number of type 2 inversions. An inversion is a pair of items (x, y) such that x occurs before y in BIT's list but x occurs after y in the optimal list. An inversion is type 1 if y's bit is 0 and is type 2 is y's bit is 2. This information can be found at the top of page 10 here.
• Consider the case of a two element list. Consider the input distribution that on each access, accesses each of the two items with probability 1/2, independent of previous accesses.
  • Show that the expected cost of any deterministic online algorithm A is 3/2 per access.
  • Show that there exists some constant c < 3/2 such that the expected cost for the optimal offline is at most c per access. So you are showing that one could expect to do better with the optimal offline algorithm (that can see what requests arrive in the future) than any online algorithm.
  • Show that for every online randomized algorithm A, that there is an input I, such that the expected cost of A on I is at least (1 + epsilon) times the optimal cost for I, for some epsilon > 0 that you may choose. So this says that even using randomization, an online algorithm will still be at least some constant factor worse than optimal. So you essentially need to prove that a variation of Yao's technique works when you are looking at the approximation ratio for minimizatin problems.
    

• Monday April 13 (This is a purely extra credit problem for those who are really interested. There will not be a question about this on the preliminary/final exam.)
  
• We consider the online algorithm A for minimizing fractional flow time plus energy for unit work jobs. Assume that power = the square of speed. Recall that speed sA for A is then (nA)^{1/2}, where nA is the fractional number of unfinished jobs (fractional means that a job that is 1/3 finished only adds 2/3 to nA). The fractional flow for A is the integral over time of nA. We wish to show that A is O(1)-competitive using a different potential function, namely Φ = σ(nA^{3/2} – 4nA^{1/2} nOpt), where σ is some constant. Here nOpt is the fractional number of jobs remaining in the optimal solution.
  
  • First show that the equation 2nA + γ(nOpt + sOpt^2) + dΦ/dt ≤ 0 holds at times when no jobs arrive, for some constant γ
  • Hints: First evaluate dΦ/dt. Recall dnA/dt= - sA. Using Young’s inequality we know that (nA)^{1/2} sOpt≤ nA/2 + sOpt^2/2. This is not too hard.
    
  • Then show the potential function Φ does not increase when a new job arrives, that is when nA and nOpt both increase by 1.