The Party Schedule problem, published in SPOJ website, is about deriving an optimal set of parties that maximizes fun value, given a party budget:

and

parties:

where each party

have an entrance cost

, and is associated with a fun value

.

In this post, we discuss how to solve this problem by first outlining an algorithm, and afterwards, by implementing that using F#.

Background¶

This problem is a special case of  Knapsack problem. Main objective of this problem is to select a subset of parties that maximizes fun value, subject to the restriction that the budget must not exceed

.

More formally, we are given a budget

as the bound. All parties

have costs

and values

. We have to select a subset

such that

is as large as possible, and subject to the following restriction --

Furthermore, an additional constraint: “do not spend more money than is absolutely necessary” is applied, which implies following. Consider two parties

and

; if

and

, then we must select

instead of

.

Algorithm¶

Attempt 1The definition of this problem suggests a recursive solution. However, a naïve recursive solution is quite impractical in this context, as it requires exponential time due to the following reason: a naïve recursive implementation applies a top-down approach that solves the subproblems again and again.

Attempt 2Next, we select dynamic programming technique to solve this problem. So, we have to define a recurrence that expresses this problem in terms of its subproblems, and therefore it begs the answer of the following question:

What are the subproblems? We have two variants:

and

, i.e. available budget and number of parties. We can derive smaller subproblems, by modifying these variants; accordingly, we define-

It returns the maximum value over any subset

where

. Our final objective is to compute

, which refers to the optimal solution, i.e., maximal achievable fun value from budget

and

parties.

To define the recurrence, we describe

in terms of its smaller subproblems.

How can we express this problem using its subproblems? Let’s denote

to be the optimal subset that results in

. Consider party

and note following.

1. It

, then

. Thus, using the remaining budget

and the parties

, we seek the optimal solution.

1. Otherwise,

then

. Since

is not included, we haven’t spent anything from

.Obviously, when

, we apply the 2nd case. Using the above observations, we define the recurrence as follows--

where the base conditions can be rendered as below.

Using the above recurrence, we can compute

for all parties

and for costs

. In essence, we build the OPT table, which consists of

rows and

columns, using a bottom-up approach as stated in the following algorithm.

[gist]4968611[/gist]

Implementation¶

Following code builds the OPT table using the stated algorithm.

[gist]4968644[/gist]

do not spend more money than is absolutely necessary

[gist]4968662[/gist]

Complexity.

as each

requires

time.

For the complete source code, please check out this gist,  or visit its IDEONE page to play with the code. Please leave a comment if you have any question or suggestion regarding the algorithm/implementation.

Happy coding!

See Also

SPOJ 8545. Subset Sum (Main72) with Dynamic Programming and F#.

UVa 10664. Luggage.