UVA 10261 – Ferry Loading

1. UVA 10261 – Ferry Loading Bowen Yu Programming Practice Midterm, 7/30/2013

2. Abridged Problem Statement There is a ferry that has two sides (port/starboard). Both sides are L-unit long (L<=10000). You are given a sequence of cars to be loaded onto the ferry. Each car has an integer length in [100, 10000]. You can decide to which side of the ferry each car is loaded. But you have to load them in the input order and stop as soon as one car cannot be loaded to either side. Task: Maximize the number of cars you can load, and print a way of loading maximum number of cars (any will do).

3. Sample Case L = 5000, Cars = {2500, 3000, 1000, 1000, 1500, 700, 800} Answer: 6 port (2500) starboard(3000) starboard(1000) starboard (1000) port (1500) port (700) Let’s verify: port = 2500 + 1500 + 700 = 4700 < 5000 (4700 + 800 > 5000) starboard = 3000 + 1000 + 1000 = 5000 (5000 + 800 > 5000)

4. First Step: Understand and formalize the task You may forget about the ferry-car story and switch to a more straightforward model instead. A simpler model: You are given some objects one by one. Pack as many of them as you can into two equal-size containers, so that the volume sum of the objects in either container does not exceed the capacity of the container.

5. Second Step: Observe input magnitude • Values are all integers, i.e. discrete. • The size of the container is up to 10000. • The size of one object is [100, 10000]. • Unfortunately, the number of objects is not given (at first glance there is no bound). • Can we determine its range? • The container is at most 10000 large, and each object is at least 100, so we can pack at most 200 objects (don’t forget you have 2 containers!). Good for memo! Small! Small! YES!

6. Choice Step: Decide your approach Enumerating decisions for 200 objects is clearly TLE. So forget about complete search. There is no greedy strategy that makes sense. (Easy to show yourself some counterexamples) See that the input are integers, and limited in range (up to 10000). Also the objects are given in an order that we can not change (forward property). This recalls us directly to DP.

7. Design Step: Design your DP solution To use DP, we need to first choose the states we will maintain. Candidate 1: memorize our decision for each object Not feasible, that is 2N Think… How does our previous choices affect the current decision? Only the volume used matters! We just need to know whether we can pack the previous objects into the two containers, so that we occupy V1 unit of space in container 1, and V2unit of space in container 2

8. Design Step: Design your DP solution (cont’d) Candidate 2: memorize whether we can pack the previous objects (objects that appear before the i-th object we’re currently considering) so that the volume used are (V1, V2) respectively for the 2 containers. So the state is (i, V1, V2) = {true, false}. Not feasible :( This would require [200][10000][10000] for all the states, which is clearly MLE

9. Design Step: Improve our DP! We need to reduce the space requirement for our DP. Think… Can we drop one variable, and recover it from the others? YES! Suppose we know a valid state (i, V1, V2). Note that we also know the sum of volumes of objects we’ve already packed, say Vsum. Then, V2 = Vsum – V1.

10. Design Step: Improve our DP! (cont’d) Candidate 3: memorize whether we can pack the previous objects (before the i-th object we’re currently considering) so that the volume used are (V1, V2). But the state is (i, V1)instead of (i, V1, V2) as we can recover V2 from V1. This gives us [200][10000] states. This candidate WORKS within the Memory Limit!:)

11. Design Step: Check the relations between DP states Suppose a previously achievable state is (i, V1, V2). (I write three parameters for clear explanation, though we do not store 3-parameter states physically) We are considering the i-th object of size Vi. We have two choices with respect to this previously achievable state (i, V1, V2): Put it into the first container (when V1+Vi <= L) (i, V1, V2) -> (i+1, V1+Vi, V2) 2) Put it into the second container (when V2+Vi <= L) (i, V1, V2) -> (i+1, V1, V2+Vi)

12. Design Step: Check the time complexity First, for each object we have to enumerate the previously achievable states, which is O(L). For each object, we need to consider two decisions, which is constant time. We have to do the above for each of the objects. We multiply the time by the number of objects. Therefore, we have finally an O(NL) time DP solution, where N<=200, L<=10000. Now we know, this solution really WORKS, as both time and space requirements are satisfied.

13. Design Step: Be careful of the problem requirement • Don’t forget that the problem asks us to print the actual solution in addition to the maximum number of objects we can pack. • This is a DP solution memo requirement. • We can do it without increasing our space requirement. • When we reach a new state from a previous one, we can store a backward pointer of the new state to the previous state. • In this way later we can trace back from the final state all the way to the initial state and figure out every decision, via the backward pointers. • Each state of DP has exactly one backward pointer, so the backward pointers together take the same space as the dp states.

14. Case Demo L = 5000, {2500, 3000, 1000, 1000, 1500, 700, 800} 5000 (2500) 4500 (3000) 4000 (2500) 4000 (3500) 3500 (3000) 3500 (4000) 3000 (3500) 3000 (2500) 3000 (4500) 2500 (0) 2500 (3000) 2500 (4000) 2500 (5000) 0 (2500) 0 i=0 i=1 2500 i=2 3000 i=3 1000 i=4 1000

15. Case Demo L = 5000, {2500, 3000, 1000, 1000, 1500, 700, 800} 5000 (2500) 5000 (4000) 5000 (4700) 4500 (3000) 4500 (4500) 4700 (5000) 4000 (3500) 4000 (5000) 3500 (4000) 3000 (4500) 2500 (5000) i=4 1000 i=6 700 i=5 1500 i=7 800

16. Case Demo (Trace back the actual solution) L = 5000, {2500, 3000, 1000, 1000, 1500, 700, 800} Container 2 Container 1 5000 (2500) 5000 (4000) 5000 (4700) 4500 (3000) 4500 (4500) 4700 (5000) 4000 (3500) 4000 (5000) 3500 (4000) 3000 (4500) 2500 (5000) i=4 1000 i=6 700 i=5 1500 i=7 800

17. Case Demo (Trace back the actual solution) L = 5000, {2500, 3000, 1000, 1000, 1500, 700, 800} Container 2 5000 (2500) 4500 (3000) Container 1 4000 (2500) 4000 (3500) 3500 (3000) 3500 (4000) Container 1 3000 (3500) 3000 (2500) 3000 (4500) Container 1 2500 (0) 2500 (3000) 2500 (4000) 2500 (5000) 0 (2500) 0 i=0 i=1 2500 i=2 3000 i=3 1000 i=4 1000

18. Final Step: Code and submit! • Pay attention to the input format. • L is given in meters, but lengths of cars are in centimeters. So we shall do an easy conversion. • As the number of cars is unknown beforehand, the input car length sequence of each case is terminated by 0. • If one car cannot be loaded, all the following cars cannot be loaded either. But we still need to read in the other car lengths. • Allocate arrays with redundant entries, or be careful with off-by-one errors. Note that a minimum of L+1 entries is required for each DP table row.

19. Final Step: Code and submit! (cont’d) Test your code with predesigned test cases. For example: L = 1, {10000} Cannot load any car! output 0 L = 1, {100, 100} One car at each side … Good thing about DP: Usually if you have a clear thinking of your DP logic (time, space, state transition, etc.), you have a high chance of getting 1A (got Accepted using 1 submission). Finally, Submit and have fun! :D

20. Sample Solutions I’ve written one C++ solution and one Java solution for this problem, which will be given out with this slide. (In fact for this problem, you can use space saving trick if you like for the DP table, but not for the backward pointers.) I’ve added exhaustive comments for each statement, and expand each variable to its full name (instead of contest-style short name) so as to minimize the chance you can confused. Hope they help!

21. Thanks