0:05

Let's turn to the Analysis of a Dynamic Programming based Heuristic for

the Knapsack problem.

In particular, let's understand precisely how the running time of this Heuristic

depends on the desired accuracy epsilon.

Let me jog your memory,

what are the two steps of our Dynamic Programming based Heuristic?

The first thing we do is we massage the item values.

We round them so that they are relatively small integers.

0:29

Precisely for each each item, i, we define v hat to be what you get by

dividing the item size by m and then rounding down to the nearest integer.

In step 2 we invoke our second dynamic programming solution for

the knapsack problem, and we pass to it these new values the v hats

as well as the original item sizes and the original knapsack capacity.

0:51

This algorithm, as stated, is underdetermined.

That's because I haven't told you how to set the parameter m.

We do at least understand qualitatively the role of m and

how it influences the choice in the accuracy running time tradeoff.

Specifically, the bigger we set m, the more information we lose when we

round the original values, the vi's to the v hat i's.

More loss in information should translate to less accuracy.

Larger m less accuracy.

On the other hand the bigger we take m,

the smaller the transformed item values the v hats.

Remember the running time of our second dynamic programming algorithm

is proportional to the largest item value so

smaller item values translates to faster running times.

Summarizing, the bigger the m the less the accuracy, but the faster the algorithm.

1:41

Here's our plan for the analysis.

We begin by studying the accuracy constraint.

Remember the setup.

The client is giving us a positive parameter epsilon.

And it is our responsibility to output a feasible solution whose total value

is at least 1 minus epsilon times that of an optimal solution.

1:59

This constraint on our algorithms accuracy should translate to an upper bound

on how large a value of m we can get away with.

Remember, as we jack up m, we lose accuracy.

So the first question we're going to study is,

how large in m can we get away with while still being guaranteed to compute

a solution within 1 minus epsilon times that of an optimal one.

2:21

Once we solve this problem and we understand how large a value

of m we can get away with, how aggressive we're permitted to be with the scaling,

we'll then evaluate the running time of the resulting algorithm for

that particular choice of m.

2:38

To answer this first question, how big can we take m subject to an accuracy

constraint of one minus epsilon its important to understand in detail how

the rounded item values, the v hats compare to the original item values

the v's that's what this quiz is meant to ask you to think about.

3:25

Remember how we obtain v hat i from v i,

first we decrease it to the next multiple of m, then we divide it by m.

So we can think of m times v hat of i as what we have just after we've rounded down

to the nearest multiple of m, and before we actually divide it by m.

So how did we get to this m times v hat i?

We decreased vi down to the next nearest multiple.

So we decreased it by somewhere between 0 and m.

So that was somewhere between vi minus m and vi.

3:58

So let's now assemble a few preliminaries crucial for the accuracy analysis.

So what did we learn from the quiz?

We learned that for each item i, the rounded value v hat i, scaled up by m, so

intuitively this is after we've rounded vi down to the nearest multiple but before

we divide it, that lies between vi as an upper bound and vi minus m as lower bound.

So let me extract these two different inequalities,

one which expresses an upper bound on vi in terms of v hat i and

then one which expresses the lower bound from vi in terms of v hat i.

4:31

So there are two inequalities which are immediate from this fact,

let me go ahead and give them names 1 and 2.

We'll put these to use in the next slide.

So first of all, the value vi,

well that's lower bounded by m times the rounded value v hat i.

And then v hat i, we can lower bound that by vi after we subtract m from it.

So we'll call those inequalities 1 and 2.

4:53

So these first two inequalities they're important for us.

They don't have a lot of content, they're just sort of immediate from our definition

of step 1 of our algorithm from the way we do our rounding.

But step 2 of our algorithm gives us a third inequality which is much more

powerful, and this says well look,

in the second step we solve a Knapsack instance optimally.

It's true we solve it for the wrong values.

We solve it for the v hats but for these rounded values of the v hats the solution

we come up with is better than any other.

5:39

That is, if we sum up the v hat i's of the items in our solution s, and

we compare it to the sum of the v hat i's in any other solution.

In particular, the solution s star, optimal for the original instance.

We count out ahead, our sum of values is bigger.

That's going to be our inequality number 3.

6:17

To see this let's just follow our notes,

let's just see what happens if we chain these three inequalities together.

Now the third one seems to have the most content, that really says we're

optimally solving this problem with the transform value is the v hat.

So let's start out by just writing down yet again, inequality number three.

6:34

So inequality three just says that the sum of the transform value is the sum of the v

hats in our heuristic solution capital S, is at least as good as any other solution,

in particular, that of the solution s star, optimal for

the original problem with the original item values.

Inequality 3 is a fine starting point.

Fundamentally what we're trying to do here is lower bound the performance of

the solution S spit out by our heuristic and that's one this inequality does.

The one problem is that it's justifying the performance of

s in terms of the wrong data, in terms of the transferred values of the v hats.

Whereas what we really care about are the original values of the v's.

So we need to take this inequality 3 as a seed ,and grow from it

a chain of inequalities, rewriting on both the left-hand side and the right-hand side

these transformed values of the v hats in terms of the original values of the v's.

And we'll use inequalities 1 and 2 to do that.

As we grow the chain to the left,

we want quantities that are only getting bigger and bigger.

As we grow the chain to the right,

we want quantities that are only getting smaller and smaller.

Hopefully at the end of the day when the dust settles,

we'll have an approximate optimally result for our heuristic solution s.

7:52

To extend this chain of inequalities on the left-hand side,

we need to tack on a quantity which is only bigger.

That is we need to upper bound m times v hat i in terms of the original value vi.

But inequality 1 simply says that indeed,

m times v hat i is never bigger than the original value vi.

8:10

So we simply apply inequality 1 to each item in the heuristic solution capital S,

and we get an upper bound of sum over the items, and

our solution s of the value of that item.

So that's great.

We get a lower bound, on the performance of our solution,

that's exactly what we want.

8:25

To grow the change of inequalities to the right we need a quantity which is

only smaller, that is we want to lower bound m times v hat i,

in terms of some function of the original value v sub i.

Now, v sub i can be bigger than m times v hat i.

Remember, we route it down but inequality 2 says it can only be bigger by at most m.

So if we subtract m from v i, we get a lower bound on m times v hat i.

So we just apply that term by term to the optimal solution, s star.

8:53

So just by following our nose in this way, we get exactly what we want.

We get, on the left hand side what we really care about, namely,

the total value of the solution output by our heuristic.

And this is the total value with the original values,

mind you, not with the transformed ones, with the ones we really care about.

We get a lower bound on that total value, that's exactly what we wanted.

In terms of the best case scenario, the total value of the optimal solution,

and the only blemish is we pick up this error of at most minus m for

each item i in the optimal solution s star.

So let's just lower this down crudely.

The optimal solution as star it can only have n items at most.

So we pick up a minus m at worst for each of these in most and items.

So if we subtract an error term of m times n that

gives us a lower bound on the value of our solution s.

So now that the dust has cleared, we see that we have a performance guarantee for

our solution s in terms of that, of the optimal solution, s star, basically,

we're off by this error term of m times n.

Remember, m is this parameter that governs how aggressively we scale the item values,

and it's controlling the running time accuracy trade-off.

We were expecting this all along, we argued with the bigger you take m,

the more information you lose.

So the less act that you'd expect and indeed the extent that were off

by the optimal solution is growing linearly in this parameter m.

The question were striving the answer, remember,

is how big an m can we get a way with, and

still be sure that our solution is within a 1 minus epsilon factor of the optimal 1.

But to achieve this we just need to make sure that the worst case error in our

solution m times n is never bigger than an epsilon fraction

of the optimal solutions value, that is we just set m small enough that

m times n is not more than epsilon times the optimal value.

10:47

So this inequality is meant to tell us how to set the parameter m in our algorithm.

But you'd be right to complain that on the right hand side,

there's a quantity here that we don't actually know, right?

We don't actually know the optimal value of the optimal solution s star.

That, after all, is what we're trying to compute,

at least approximately, in the first place.

11:06

So instead what we're going to do is just use a crude lower bound

on how small the optimal solution value could be.

Let's make a trivial assumption, let's assume that each item has a size at most

the Knapsack capacity, that is, each items fits by itself inside the Knapsack.

Any items which fail that test obviously can be deleted in the pre-processing step.

Then, the optimal solution if nothing else,

it's at least as large as the value of the max value item.

11:36

So to satisfy the desired accuracy constraint, all we need to do is set

m small enough so that m times n is at most the right hand side listed here.

Of course, it's sufficient to set m even smaller so

that m times n is no more than an even smaller number.

12:05

So notice, these are all indeed parameters known to the algorithm.

It of course, knows how many items n there are, it knows epsilon,

that's the parameter supplied to the algorithm by the client and

it's easy to compute v max, the maximum value item.

So the algorithm is in a position to set m so that this equality holds.

That is to set m equal to epsilon v max over n.

That finally completes the description of the dynamic per mean based heuristic.

12:48

And now I hope that everybody is holding their breath and

crossing their fingers just a little bit.

because remember m not only governs the accuracy it also governs the running time,

the more aggressively that we can scale the numbers the larger we can take m

the faster the algorithm, and the question now is are we permitted to take m

large enough that the resulting heuristic running time is polynomial?

13:12

So the running time of the heuristic is certainly dominated by step 2,

where we invoke our dynamic programming algorithm, and the running time there is

n squared times the maximum item value passed to that subroutine.

That is the maximum value of a scaled value, the maximum v hat i.

13:38

So pick your favorite i, how big can its transform value v hat i be?

Well, how do we get v hat i?

We take the original value vi, we round it down and we divide it by m.

So the biggest certainly the v hat i could be is the original value of vi

divided by m.

14:37

As you take epsilon smaller and smaller you need to take n smaller and smaller.

To get the accuracy guarantee that resulted in less aggressive scaling of

item values in turn, bigger transformed values get passed to

the dynamic programming subroutine, resulting in the bigger running time.