COMS 482: unofficial class blog

We can take a greedy approach, minimum makespan. Given jobs for machines with times t₁, t₂, … , t_n, the total time from start to finish of the slowest machine is as small as possible. Example, three machines with jobs 2, 2, 2, 3, 4, 6:

M₁: 2, 2, 2
M₂: 3, 4
M₃: 6

We can write this as a decision problem. Given the number of machines and a list of job times, and a bound k, is there a way to assign jobs so that Makespan <= k? Makespan is NP-complete, by reduction from Subset Sum! Given a target W and w₁, w₂, … , w_n, split into sets W and S - W where S = sum(w_i). Take |W - (S - W)| = |2W - S| = W₀, a new constant in the list which forces the best solution where both subsets have the same sum = max(W, S - W).

Given a Subset Sum problem, create W₀ = |S - 2W| and let the w’s be the times of jobs. Ask if Makespan works on 2 machines of size <= (S + W₀) / 2.

Claim: “There is a solution to Subset Sum if and only if there is a solution to Makespan.”

Assume a Subset Sum solution. Split the w’s into subsets that sum to W and S - W. W₀ was chosen so we can make them equal, so there exists a Makespan = (S + W₀) / 2, and some machine has a subset of jobs summing to W.

Greedy Strategy: Assign each job to least busy machine, incrementally. How good is this? Call the best Makespan possible T*. The sum(t_i) = total time to be spread over m machines. Some machine must have more than sum(t_i) / m, so T* >= sum(t_i) / m. Consider M_i, the machine with worst time; it’s load is T = T_i. In general, T_j = load on M_j. Our makespan answer is T₁ by the greedy algorithm.

Let t_j be the last time assigned to M_i. At that moment, M_i’s load is T_i - t_j. That must be the smallest load, because we chose it for the last job. So T_i - t_j <= T_k for all k.

For each machine: M(T_i - t_j) <= sum(T_k) = sum(t_j). So T_i - T_j < = sum(t_j) / m &;t= T*. T_i &lt= T* + t_j so T = T_i <= T* + t_j and T* >= worst t_k >= t_j, so T <= T* + T* -> T <= 2 T*.

The greedy algorithm is always within twice the optimal value. If we presort and do the largest jobs first, we can show that T/T* <= 3/2 and T/T* <= 4/3.

Credit to Kevin Canini for the notes!

This entry was posted on Wednesday, April 13th, 2005 at 11:07 pm and is tagged with subset sum problem, w1 w2, greedy algorithm, lt 2, greedy approach, wn, decision problem, target, worst time, 2w, last job, subsets, best solution, t2, last time, tk, m2, np, jobs. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback.

Leave a Reply

Name (required)

Mail (will not be published) (required)

Website

Please take time to enjoy the archives: May 2005 (1) April 2005 (11) March 2005 (11) February 2005 (15) January 2005 (7)

Fresh, related resources: