{'fraction_non_alphanumeric': 0.050944837032278395, 'fraction_numerical': 0.01242409182918995, 'mean_word_length': 3.885243960208432, 'pattern_counts': {'":': 0, '<': 8, '<?xml version=': 0, '>': 26, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 26, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Stochastic Combinatorial Optimization via Poisson Approximation

We study several stochastic combinatorial problems, including the expected utility maximization problem, the stochastic knapsack problem and the stochastic bin packing problem. A common technical challenge in these problems is to optimize some function of the sum of a set of random variables. The difficulty is mainly due to the fact that the probability distribution of the sum is the convolution of a set of distributions, which is not an easy objective function to work with. To tackle this difficulty, we introduce the Poisson approximation technique. The technique is based on the Poisson approximation theorem discovered by Le Cam, which enables us to approximate the distribution of the sum of a set of random variables using a compound Poisson distribution. We first study the expected utility maximization problem introduced recently [Li and Despande, FOCS11]. For monotone and Lipschitz utility functions, we obtain an additive PTAS if there is a multidimensional PTAS for the multi-objective version of the problem, strictly generalizing the previous result. For the stochastic bin packing problem (introduced in [Kleinberg, Rabani and Tardos, STOC97]), we show there is a polynomial time algorithm which uses at most the optimal number of bins, if we relax the size of each bin and the overflow probability by eps. For stochastic knapsack, we show a 1+eps-approximation using eps extra capacity, even when the size and reward of each item may be correlated and cancelations of items are allowed. This generalizes the previous work [Balghat, Goel and Khanna, SODA11] for the case without correlation and cancelation. Our algorithm is also simpler. We also present a factor 2+eps approximation algorithm for stochastic knapsack with cancelations. the current known approximation factor of 8 [Gupta, Krishnaswamy, Molinaro and Ravi, FOCS11].


We first study the expected utility maximization problem introduced recently [Li and
Despande, FOCS11]. For monotone and Lipschitz utility functions, we obtain an additive PTAS if there is a multidimensional PTAS for the multi-objective version of the problem, strictly generalizing the previous result. The result implies the first additive PTAS for maximizing threshold probability for the stochastic versions of global min-cut, matroid base and matroid intersection.
2. For the stochastic bin packing problem (introduced in [Kleinberg, Rabani and Tardos, STOC97]), we show there is a polynomial time algorithm which uses at most the optimal number of bins, if we relax the bin size and the overflow probability by ǫ for any constant ǫ > 0. Based on this result, we obtain a 3-approximation if only the bin size can be relaxed by ǫ, improving the known O(1/ǫ) factor for constant overflow probability.

Introduction
We study several stochastic combinatorial optimization problems, including the threshold probability maximization problem [52,50,45], the expected utility maximization problem [45], the stochastic knapsack problem [24,13,35], the stochastic bin packing problem [41,31] and some of their variants. All of these problems are known to be #P-hard and we are interested in obtaining approximation algorithms with provable performance guarantees. We observe a common technical challenge in solving these problems, that is, roughly speaking, given a set of random variables with possibly different probability distributions, to find a subset of random variables such that certain functional (other than the expectation 1 ) of their sum is optimized. The difficulty is mainly due to the fact that the probability distribution of the sum is the convolution of the distributions of individual random variables. To address this issue, a number of techniques have been proposed (briefly reviewed in the related work section). In this paper, we introduce a new technique, called the Poisson approximation technique, which can be used to approximate the probability distribution of a sum of several random variables. The technique is very easy to use and yields better or more general results than the previous techniques for a variety of stochastic combinatorial optimization problems mentioned above. In the rest of the section, we formally introduce these problems and state our results. Terminology: We first set up some notations and review some standard terminologies. Following the literature, the exact version of a problem A (denoted as Exact-A) asks for a feasible solution of A with weight exactly equal to a given number K. An algorithm runs in pseudopolynomial time for Exact-A if the running time of the algorithm is bounded by a polynomial of n and K.
A polynomial time approximation scheme (PTAS) is an algorithm which takes an instance of a maximization problem and a parameter ǫ and produces a solution whose cost is at least (1− ǫ)OPT, and the running time, for any fixed ǫ, is polynomial in the size of the input. If ǫ appears as an additive factor in the above definition, namely the cost of the solution is at least OPT − ǫ, we say the algorithm is an additive PTAS. We say a PTAS is a fully polynomial time approximation scheme (FPTAS) if the running time is polynomial in the size of the input and 1 ǫ . In a multidimensional minimization problem, each element b is associated with a weight vector (w b,1 , w b,2 , . . .). We are also given a budget vector (B 1 , B 2 , . . .). The goal is to find a feasible solution S ∈ F such that b∈S w b,i ≤ B i ∀i. We use Multi-A to denote the problem if the corresponding single dimensional optimization problem is A. A multidimensional PTAS for Multi is an algorithm which either returns a feasible solution S ∈ F such that b∈S w b,i ≤ (1 + ǫ)B i ∀i, or asserts that there is no feasible solution S ′ with b∈S ′ w b,i ≤ B i ∀i.

Expected Utility Maximization
We first consider the fixed set model of a class of stochastic optimization problems introduced in [45]. We are given a ground set of elements (or items) B = {b i } i=1...n . Each feasible solution to the problem is a subset of the elements satisfying some property. In the deterministic version of the problem, we want to find a feasible solution S with the minimum total weight. Many combinatorial problems such as shortest path, minimum spanning tree, and minimum weight matching belong to this class. In the stochastic version, each element b is associated with a random weight X b . We assume all X b s are discrete nonnegative random variables and are independent of each other. We are also given a utility function µ : R → R + to capture different risk-averse or risk-prone behaviors that are commonly observed in decision-making under uncertainty. Our goal is to to find a feasible set S such that the expected utility E[µ(X(S))] is maximized, where X(S) = b∈S X b . We refer to this problem as the expected utility maximization (EUM) problem. An important special case is to find a feasible set S such that Pr[X(S) ≤ 1] is maximized, which we call the threshold probability maximization (TPM) problem. Note that if µ(x) = 1 for x ∈ [0, 1]; µ(x) = 0 for x > 1, we have that Pr[X(S) ≤ 1] = E[µ(X(S))]. In fact, this special case has been studied extensive in literature for various combinatorial problems including stochastic versions of shortest path [52], minimum spanning tree [38,30], knapsack [31] as well as some other problems [1,50]. We use A to denote the deterministic version of the optimization problem under consideration, and use accordingly EUM-A and TPM-A to denote the expected utility maximization problem and the threshold probability maximization problem for A respectively.
Our Results: Following the previous work [45], we assume lim x→∞ µ(x) = 0 (if the weight of our solution is too large, it is almost useless). We also assume µ is α-Lipschitz in [0, ∞), i.e., |µ(x) − µ(y)| ≤ α|x − y| for any x, y ∈ [0, ∞), where α is a positive constant. Our first result is an alternative proof for the main result in [45]. For many combinatorial problems, including shortest path, spanning tree, matching and knapsack, a pseudopolynomial algorithm for the exact version is known. Therefore, Theorem 1.1 immediately implies an additive PTAS for the EUM version of each of these problems. An important corollary of the above theorem is a relaxed additive PTAS for TPM: For any ǫ > 0, we can find in polynomial time a feasible solution S such that provided that there is a pseudopolynomial time algorithm for Exact-A. In fact, the corollary follows easily by considering the monotone utility function χ(x) = 1 for x ∈ [0, 1]; χ(x) = − x ǫ + 1 ǫ + 1 for x ∈ [1, 1 + ǫ]; χ(x) = 0 for x > 1 + ǫ, which is 1 ǫ -Lipschitz. We refer the interested reader to [45] for more implications of Theorem 1.1. However, this is not the end of story. Our second major result considers EUM with monotone nonincreasing utility functions, a natural class of utility functions (we denoted the problem as EUM-Mono). We can get the following strictly more general result for EUM-Mono. It is worthwhile mentioning that condition of Theorem 1.2 is strictly more general than the condition of Theorem 1.1. It is known that if there is pseudopolynomial time algorithm for Exact-A, there is a multidimensional PTAS for Multi-A, by Papadimitriou and Yannakakis [53]. However, the converse is not true. Consider the minimum cut (MC) problem. A pseudopolynomial time algorithm for Exact-MC would imply a polynomial time algorithm for the NP-hard MAX-CUT problem, while a multidimensional PTAS for Multi-MC is known [3]. Therefore, Theorem 1.2 implies the first relaxed additive PTAS for TPM-MC. Other problems that can justify the superiority of Theorem 1.2 include the matroid base (MB) problem and the matroid intersection (MI) problem. Obtaining pseudopolynomial time exact algorithms for Exact-MB and Exact-MI is still open [14] 2 , while multidimensional PTASes for Multi-MB and Multi-MI are known [54,19].
We would like to remark that obtaining an additive PTAS for EUM-A for non-monotone utility functions under the same condition as Theorem 1.2 is impossible. Consider again EUM-MC. Suppose the weights are deterministic. The given utility function is µ(x) = 100x − 89 for x ∈ [0.89, 0.9]; µ(x) = −100x + 91 for x ∈ [0.9, 0.91]; µ(x) = 0 otherwise, (which is 100-Lipschitz) and the maximum cut of the given instance has a weight 0.9. So, the optimal utility is 1, but obtaining a utility value better than 0 is equivalent to finding a cut of weight at least 0.89, which is impossible given the imapproximability result for MAX-CUT [40].
Our techniques: Our algorithm consists of two major steps, discretization and enumeration. Our discretization is similar to, yet much simpler than, the one developed by Bhalgat et al. [13]. In their work, they developed a technique which can discretize all (size) probability distributions into O(log n) equivalent classes. This is a difficult task and their technique applies several clever tricks and is quite involved. However, we only need to discretize the distributions so that the size of the support of each distribution is a constant, which is sufficient for the enumeration step. In the enumeration step, we distinguish the items with large expected weights (heavy items) and those with small expected weights (light items). We argue that there are very few heavy items in the optimal solution, so we can afford to enumerate all possibilities. To deal with light items, we invoke Le Cam's Poisson approximation theorem which (roughly) states that the distribution of the total size of the set of light items can be approximated by a compound Poisson distribution, which can be specified by the sum of the (discretized) distribution vectors of the light items (called the signature of the set). Therefore, instead of enumerating O(2 n ) combinations of light items, we only need to enumerate all possible signatures and check whether there is a set of light items with the sum of their distribution vectors approximately equal to (or at most) the signature. To solve the later task, we need the pseudopolynomial time algorithm for Exact-A (or the multidimensional PTAS for Multi-A).

Stochastic Bin Packing
In the stochastic bin packing (SBP) problem, we are given a set of items B = {b 1 , b 2 , . . . , b n } and an overflow probability 0 < p < 1. The size of each item b i is an independent random variable X i following a known discrete distribution. The distributions for different items may be different. Each bin has a capacity of C. The goal is to pack all the items in B using as few bins as possible such that the overflow probability for each bin is at most p. The problem was first studied by Kleinberg, Rabani and Tardos [41]. They obtained a O(1/ǫ)-approximation, for only Bernoulli distributed items, if we relax the bin size to (1 + ǫ)C or the overflow probability to p 1−ǫ . They also obtained a O log p −1 log log p −1 -approximation without relaxing the bin size and the overflow probability. Goel and Indyk [31] obtained PTAS for both Poisson and exponential distributions and QPTAS (i.e., quasi-polynomial time) for Bernoulli distribution.
Our Results: Our main result for SBP is the following theorem. Theorem 1.3. For any fixed constant ǫ > 0, there is a polynomial time algorithm for SBP that uses at most the optimal number of bins, when the bin size is relaxed to (1 + ǫ)C and the overflow probability is relaxed to p + ǫ.
To the best of our knowledge, our result is the first result for SBP for arbitrary discrete distributions. Based on this result,we can get the following result when the overflow probability is not relaxed. For Bernoulli distributions, this improves the O(1/ǫ)-approximation in [41] for any constant p. Theorem 1.4. For any constant p > 0, we can find in polynomial time a packing that uses at most 3OPT bins of capacity (1 + ǫ)C such that the overflow probability of each bin is at most p.
Our technique: Our algorithm for SBP is similar to that for EUM. We distinguish the heavy items and the light items and use the Poisson approximation technique to deal with the light items. One key difference from EUM is that we have a linear number of bins, each of them may hold a constant number of heavy items. Therefore, we can not simply enumerate all configurations of the heavy items since there are exponential many of them. To reduce the number of the configurations to a polynomial, we classify the heavy items into a constant number of types (again, by discretization). For a fixed configuration of the heavy items, using the Poisson approximation, we reduce SBP to a multidimensional version of the multi-processors scheduling problem, called the vector scheduling problem, for which a PTAS is known [17].

Stochastic Knapsack
The deterministic knapsack problem is a classical and fundamental problem in combinatorial optimization. In this problem, we are given as input a set of items each associated with a size and a profit, and our objective is to find a maximum profit subset of items whose total size is at most the capacity C of the knapsack. In many applications, the size and/or the profit of an item may not be fixed values and only their probability distributions are known to us in advance. The actual size and profit of an item are revealed to us as soon as it is inserted into the knapsack. For example, suppose we want to schedule a subset of n jobs on a single machine by a fixed deadline and the precise processing time and profit of a job are only revealed until it is completed. In the following, we use terms items and jobs interchangeably. If the insertion of an item causes the knapsack to overflow, we terminate and do not gain the profit of that item. The problem is broadly referred to as the stochastic knapsack (SK) problem [24,13,35]. Unlike the deterministic knapsack problem for which a solution is a subset of items, a solution to SK is specified by an adaptive policy which determines which item to insert next based on the remaining capacity and and the set of available items. In contrast, a non-adaptive policy specifies a fixed permutation of items.
A significant generalization of the problem, introduced in [35], considers the scenarios where the profit of a job can be correlated with its size and we can cancel a job during its execution in the policy. No profit is gathered from a canceled job. This generalization is referred as Stochastic Knapsack with Correlated Rewards and Cancelations (SK-CC). Stochastic knapsack and several of its variants have been studied extensively by the operation research community (see e.g., [25,26,5,4]). In recent years, the problem has also attracted a lot of attention from the theoretical computer science community where researchers study the problems from the perspective of approximation algorithms [24,13,35].
Our Results: For SK, Bhalgat, Goel and Khanna [13] obtained a (1 + ǫ)-approximation using ǫ extra capacity. We obtain an alternative proof of this result, using the Poisson approximation technique. The running time of our algorithm is n O(f (ǫ)) where f (ǫ) = 2 poly(1/ǫ) , improving upon the n O(f (ǫ)) O(f (ǫ)) running time in [13]. Our algorithm is also considerably simpler. Theorem 1.5. For any ǫ > 0, there is a polynomial time algorithm that finds a (1+ ǫ)-approximate adaptive policy for SK when the capacity is relaxed to (1 + ǫ)C.
Our next main result is a generalization of Theorem 1.5 to SK-CC where the size and profit of an item may be correlated, and cancelation of item in the middle is allowed. The current best known result for SK-CC is a factor 8 approximation algorithm by Gupta, Krishnaswamy, Molinaro and Ravi [35], base on a new time-indexed LP relaxation. We remark that it is not clear how to extend the enumeration technique developed in [13] to handle cancelations (see a detailed discussion in Section 5). Theorem 1.6. For any ǫ > 0, there is a polynomial time algorithm that finds a (1+ ǫ)-approximate adaptive policy for SK-CC when the capacity is relaxed to (1 + ǫ)C.
We use SK-Can to denote the stochastic knapsack problem where cancelations are allowed (the size and profit of an item are not correlated). Based on Theorem 1.6 and the algorithm in [12], we obtain a generalization of the result in [12] as follows.
Theorem 1.7. For any ǫ > 0, there is a polynomial time algorithm that finds a (2+ ǫ)-approximate adaptive policy for SK-Can.
Bayesian Online Selection: The technique developed for SK-CC can be used to obtain the following result for an interesting variant of SK, where the size and the profit of an item are revealed before the decision whether to select the item is made. We call this problem the Bayesian online selection problem subject to a knapsack constraint (BOSP-KC). The problem falls into the framework of Bayesian online selection problems (BOSP) formulated in [42]. BOSP problems subject to various constraints have attracted a lot of attention due to their applications to mechanism design [36,16,2,42]. BOSP-KC also has a close relation with the knapsack secretary problem [6] (See Section 6 for a discussion).
Theorem 1.8. For any ǫ > 0, there is a polynomial time algorithm that finds a (1+ ǫ)-approximate adaptive policy for BOSP-KC when the capacity is relaxed to 1 + ǫ.
As a byproduct of our discretization procedure, we also give a linear time FPTAS for the stochastic knapsack problem where each item has unlimited number of copies (denoted as SK-U), if we relax the knapsack capacity by ǫ. The problem has been studied extensively under different names and optimal adaptive policies are known for several special distributions [25,26,5,4]. However, no algorithmic result about general (discrete and continuous) distributions is known before. The details can be found in Appendix D.
Our techniques: SK-CC and BOSP-KC are more technically interesting since their solutions are adaptive policies, which do not necessarily have polynomial size representations. So it is not even clear at first sight where to use the Poisson approximation technique. As before, we first discretize the distributions. In the second step, we attempt to enumerate all possible block-adaptive policies, a notion which is introduced in [13]. In a block-adaptive policy, instead of inserting them items one by one, we insert the items block by block. In terms of the decision tree of a policy, each node in the tree corresponding to the insertion of a block of items. A remarkable discovery in [13] is that there exists a block-adaptive policy that approximates the optimal policy and has only O(1) blocks in the decision tree (the constant depends on ǫ) for SK. However, their proof does not easily generalize to SK-CC. We extend their result to SK-CC with a essentially different proof, which might be of independent interest. Fixing the topology of the decision tree of the block-adaptive policy, we can enumerate the signatures of all blocks in polynomial time, and check for each signature whether there exists a block-adaptive policy with the signature using dynamic programming. Again, in the analysis, we use the Poisson approximation theorem to argue that two block adaptive policies with the same tree topology and signatures behave similarly.

Other Related Work
Recently, stochastic combinatorial optimization problems have drawn much attention from the theoretical computer science community. In particular, the two-stage stochastic optimization models for many classical combinatorial problem have been studied extensively. We refer interested reader to [57] for a comprehensive survey.
There is a large body of literature on EUM and TPM, especially for specific combinatorial problems and/or special utility functions. Loui [47] showed that the EUM version of the shortest path problem reduces to the ordinary shortest path (and sometimes longest path) problem if the utility function is linear or exponential. For the same problem, Nikolova, Brand and Karger [51] identified more specific utility and distribution combinations that can be solved optimally in polynomial time. Nikolova, Kelner, Brand and Mitzenmacher [52] studied the TPM version of shortest path when the distributions of the edge lengths are normal, Poisson or exponential. Nikolova [50] extended this result to an FPTAS for any problem for normal distributions, if the deterministic version of the problem has a polynomial time algorithm. Many heuristics for the stochastic shortest path problems have been proposed to deal with more general utility functions (see e.g., [48,49,11]). However, either their running times are exponential in worst cases or there is no provable performance guarantee for the produced solution. The TPM version of the minimum spanning tree problem has been studied in [38,30], where polynomial time algorithms have been developed for Gaussian distributed edges.
The bin packing problem is a classical NP-hard problem. It is well known that it is hard to approximate within a factor of 3/2−ǫ from a reduction from the subset sum problem. Alternatively, the problem admits an asymptotic PTAS, i.e., it is possible to find in polynomial time a packing using at most (1+ǫ)OPT+1 bins for any ǫ > 0 [29]. The stochastic model where all items follow the same size distribution have been studied extensively in the literature (see, e.g., [20,55]). However, these works require that the actual items sizes are revealed before put in the bins and their focus is to design simple rules that achieve nearly optimal packings.
Kleinberg, Rabani and Tardos [41] first considered the fixed set version of the stochastic knapsack problem with Bernoulli-type distributions. Their goal is to find a set of items with maximum total profit subject to the constraint that the overflow probability is at most a given parameter γ. They provided a polynomial-time O(log 1/γ)-approximation. For exponentially distributed items, Goel and Indyk [31] presented a bi-criterion PTAS. Chekuri and Khanna [18] pointed out that a PTAS for Bernoulli distributed items can be obtained using their techniques for the multiple knapsack problem. For Gaussian distributions, Goyal and Ravi [32] obtained a PTAS.
The adaptive stochastic knapsack problem and several of it variants have been shown to be PSPACE-hard [24], which implies that it is impossible in polynomial time to construct an optimal adaptive policy, which may be exponentially large and arbitrarily complicated. Dean, Goemans, and Vondrak [24] first studied SK from the perspective of approximation algorithms and gave an algorithm with an approximation factor of 3 + ǫ. In fact, their algorithm produces a non-adaptive policy (a permutation of items) which implies the adaptivity gap of the problem, the maximum ratio between the expected values achieved by the best adaptive and non-adaptive strategies, is a constant. Using the technique developed for the (1 + ǫ)-approximation using ǫ extra capacity, Bhalgat, Goel and Khanna [13] also gave an improved ( 8 3 +ǫ)-approximation without extra capacity. Stochastic multidimensional knapsack (also called stochastic packing) has been also studied [23,13,8]. The stochastic knapsack problem can be formulated as an exponential-size Markov decision process (MDP). Recently, there is a growing literature on approximating the optimal policies for exponential-size MDPs in theoretical computer science literature (see e.g., [24,34,35,42]).
BOSP problems are often associated with the name prophet inequalities since the solutions of the online algorithms are often compared with "the prophet's solutions" (i.e., the offline optimum). The prophet inequalities were proposed in the seminal work of Krengel and Sucheston [43] and have been studied extensively since then. The secretary problem is a also classical online selection problem introduced by Dynkin [28]. Recently, both problems enjoy a revival due to their connections to mechanism design and many generalizations have been studied extensively [7,6,37,15,39,36,16,2,42]. We note that performances in all the work mentioned above are measured by comparing the solutions of the online policies with the offline optimum. Complementarily, our work compares our policies with the optimal online policies.
Finally, we would like to point out that Daskalakis and Papadimitrious [21] recently used Poisson approximation in approximating mixed Nash Equilibria in anonymous games. However, the problem and the technique developed there are very different from this paper.
Prior Techniques: As mentioned in the introduction, it is a common challenge to deal with the convolution of a set of random variables (directly or indirectly). To address this issue, a number of techniques have been developed in the literature. Most of them only work for special distributions [47,51,52,31,33,50], such as Gaussian, exponential, Poisson and so on. There are much fewer techniques that work for general distributions. Among those, the effective bandwidth technique [41] and the linear programming technique [24,8,35] have proven to be quite powerful for many problems, but the approximation factors obtained are constants at best (no exception is known so far). In order to obtain (multiplicative/additive) PTAS, two techniques are developed very recently: one is the discretization technique [13] for the stochastic knapsack problem and the other is the Fourier decomposition technique [45] for the utility maximization problem. However, both of them have certain limitations. The discretization technique [13] typically reduces a stochastic optimization problem to a complicated enumeration problem (in some sense, it is an O(log n)dimensional optimization problem since the distributions are discretized into O(log n) equivalent classes). If the structure of the problem is different from or has more constraints than the knapsack problem, the enumeration problem can become overly complicated or even intractable (for example, the SK-CC problem or the TPM version of the shortest path problem). In the Fourier decomposition technique [45], due to the presence of complex numbers, we lose certain monotonicity property in the reduction from the stochastic optimization problem to an deterministic optimization problem, thus it is impossible to obtain something like Theorem 1.2 using that technique.

Expected Utility Maximization
We prove Theorem 1.1 and Theorem 1.2 in this section. For each item b ∈ B, we use π b (.) to denote probability distribution of the weight X b of b. We use F ⊂ 2 B to denote the set of feasible solutions. For example, in the minimum spanning tree problem, B is the set of edges and F is the set of all spanning trees. Since we are satisfied with an ǫ additive approximation, we can assume w.l.o.g. the utility function By scaling, we can assume C = 1 and 0 ≤ µ(x) ≤ 1 for x ≥ 0. We also assume µ is α-Lipschitz where α is a constant that does not depend on ǫ. It is straightforward to extend our analysis to the case where α depends on ǫ. We first consider the general EUM problem and then focus on the EUM-Mono problem where the utility function is monotone nonincreasing.
We start by bounding the total expected size of solution S if µ(S) is not negligible. This directly translates to an upper bound of the number of items with large expected weight in S, which we handle separately. The proof is fairly standard and can be found in the appendix.
≤ 3α/ǫ. Let S * denote the optimal feasible set and OPT the optimal value. If OPT = E[µ(X(S * ))] ≤ ǫ, then any feasible solution achieves the desired approximation guarantee since OPT − ǫ ≤ 0. Hence, we focus on the other case where OPT > ǫ. We call an item b heavy item if E[X b ] > ǫ 10 . Otherwise we call it light. By Lemma 2.1, we can see that the number of heavy items in S * is at most 3 ǫ 11 .
Enumerating Heavy Elements We enumerate all possible set of heavy items with size at most 3/ǫ 11 . There are at most n 3/ǫ 11 such possibilities. Suppose we successfully guess the set of heavy items in S * . In the following parts, we mainly consider the question that given a set H of heavy items, how to choose a set L of light items such that their union S is a feasible solution, and E[µ(S)] is close to optimal.
Dealing with Light Elements Unlike heavy items, there may be many light items in S * , which makes the enumeration computationally prohibitive. Our algorithm consists of the following steps. First, we discretize the weight distributions of all items. After the discretization, there are only a constant number of discretized weight values in [0, C]. The discretized distribution can be thought as a vector with constant dimensions. Then, we argue that for a set L of light items (with certain conditions), the distribution of the sum of their discretized weights behaves similarly to a single item whose weight follows a compound Poisson distribution. The compound Poisson distribution is completely determined by a constant dimensional vector (which we call the signature of L) which is the sum of the distribution vectors in L. The argument is carried out by using the Poisson approximation theorem developed by Le Cam [44]. Then, our task amounts to enumerating all possible signatures, and checking whether there is a set L of light items with the signature and H ∪ L is a feasible set in F. Since the number of possible signatures is polynomial, our algorithm runs in polynomial time. Now, we present the details of our discretization method.

Discretization
In this section, we discuss how to discretize the size distributions for items, using parameter ǫ.
Our discretization is similar in many parts to the one in [13], however, ours is much simpler.
For item b, we say b realizes to a "large" size if X b > ǫ 4 . Otherwise we say b realizes to a "small" size. The discretization consists of two steps. We discretize the small size region in step 1 and the large size region in step 2. We use X b to denote the size after discretization and π b its distribution.
Step 1. Small size region In the small size region, X b follows a Bernoulli distribution, taking only values 0 and ǫ 4 . The probability values Pr We create a mapping between X b and X b as follows: In the appendix, we discuss the case where such value d does not exist.
Step 2. Large size region If X b realizes to a large size, we simply discretize it as follows: Let we round a large size down to a multiple of ǫ 5 ). The above two discretization steps are used throughout this paper. We denote the set of the discretized sizes by S = {s 0 , s 1 , . . . , s z−1 } where s 0 = 0, s 1 = ǫ 5 , s 2 = 2ǫ 5 , s 3 = 3ǫ 5 , . . . , s z−1 . Note that s 1 = ǫ 5 , . . . , s 1/ǫ−1 = ǫ 4 − ǫ 5 are also included in S, even though their probability is 0. It is straightforward to see that |S| = z = O(C/ǫ 5 ). This finishes the description of the discretization.
The following lemma states that for a set of items, the behavior of the sum of their discretized distributions is very close to that of their original distributions.
Proof. For a set S, we use P S (x) and P S (x) to denote the CDFs of X(S) and X(S) respectively. We first observe that The second equation follows from applying integration by parts and the last is because µ is α-Lipschitz. From Lemma 2.2, we can see that In fact, the above can be seen as follows: The proof for the other direction is similar and we omit it here.

Poisson Approximation
For an item b, we define its signature to be the vector For a set S of items, its signature is defined to be the sum of the signatures of all items in S, i.e., We use Sg(S) k to denote the kth coordinate of Sg(S). By Lemma 2.1, Thus Sg(S) k ≤ 3/ǫ 5 for all k. Therefore, the number of possible signatures is bounded by 3n/ǫ 11 |S|−1 , which is polynomial in n.
For an item b, we let X b be the random variable that Pr X b = s = π b (s) for s = s 1 , s 2 , . . . , s z−1 , and X b = 0 with the rest of the probability mass. Similarly, we use X(S) to denote b∈S X b for a set S of items.
The following lemma shows that it is sufficient to enumerate all possible signatures for the set of light items.
Lemma 2.4. Let S 1 , S 2 be two sets of light items such that Sg(S 1 ) = Sg(S 2 ) and E X(S 1 ) ≤ 3/ǫ, E X(S 2 ) ≤ 3/ǫ. Then, the total variation distance between X(S 1 ) and X(S 2 ) satisfies The following Poisson approximation theorem by Le Cam [44], rephrased in our language, is essential for proving Lemma 2.4. Suppose we are given a K- Let Y be the compound Poisson distribution corresponding to vector V . Then, the total variation distance between X and Y can be bounded as follows: Proof of Lemma 2.4: By definition of X b , we have that ∆ X b , X b ≤ ǫ/n for any item b. Since S 1 and S 2 contains at most n items, by the standard coupling argument, we have that If we apply Lemma 2.5 to both X(S 1 ) and X(S 2 ), we can see they both correspond to the same compound Poisson distribution, say Y , since their signatures are the same. Moreover, since the total variation distance is a metric, we have that The last equality holds since for any light item b,

Approximation Algorithm of EUM
Now, everything is in place to present our approximation algorithm and the analysis.  Proof of Theorem 1.1: Assume the optimal feasible set is S * = H * ∪ L * where items in H * are heavy and items in L * are light. Assume our algorithm has guessed H * correctly. Since there is a pseudopolynomial algorithm, we can find a set L of light items such that Sg(L) = Sg(L * ). By Lemma 2.4, we know that ∆ X(L), X(L * ) = O(ǫ). Therefore, we can get that Moreover, we have that where π S is the PDF for X(S). It is time to derive our final result: The inequality follows from Lemma 2.3 and 2.4.

Approximation Algorithm for EUM-Mono
We prove Theorem 1.2 in this subsection. Recall that EUM-Mono is a special case of EUM where the utility function µ is monotone nonincreasing. The algorithm is the same as that in EUM except we adopt the new step (a), as follows.
(a) Try to find a set L of light items such that H ∪ L ∈ F (H ∪ L is feasible) and Sg(L) ≤ (1 + ǫ 6 )Sg (coordinatewise); Lemma 2.6. We are given two vectors V 1 ≤ V 2 (coordinatewise). Y 1 and Y 2 are random variables following CPD corresponding to V 1 and V 2 , respectively. Then, Y 2 stochastically dominates Y 1 .
Proof. We are not aware of an existing proof of this intuitive fact, so we present one here for completeness. The lemma can be proved directly from the definition of CPD, but the proof is tedious. Instead, we use Lemma 2.5 to give an easy proof as follows: Consider the sum X of a large number N of nonnegative random variables {X i } i=1,...,N , each X i having a very small expectation. Suppose i Sg(X i ) = V 1 . As N goes to infinity and each E[X i ] goes to 0, the distribution of X approaches to that of Y 1 since their total variation distance approaches to 0. We can select a subset S of {X i } i=1,...,N so that i∈S Sg(X i ) = V 2 . So, the sum of the subset, which approaches to Y 2 in the limit, is clearly stochastically dominated by total sum X.
Lemma 2.7. Let S 1 , S 2 be two sets of light items with E X(S 1 ) ≤ 3/ǫ and E X( , then we have that for any β > 0 Proof. Let Z 1 and Z 2 be the compound Poisson distribution (CPD) corresponding to Sg(S 1 ) and . By the standard coupling argument, we can see that

This is because Pr
. Therefore the total variation distance of N and N ′ can be bounded by O(ǫ).
Proof of Theorem 1.2: The proof is similar to the proof of Theorem 1.1. Assume the optimal feasible set is S * = H * ∪ L * where items in H * are heavy and items in L * are light. Assume our algorithm has guessed H * correctly. Since there is a multidimensional PTAS, we can find a set L of light items such that Sg(L) ≤ (1 + ǫ 6 )Sg(L * ). By Lemma 2.7, we know that for any . Therefore, we can get that for any β > 0, . Now, we can bound the expected utility loss for discretized distributions: Finally, we can show the performance guarantee of our algorithm: The last inequality follows from Lemma 2.3.

Stochastic Bin Packing
Recall that in the stochastic bin packing (SBP) problem, we are given a set of items B = {b 1 , b 2 , . . . , b n } and an overflow probability 0 < p < 1. The size of each item b i is an independent random variable X i . The goal is to pack all the items in B into bins with capacity C, using as few bins as possible, such that the overflow probability for each bin is at most p. The main goal of this section is to prove Theorem 1.3.
W.l.o.g., we can assume that p ≤ 1 − ǫ where ǫ is the error parameter. Otherwise, the overflow probability is relaxed to p + ǫ ≥ 1, and we can pack all items in a single bin. Let the number of bins used in the optimal solution be m. In our algorithms, we relax the bin size to C + O(ǫ), which is less than 2C. W.l.o.g., we assume the support ofX i is [0, 2C]. From now on, assume that our algorithm has guessed m correctly. We use B 1 , B 2 , . . . , B m to denote the bins.

Discretization
We first discretize the size distributions for all items in B, using parameter ǫ, as described in Section 2.1. Denote the discretized size of b i by X i . We We need to further discretize the size distributions of the heavy items. We round down the probabilities of X i taking each nonzero value to multiples of ǫ 22  where N k ∈ N is the number of heavy items in S following the discretized size distribution Π k , k = 1, 2, . . . , |H|. Suppose we pack all items in S into one bin. By Lemma 2.1 and the assumption that p ≤ 1 − ǫ, E X(S) ≤ 3/ǫ. So, we can pack at most O(ǫ −16 ) heavy items into a bin. Therefore, the number of possible arrangements for a bin is bounded by |H|+O(ǫ −16 )

|H|
, which is a constant. Let the signature of a light item b be Sg(b) = π b (s i ) 1≤i≤|S|−1 (Note that the definition is slightly different from the previous one). The signature of the a set S of light items is defined to be Sg(S) = b∈S Sg(b). If S consists of both heavy and light items, we use Sg(S) as a short for Sg(L(S)). Moreover, for set S, we define the rounded signature to be Sg(S) : Sg(S) k = Sg(S) k · ǫ −6 · ǫ 6 for each k = 1, . . . , |S| − 1.
The configuration of a set S of items is defined to be Cf(S) = Ar(S); Sg(S) . It is straightfor-ward to see the number of all configurations is bounded by which is still a constant. We

Our Algorithm
Before describing our algorithm, we need a procedure to solve the following multi-dimensional optimization problem: We are given an s-configuration Cf = (Ar 1 , Sg 1 ), (Ar 2 , Sg 2 ), . . . , (Ar m , Sg m ) , Our goal is to find a packing SOL = (S 1 , . . . , S m ) such that Ar(S i ) = Ar i and Sg(S i ) ≤ Sg i + ǫ 6 1 (where 1 = (1, . . . , 1)) for 1 ≤ i ≤ m or to claim that there is no packing SOL = (S 1 , . . . , S m ) such that Ar(S i ) = Ar i and Sg(S i ) ≤ Sg i for 1 ≤ i ≤ m. If we succeed in finding such a solution, we say Cf passes the test of feasibility, otherwise we say Cf fails the test.
Finding a solution such that Ar(S i ) = Cf i for all i is trivial. Now, we concentrate on the set of the light items, L(B). In fact, the problem for light items becomes a variant of the multidimensional bin packing problem, called the vector scheduling problem, which has been studied in [17]. For completeness, we sketch their approach, using our notations. We write a linear integer program, solve its LP relaxation and then round the solution to a feasible packing. We use the Boolean variables x ij to denote whether the light item b i is packed into bin B j . We have the integrality constraints x ij ∈ {0, 1} and they are relaxed to x ij ≥ 0 in the following LP relaxation: The following proposition states a well-known property for any basic solution of the LP.
Proposition 3.1. Any basic feasible solution to the LP has at most (|S| − 1) · m light items that are packed fractionally into more than one bins.
If the above LP has no feasible solutions, we say Cf fails the test. Otherwise Cf passes the test, and we find a solution SOL as follows. First, we solve the LP and obtain a basic feasible solution. Let F be the set of light items that are fractionally packed into more than bins. By proposition for m ← 1 to n do // guess the number of bins in OPT for each s-configuration Cf = (Cf 1 , . . . , Cf m ) ∈ C do if Pr(Cf j , (1 + O(ǫ))C) ≤ p + O(ǫ), ∀j and Cf pass the feasibility test then Return the solution S obtained from the testing algorithm; Algorithm 2: Stochastic Bin Packing 3.1, |F | ≤ (|S| − 1) · m. We partition F arbitrarily into m subsets, each containing at most (|S| − 1) items, and then pack the k-th subset into the k-th bin. Since the expected size of a light item is less than ǫ 15 , π i (s k ) ≤ ǫ 11 for any i, k. Therefore, Sg(S j ) ≤ Sg j + (|S| − 1)ǫ 11 = Sg j + ǫ 6 1 for any j. We need one more notation to describe our algorithm. For a set of items S, let where X H = X H(S) and Y L is the CPD corresponding to Sg(S) (according to Lemma 2.5) . By definition, if two sets S 1 and S 2 have the same configuration, Pr(Cf(S 1 ), C) = Pr(Cf(S 2 ), C). Now, everything is ready to state our algorithm. We simply enumerate all s-configurations in C. For each s-configuration Cf, we first compute Pr(Cf(S), C). If it is at most p + O(ǫ), we run the feasibility test. If Cf passes the test, the returned solution is our final packing. The pseudocode of our algorithm is described in Algorithm 2.
The algorithm clearly runs in polynomial time since the number of s-configurations is polynomial and the feasibility test also runs in polynomial time.

Analysis
The following lemma shows that we can approximate the overflow probability of a bin given its configuration. Therefore, it is sufficient to enumerate all possible configurations for each bin to find an approximation solution. We can also show ∆ Y L , Y L = O(ǫ) since Sg(S) − Sg(S) ∞ = O(ǫ 6 ). Therefore, This finishes the proof of the lemma.
The following lemma shows that we can approximate the overflow probability even if only an approximate signature is given. Lemma 3.3. For any two sets S 1 , S 2 such that Ar(S 1 ) = Ar(S 2 ) and Sg(S 1 ) ≤ Sg(S 2 ) + 3ǫ 6 Proof. Let Sg S = Sg(S 2 ) + 3ǫ 6 1. Let X H = X H(S 1 ) = X H(S 2 ) (since Ar(S 1 ) = Ar(S 2 )). Let Y 1 , Y 2 be the CPD corresponding to Sg(S 1 ) and Sg(S 2 ), respectively. Let Z, Z 1 , Z 2 be the CPD corresponding to Sg S , Sg(S 1 ) and Sg(S 2 ), respectively. Since Combining these facts together, we have that On the other hand, Sg(S 1 ) ≤ Sg S . So, by Lemma 2.6, Z 1 is stochastically dominated by Z. Therefore, we have that Combining these two results, we complete the proof. Now, we are ready to prove the main theorem of this section.
Proof of Theorem 1.3: Suppose the optimal solution OPT = (O 1 , . . . , O m ) uses m bins. The algorithm will enumerate its s-configuration Cf(OPT). Obviously, Cf(OPT) can pass the feasibility test. Let SOL = (S 1 , . . . , S m ) be the solution obtained by the LP rounding procedure, which guarantees that Sg(S j ) ≤ Sg(O j ) + 3ǫ 6 1, for any j. By Lemma 3.3 and Lemma 2.2, for 1 ≤ j ≤ m, The proof of the theorem is completed.
Run Algorithm 2 to get a packing S 1 , S 2 , . . . , S m ; for each bin B i do Pack each item in B i into a new bin B i,j ; while there exist two bins Merge B i,j 1 and B i,j 2 into one bin; Algorithm 3: Stochastic Bin Packing without Relaxing the Overflow Probability

A 3-Approximation without Relaxing the Overflow Probability
For SBP, we can find a 3-approximation within polynomial time without relaxing the overflow probability p, for any constant 0 < p < 1. First, we note that for any set of items, we can estimate the overflow probability by using the technique for counting knapsack solutions [27]. In fact, since we assume p is constant, we can simply use the Monte Carlo method to get an estimate with additive error ǫ with high probability by randomly taking O(log n) samples. For each item set S we use P (S) to denote the estimate probability of Pr[X(S) ≥ C + ǫ] Then, we have with high probability (1 − 1 n c for some constant c) when Pr[X(S) ≥ C + ǫ] ≥ p. We first run Algorithm 2 and obtain a packing B 1 , . . . , B m where S i is the set of items in B i and m ≤ OPT. We know that Pr[X(B i ) ≥ C + ǫ] ≤ p + ǫ. Then, for each B i , we distribute the items in B i to at most 3 new bins such that the overflow probability is not at most p for each new bin. Let ǫ be any constant less than p−p 2 1+4p . The pseudo-code of our algorithm is described in Algorithm 3. Proof of Theorem 1.4: Now we claim that for each B i , the while loop (a) produces at most 3 new bins. The approximation factor of 3 follows immediately since m ≤ OPT. Now, we prove the claim. For each bin B i,j output by the algorithm, either it packs only one item with overflow probability at most p (otherwise, there is no feasible solution), or P (B i,j ) ≤ (1 − ǫ)p. Therefore, the true overflow probability of B i,j is at most p.
We still need to show the while loop terminates with at most 3 bins. Suppose for contradictor that it outputs at least 4 bins, and B i,1 , B i,2 , B i,3 , B i,4 are four of them. Then, for any ǫ < p−p 2 1+4p . This contradicts to the fact that Pr[X(B i ) ≥ C + ǫ] ≤ p + ǫ.

Stochastic Knapsack
An instance of the stochastic knapsack problem can be specified by a tuple (π, C), where π = {π 1 , π 2 , ..., π n }. π i is the joint distribution of size and profit for item b i , ∀i. C is the capacity of the knapsack. W.l.o.g., we can assume 1 2 ≤ C ≤ 2 and the size of each item is distributed between 0 and 2C. The relaxed knapsack capacity C + O(ǫ) should be less than 2C. The distributions for different items are mutually independent. We let random variables X b and P b denote the size and profit of item b. We use π b to denote the probability distribution of X b , i.e., π b (w) = Pr[X b = w]. W.l.o.g., we can assume that for each item, we obtain a fixed profit for each realized size. For each item b, we define the effective profit function 3 p b to be We use the shorthand notation p b (I) = w∈I p b (w) for any I ⊆ [0, C].
Policies: The process of applying a policy σ on an instance (π, C) can be represented as a decision tree T (σ, π, C). Each node v in T σ corresponds to placing an item in the knapsack. Each edge e = (v, u) in T σ (v is the parent) corresponds to a size realization of v. We use w e , π e to denote the corresponding size and probability of e, respectively. We also use T σ to denote T (σ, π, C) when the context is clear.
We call the path from root to v in T σ the realization path of v, and denote it by R(v). For a node v, we denote the occupied capacity before inserting v as W (v) = e∈R(v) w e and the probability of reaching v as Φ(v) = e∈R(v) π e . Denote by R σ the random set of items that σ packs.
We use P(σ, π, C) to denote the expected profit that the policy σ can obtain with the given distributions π and total capacity C. We also use the shorthand notation P(σ) or P(T σ ) if the context is clear. Recursively define the expected profit of the subtree T v rooted at v to be The expected profit P(σ) of policy σ is simply P(the root of T σ ). We use OPT to denote the expected profit of the optimal adaptive policy. We note that in some steps of our algorithm, we assume the knowledge of OPT. In fact, any constant approximation of OPT, which for example can be obtained using the approximation algorithm in [24] for SK or the one in [35] for SK-CC, would suffice for our purpose.
As we mentioned before, the problem is PSPACE-hard and the optimal policy may be exponentially large. In order to reduce search space, we need to focus on a very special class of policies, in which it is possible to find a nearly optimal policy efficiently and this policy is also close to the optimal policy for the original problem. We start with some simple properties shown in Bhalgat et al. [13] 4 . W.l.o.g., we also assume that all (optimal or near optimal) policies σ considered in this paper have the following property: Otherwise, replacing the subtree T u with T v increases the profit of the policy σ. This also implies that for any v ∈ T σ , P(v) ≤ P(σ).  [13]). For any policy σ on instance (π, C), there exists a policy σ ′ such that P(σ ′ , π, C) = (1 − O(ǫ))P(σ, π, C) and P2. for any realization path R in T (σ ′ , π, C), v∈R E[X v ] = O(C/ǫ).

Discretization
In this section, we discuss how to discretize the size and profit distributions for items in B, using parameter ǫ. W.l.o.g., we assume that the range of X b is [0, 2C) for any item b. The discretization of the size distributions is the same as the one in Section 2.1. We also need to discretize the profit distributions. For each item b and w ∈ [0, 2C], we use D b (w) to denote the discretized size of w This finishes the description of the discretization step We need the notion of canonical policies introduced in [13]. A policy σ is a canonical policy if it makes decisions based on the discretized sizes of items inserted, rather than their actual sizes. A canonical policy stops inserting items when the total discretized size of items inserted exceeds the knapsack capacity C. Before that, it attempts to insert items even if the total actual size overflows. No profit from those items can be collected. In this following lemma, we show it suffices to only consider canonical policies. The proof is similar to that of Lemma A.5 in [13], which can be found in the appendix. Due to the presence of the correlations between profits and sizes, we need to be more careful in bounding the profit loss.

Block-Adaptive Policies
To further reduce the search space, Bhalgat et al. [13] discovered a very specific class of canonical policies, called block-adaptive policies and showed it is sufficient to restrict the search to this set if we are satisfied with a nearly optimal policy. In a block-adaptive policy, instead of inserting one item at a time, we insert a set of items together each time. This set of items is called a block. A block-adaptive policy σ can also be thought as a decision tree T σ where each node in the tree corresponds to a block. Each edge incident on a vertex corresponds to a realization of the sum of the discretized sizes of all items in the block.
It has been shown in [13] that for SK, from an optimal (or nearly optimal) adaptive canonical policy σ, we can construct a block adaptive policy (with some other nice properties), from which we can get almost as much profit as from σ, as in the following Lemma. B3. Each block M with more than one items satisfies that b∈M E X b ≤ ǫ 13 . 5 In Section 5.1, we provide a proof for the generalization of the above lemma to SK-CC.

Poisson Approximation
To search for the (nearly) optimal block-adaptive policy, we want to enumerate all possible structures for a block. In [13], this is done by enumerating all different combinations of the profit contributions from O(log n) equivalence classes of items, using the technique developed in [18]. Instead, we enumerate all possible signatures of a block, similar to what we have done in Section 2. Since we consider correlated profits and sizes, a signature needs to reflect the profit distribution as well as the size distribution. Formally, for an item b, we define the signature of b to be and π b (s) = π b (s) · n ǫ 23 · ǫ 23 n for any s ∈ S. For a block M of items, we define the signature of M to be We denote the "zero size probability" of M to be π 0 M = Pr X(M ) = 0 . The following lemma shows that it is sufficient to enumerate all signatures for all blocks in a block-adaptive policy.  Proof. For ease of notation, we use T 1 to denote T σ b and T 2 the tree obtained by replacing M 1 with M 2 . Let P(M 2 ) be the expected profit we can get from M 2 with a knapsack capacity C ′ . First, we show the following two useful results. It is straightforward to verify the above results for the case where both M 1 and M 2 have only one item, from the definition of signatures. Now, we focus on the case where M 1 has more than one items. The case where M 2 has more than one items is the same. By Lemma 4.3 B3, , and π 0 M 2 ≥ 1 − 3ǫ 9 . Suppose we insert the items in M 1 one by one. For any item b ∈ M 1 , with probability at least π 0 M 1 , the remaining capacity before inserting b is C ′ (all previous items realized to zero size). So the expected profit we can get from b is at least π 0 We also have that Similarly, we can show that Since Sg(M 1 ) = Sg(M 2 ) = Sg M , we have that Linking these inequalities together, we obtain (a). On the other hand, since 13 and π M 1 (s) = π M 2 (s) for any s, we can show (b) holds also by following the same proof as that of Lemma 2.4, which we do not repeat here.
Let v s be the child of M 1 corresponding to size realization s, and T s be the subtree rooted at

Finding a Nearly Optimal Block-Adaptive Policy
We have shown it suffices to enumerate over all topologies of the decision trees along with all possible signatures for each block (the number of all possibilities is n O(f (ǫ)) = n 2 poly(1/ǫ) ) in order to find a nearly optimal block-adaptive policy. Now, we show how to find a nearly optimal blockadaptive policy with a given tree topology along with the signatures for all blocks, using dynamic programming. The dynamic program is fairly standard and we present a sketch here. Assume the tree topology has been fixed. A configuration C in the dynamic program is a set of signatures, each corresponding to a block in the tree. As we have shown, the number of configurations is poly(n). We use DP(i, C) = 1 to denote the fact that we can reach configuration C using a subset of {b 1 , . . . , b i }. Otherwise, DP(i, C) = 0. Initially, DP(0, 0) = 1. We compute all DP(i, C) values in an lexicographically increasing order of (i, C). The value of DP(i, C) can be computed from the values of DP(i − 1, C ′ ) for all C ′ ≤ C (coordinatewise). In fact, this step can be done as follows. Suppose we want to compute DP(i, C). We can decide to place item b i in a few blocks in the decision tree. The constraint here is no two blocks where we place b i have an ancestor-descendant relationship. Since the size of tree is f (ǫ) = (1/ǫ 5 ) O(1/ǫ 14 ) , so the number of possible ways of adding item b i is 2 f (ǫ) which is (still) a constant. For a particular placement of b i , we subtract the contribution of b i from configuration C (i.e., subtract Sg(b i ) from the vectors in C corresponding to the blocks where we place b i ), resulting another configuration C ′ . We let DP(i, C) ← max(DP(i, C), DP(i − 1, C ′ )). Since the number of tree topologies is a constant, the number of configurations is n f (ǫ) and computing each DP(i, C) values takes a constant time, the overall running of our algorithm is O(n f (ǫ) ), which improves upon the n O(f (ǫ)) O(f (ǫ)) running time in [13]. Now we have all necessary components to show the main theorem of this section.
Proof of Theorem 1.5: Suppose σ * is the optimal policy. The optimal expected profit is denoted as P(σ * , π, C) = OPT. Given an instance (π, C), the first step is to compute the discretized distribution π. Then we use the dynamic program to find a nearly optimal block adaptive policy σ for ( π, (1 + 5ǫ)C). By result 1 of Lemma 4.2, there exists a canonical policy σ such that By Lemma 4.3, there exists a block adaptive policy σ b such that P(σ b , π, (1+5ǫ)C) ≥ (1−O(ǫ))OPT. Since the configuration of σ b is enumerated at some step of the algorithm, our dynamic program is able to find a block adaptive policy σ with the same configuration (the same tree topology and the same signatures for corresponding nodes). By Lemma 4.4, we can see that By result 2 of Lemma 4.2, P(σ, π, (1 + 4ǫ)(1 + 5ǫ)C) ≥ (1 − O(ǫ))P(σ, π, (1 + 5ǫ)C) ≥ (1 − O(ǫ))OPT.
Hence, the proof of the theorem is completed.

Stochastic Knapsack with Correlations and Cancelations
Recall in the stochastic knapsack problem with correlations and cancelations (SK-CC), we can cancel a job in the middle and we gain zero profit from a canceled job. If we decide to cancel job b after running for t time units, job b can be thought as a job b t with running time Since we consider discrete time distributions, it only makes sense to cancel a job after a discrete point with nonzero probability mass. Suppose the size of the support of each time distribution is bounded by m. Therefore, for each job b, we can use a set of m jobs to represent all possible cancelations of b, and in each realization path, we are allowed to choose at most one job from the set. In fact, we solve the following more general problem. We have n sets of items, B i , i = 1, 2, ..., n. Each set B i consists of several items b i1 , b i2 , .... Our goal is to find a policy that packs at most one item from each item set B i to the knapsack with capacity C such that the expected profit is maximized. We call this problem the generalized stochastic knapsack problem, denoted as GenSK.
It is not clear how to use the technique in Bhalgat et al. [13] to handle the above problem. In fact, they discretize all (size) probability distributions into q = O(log n) equivalent classes and enumerate all combinations of the profit contributions from different classes in each block. For this purpose, they adopt the technique developed in [18] to reduce the number of combinations to a polynomial. Once the profit contribution from a class to a block is fixed, the actual set of items assigned into that block can be easily determined in a greedy manner (items with larger profit should be packed into the blocks that are closer to the root). However, in SK-CC, B i may contain items from several classes. Assigning an item in B i to a block would prevent us from assigning any other items in B i to the same block and its descendants. Such dependency makes the item assignment very complicated (for a fixed combination) and it is not clear to us how to do this in polynomial time. However, our technique can be easily extended to SK-CC.

Block-Adaptive Policies
In this section, we show that Lemma 4.3 also holds for GenSK (thus also for SK-CC). We note that the proof in [13] does not generalize to GenSK and we need to modify the proof in some essential way. We note that our proof works even when there are arbitrary precedence or cardinality constraints imposed on the items. In fact, any realization path of the constructed block-adaptive policy corresponds to some realization path of the original policy σ. The idea of the proof may be useful in showing the existence of nearly optimal block-adaptive policies for other problems, thus may be of independent interest.
Proof. For any node v in the decision tree T σ , we define the leftmost path of v to be the realization path which starts at v, ends at a leaf, and consists of only edges corresponding to size zero. For any node v and size s ∈ S, we use v s to denote the s-child of v, that is the child of v corresponding to the size realization s. We define the segment starting with node v (denoted as seg(v)) in T σ as the maximal prefix of the leftmost path of v such that: 2. For any two nodes u, w ∈ seg(v), and any size s, |P(T us ) − P(T ws )| ≤ ǫ 5 OPT.
We partition T σ into segments as follows. We say a node v is a starting node if v is a root or v corresponds to a non-zero size realization of its parent. For each starting node v, we greedily partition the leftmost path of v into segments, i.e., delete seg(v) and recurse on the remaining part. Fix a particular root-to-leaf path R. Let us bound the number of segments on R. Suppose we are at node u, which is a node in seg(v), and the next node we are about to visit is w which is not in seg(v). We know that one of the following events must happen: 1. w corresponds to a non-zero size realization of u;

2.
u ′ ∈seg(v)∪{w} E X(u ′ ) > ǫ 13 ; 3. For some size s, |P(T vs ) − P(T ws )| > ǫ 5 OPT. Now, we are ready to describe the algorithm, which takes a canonical policy σ as input, and packs items into the knapsack in a block-adaptive way. For any segment seg(v), we use l(v) to denote the last node in seg(v). Similar to the argument in [13], we use two knapsacks, the main knapsack with capacity C and the auxiliary knapsack with capacity ǫC.
1. Initially, S = ∅. S represents the auxiliary knapsack. 2. We start at the root of T σ . repeat

3.1
Suppose we are at node v in T σ . Add the items in seg(v) to the main knapsack one by one until some node u realizes to a nonzero size, say s.

3.2
Add all remaining items in seg(v) to the auxiliary knapsack S.

3.3
Visit node l(v) s , the s-child of the last node of seg(v).

3.4
If all nodes in seg(v) realize to size 0, visit l(v) 0 . until A leaf in T σ is reached. 4. If the auxiliary knapsack overflows, discard the entire profit.
We can see that the set of items the algorithm attempts to insert always corresponds to some realization path in the original policy σ. Hence, the algorithm packs at most one item from each item set B k . We have shown that B1 holds. Properties B2 and B3 are straightforward from the definition of segments and the algorithm. Now we show that the expected profit that new policy can obtain is at least (1 − O(ǫ))OPT. Let us focus on the profit we collect from the main knapsack and ignore those from the auxiliary knapsack. We note that the main knapsack never overflows. Our algorithm deviates the policy σ whenever some node u in the middle of some segment seg(v) realizes to a nonzero size, say s. In this case, σ would visit u s , the s-child of u and follows T us from then on, but our algorithm visits l(v) s , the s-child of the last node of that segment, and follows T l(v)s . The expected profit loss in each such event can be bounded by |P(T us ) − P(T l(v)s )| ≤ ǫ 5 OPT. Suppose σ pays such a profit loss, and switches to visit l(v) s . Hence, σ and our algorithm always stay at the same node. Note that the number of edges corresponding to nonzero size realizations is at most C/ǫ 4 in any root-to-leaf path. So σ pays at most O(ǫ −4 ) times in any realization. Therefore, the total profit loss is at most O(ǫOPT).
Finally, we note that we may not be able to collect the profit from the main knapsack in every realization since the auxiliary knapsack may overflow, in which case we lose all the profit. An easy (but important) observation is that the decision of the policy is independent of the size realizations of the items in the auxiliary knapsack S. Therefore, we can think that the sizes of the items in S are realized after the execution of the algorithm. If S overflows, we lose the entire profit. Since there are at most C/ǫ 4 items realizes to a nonzero size, S is packed with items from at most C/ǫ 4 segments. By the first property of a segment, E[ X(S)] ≤ ǫ 9 C. By Markov's inequality, Pr[ X(S) > ǫC] ≤ ǫ 8 .

Finding a Nearly Optimal Block-Adaptive Policy
We need to modify the dynamic program to incorporate the constraint that at most one item from each B i can be packed. Now, we use DP(i, C) = 1 to denote the fact that we can reach configuration C using items from {B 1 , . . . , B i }, such that on each realization path, at most one item in B i can appear at most once. Suppose we want to compute the value of DP(i, C) for some i and configuration C. Suppose we have computed the values of DP(i − 1, C ′ ) for all C ′ ≤ C. We can decide to place items from B i in a few blocks in the decision tree. The only constraint here is that we can place at most one item from B i in each realization path. So the number of ways to do so is bounded by m f (ǫ) for f (ǫ) = 2 (1/ǫ 5 ) O(1/ǫ 14 ) , which is a polynomial of the input size. So the overall running time of the dynamic program is still a polynomial. The rest of the analysis is the same as before and we do not repeat it here.
In summary, we have the following theorem, from which Theorem 1.6 follows as a direct corollary.
Theorem 5.1. For any ǫ > 0, there is a polynomial time algorithm that finds a (1+ ǫ)-approximate adaptive policy for GenSK when the capacity is relaxed to 1 + ǫ.

SK-CC with Exponential Number of Realizations
We have assumed that the size distribution of each item has a polynomial size support. Now, we consider the case where the supports may be of exponential sizes (must be represented implicitly). The only assumption we make here is that for any item b i and time t, we can compute the signature of b t i in polynomial time. The catch is that even though there are exponential even infinite realizations, the number of possible signatures is bounded by a polynomial. Moreover, as we increase t, each coordinate of the signature of b t i changes monotonically, thus the same signature does not appear again. Hence, starting from t = 0, we can use binary search to identify the first point where the signature changes. Repeating this, we can find all different signatures for b, each corresponding to b t for some t, in polynomial time.
In the dynamic program, we only care the signature of an item, instead of an item per se. So we can let B i contain only those b t i s that correspond to distinct signatures. The size of B i is therefore bounded by a polynomial.
SK-CC without Relaxing the Capacity Combining this result and the algorithm developed in [12] we can give a (2 + ǫ)-approximation for SK-Can (Theorem 1.7). This improves the factor 8 approximation algorithm developed in [35]. We note the algorithm in [12] does not work for correlated sizes and profits. So whether there is (2 + ǫ)-approximation for SK-CC is still open. However, with mild assumptions on the size distributions, we can achieve an approximation factor of 2 for SK-CC (Theorem C.1). The details can be found in Appendix C.

Bayesian Online Selection
In this section, we consider the Bayesian online selection problem subject to a knapsack constraint (denoted as BOSP-KC). Our problem falls into the framework formulated in [42]. In BOSP-KC, we are given a set of items B = {b 1 , b 2 , . . . , b n } and a knapsack capacity C. Each item b i has a random size X i and a random profit P i . X i and P i can be correlated but different items are independent of each other. The (discrete) joint distribution π of X i and P i is the input to the problem, in the form of π i (x, p) = Pr(X i = x, P i = p). Let D i be the support of π i , i.e., D i = {(x, p) | π i (x, p) = 0}. An adaptive policy σ can choose an item b i ∈ B each time, view the size realization of X i , and then make a irrevocable decision whether to pack b i or not. If σ decides to pack b i into the knapsack (given the remaining capacity is sufficient), the profit P i is collected. Otherwise, no profit is collected, the remaining capacity does not change and we can not recall b i later. If the items arrive in a predetermined order, we call the problem the fixed order BOSP-KC problem.
Our problem is closely connected to the knapsack secretary problem [6] in the following sense. In the knapsack secretary problem, the size and the profit of each item are unknown in advance and the items arrive in a random order. When an item arrives, its size and profit become known to the decision maker and an irrevocable decision has to be made. Therefore, if we intentionally forget about the stochastic information and process the items in a random order, BOSP-KC becomes exactly the knapsack secretary problem, for which a constant factor competitive algorithm is known [6] 6 . The ability that we can adaptively choose the order of the items in BOSP-KC is very similar to the free order models of matroid prophet inequality [16] and matroid secretary [39].
In the remainder of this section, we focus on proving Theorem 1.8. First, we consider as a warmup an interesting special case where the profit of each item is a fixed value. In this case, we can show the following intuitive lemma. The proof can be found in the appendix. Lemma 6.1. Let σ be the optimal policy. Suppose σ chooses b as the next item to consider. and decides to discard b if X b realizes to t. Then σ should discard b if X b realizes to a larger size s ≥ t.
The above lemma suggests that at a particular stage, for an item b i , there is a cutoff point t such that we accept b if X i ≤ t, and reject b i otherwise. In this case, item b i is equivalent to an item with the size X t i and profit P t i , jointly distributed as follows: In fact, this viewpoint allows us to reduce BOSP-KC to GenSK. For each item b i , we create a set of items B i = {b t i } t where b t i represents the item b i with cutoff point t. The only requirement is that at most one item from B i can be packed in the knapsack. Since we assume discrete distributions, there are at most a polynomial number cutoff points. Hence, the size of GenSK instance we create is also bounded by a polynomial. Theorem 1.8 directly follows from Theorem 5.1. Now, we consider the general case where X i and P i are correlated. In this case, there is no single cutoff point as before. However, we can still reduce the problem to GenSK. Suppose we decide to consider b i at a particular stage, and decide to accept b i if and only if the realization (X i , P i ) ∈ D for some D ⊆ D i . We call D the acceptance set. Then, b i is equivalent to an item with the size X D i and profit P D i , jointly distributed as follows: (0, 0), Otherwise.
OPT p x C' 0 However, the GenSK instance created can be exponential in size since each subset D ⊆ D i corresponds to a distinct item in B i . We may reduce the size of B i by exploiting the simple observation that in any optimal policy, if (x, p) ∈ D, any (x ′ , p ′ ) with x ′ ≤ x and p ′ ≥ p (a realization with a smaller size and a larger profit) must be in D (we can use the same proof as Lemma 6.1 to show this). But the resulting size is still exponential. Now, we sketch an algorithm that reduces the size of B i to a polynomial and incurs a profit loss of at most O(ǫOPT). We modify the distribution π i as follows.
1. For any (x, p) ∈ D i such that x ≤ ǫC n , we move the probability mass at point (x, p) to point (0, p). This step affects the total size of all packed items by at most ǫC since there are at most n items.
2. For any (x, p) ∈ D i such that p ≤ ǫOPT n , we move the probability mass at point (x, p) to point (x, 0). This step affects the total profit by at most ǫOPT.
3. For other (x, p) ∈ D i , we move the probability mass at point (x, p) to point (x ′ , p ′ ) where x ′ is the largest value of the form ǫC n (1 + ǫ) k (for some k ∈ Z + ) that is at most x, and p ′ is the largest value of the form ǫOPT n (1 + ǫ) l (for some l ∈ Z + ) that is at most p. Obviously, this step affects the total size and total profit by at most a multiplicative factor 1 + ǫ. Now, the number of different sizes is at most log 1+ǫ n and the number of different profits is at most log 1+ǫ npmax OPT where p max is the maximum possible profit of any realization. We first assume p max is at most OPT. In this case, the size of D i is at most log 2 1+ǫ n = O(log 2 n) and the number of all subsets is 2 O(log 2 n) = n O(log n) , which is slightly larger than a polynomial. To reduce this number to a polynomial, the simple observation we made before comes in handy. That is if an optimal policy accept a realization, it must accept any realization with a smaller size and a larger profit. Think all points in B i are arranged as log 1+ǫ n × log 1+ǫ n grid points, in the 2d plane. If we include a point (x, p) in D (i.e., we accept the point), we need to include all points to the upper left of (x, p). Hence, the points in D form a staircase structure. The number of such structures are bounded by the number of monotone paths from the origin to the upper right corner of the grids, which is log 1+ǫ n + log 1+ǫ n log 1+ǫ n ≤ (2 log 1+ǫ n) log 1+ǫ n (log 1+ǫ n/e) log 1+ǫ n ≤ (2e) log 1+ǫ n = poly(n).
We have reduced the size of B i , thus the size of the GenSK instance, to a polynomial. Now, we consider the case where p max > OPT, Consider a particular item b i . Suppose for some realization (x, p) ∈ D i , p > OPT. We call (x, p) a huge profit realization. A simple observation is that if a huge profit realization (x, p) is realized and x is no more than the remaining capacity C ′ , we should accept (x, p). Moreover, we can not accept any (x, p) such that x > C ′ . Hence, our search range is restricted in [0, C ′ ] × [0, OPT]. See Figure 1. For each C ′ , this reduces to the previous case. Since we only need to consider log 1+ǫ n different C ′ values, the number of different acceptance sets is clearly bounded by a polynomial. Therefore, by Theorem 5.1, we complete the proof of Theorem 1.8.
Fixed order BOSP-KC: For the fixed order model, the above reduction also works. The only change is that in the GenSK instance we reduce to, we are required to examine the items in a fixed order. Lemma 4.2 and Lemma 4.3 also hold in this case. So, it suffices to find a nearly optimal blockadaptive policy. We can also modify the dynamic program in Section 5.2 to find a block-adaptive policy subject to a particular order, as follows. Let DP(i, C) = 1 to denote whether we can reach configuration C using items from {B 1 , . . . , B i }, exact one item from each B i , such that the block where the item from B j is placed should be no lower (w.r.t. the decision tree) than the block where the item from B k is place for any j < k. When we want to compute DP(i, C), we can only place items from B i in the lowest blocks (w.r.t. the decision tree) with non-zero signatures (these blocks can be directly determined from C). The number of such placements is clearly bounded by a polynomial since the number of blocks is a constant. The rest is the same as in Section 5.2.
Finally, we note that we can also get a constant competitive algorithm when compared with the offline optimum, using simple LP techniques [46] 7 . The algorithm can provide the information of OPT, up to a constant factor, that is needed in the discretization.

Concluding Remarks
We develop the Poisson approximation technique and successfully apply it in finding approximate solutions for a variety of stochastic combinatorial optimization problems. These problems range from fixed set optimization problems to adaptive online optimization problems, from problems with a single probabilistic objective function, to problems with many probabilistic constraints. Our technique is conceptually simple, easy to apply, and has led to simplifications, generalizations and/or improvements of several previous results.
Our technique also seems quite flexible and could be potentially combined with other techniques to yield new results for other stochastic optimization problems. For example, we could first apply the technique in [13] to discretize the distributions into O(log n) equivalent classes. This could further reduce the number of possible signatures, which might be essential for problems exhibiting more complex combinatorial structures.
In the realm of approximating the distributions of the sums of n random variables, the Poisson approximation theorem and its relatives [10] work most effectively in the regime where, roughly speaking, the sum of the expected values of those random variables stays constant as n increases. This is quite different from the Gaussian approximations (e.g., CLT, Chernoff bounds, Berry-Esseen type inequalities) which typically require the sum of the expected values increases as n. In fact, the theory of Poisson approximation is an important area in probability theory [10], but it has not been explored and utilized in algorithmic applications as extensively. We believe our technique, and more generally the theory of Poisson approximation, can find wider applications in stochastic combinatorial optimization and other domains. The proof for the second inequality is essentially the same and omitted here.
Step 2: Noting that for step 2 we have X b ≤ X b ≤ (1 + ǫ) X b , the lemma is obviously true.
This completes the proof of the lemma.
Proof. For the first result, we first prove that there is a randomized canonical policy σ r such that P(σ r , π, (1 + 4ǫ)C) = (1 − O(ǫ))P(σ, π, C). Thus such a deterministic policy σ exists. In the decision tree T (σ, π, C), each edge e = (v, u) corresponds to an actual size realization of item v. We use w e to denote the discretized size of w e , i.e., w e = D v (w e ).
The randomized policy σ r is derived from σ as follows. T σr has the same tree structure as T σ . If σ r inserts an item b and observes a discretized size s ∈ S, it chooses a random branch in σ among those sizes that are mapped to s, i.e., {w | D b (w) = s} according to the probability distribution Pr[branch w is chosen] = π b (w)/ π b (s), where π b is the discretized version of π b . We can see that the probability of an edge in T σr is the same as that of the corresponding edge in T σ . The only difference is two edges are labeled with different lengths (w e in T σ and w e in T σr ). Now, we bound the profit we can collect from T σr with a knapsack capacity of (1 + 4ǫ)C. Recall R(v) is the realization path from the root to v in T σ . Let W (v) = e∈R(v) w e . W.l.o.g., we assume that ∀v ∈ T (σ, π, C), W (v) ≤ C. By definition, we have that p v (s) = e=(v,u)| we=s p v (w e ). By our construction, we have that P(σ r , π, (1 + 4ǫ)C) = v,s| W (v)+s≤(1+4ǫ)C where S 1 = {v ∈ T (σ, π, C) | W (v) ≤ (1 + 4ǫ)C and ∃e = (v, u), W (u) > (1 + 4ǫ)C}. The last inequality holds due to Property P1. We upper bound v∈S 1 Φ(v) in the following lemma.
Lemma Let σ be a policy and let (π, C) be an instance of the stochastic knapsack problem. Let S be a set of nodes in T (σ, π, C) that contains at most one node from each root-leaf path. Then we have that Proof. We can assume w.l.o.g. that S is the set of leaves in T σ . We prove this lemma for both steps of the discretization in Section 2.1. First, we show after Step 1: it holds that For u ∈ T σ , let b u be the item corresponding to u and define δ u = X bu − X bu . As we have shown in Lemma 2.2, E[δ u ] = 0 and Var[δ u ] ≤ 2ǫ 4 E[X bu ]. Let R σ be the random path (consisting of both nodes and edges) σ would choose. For u ∈ T σ , let R u+ be the random path σ would choose after reaching u (including u and edges incident on u). Define δ(R u+ ) = e∈R u+ (w e − w e ). Since σ packs an item b before it realizes to a particular size, we have that: Step 2: For step 2, |w e − w e | ≤ ǫw e and W (v) ≤ C for any e, v. Thus we have that: From (a) and (b), we can conclude the lemma.
For any edge e = (v, u) ∈ T (σ, π, C), we have W (u) ≤ C and w e − w e ≤ ǫ 4 . Thus for any v ∈ S 1 , we have . Note that S 1 contains at most one node from each root-leaf path. Applying the above lemma again, we have that v∈S 1 Φ(v) = O(ǫ). This completes the proof of the first part. Now, we prove the second part. Φ(v)s are defined with respect to T ( σ, π, C). Since a canonical policy makes decisions based on the discretized sizes, T ( σ, π, C) has the same tree structure as T ( σ, π, (1 + 4ǫ)C), except that we can not collect the profit from the later if the knapsack overflows at the end of the policy. More precisely, we have that P( σ, π, (1 + 4ǫ)C) = e=(v,u)|W (u)≤(1+4ǫ)C Φ(v)p v (w e ).

Φ(v)
where S 2 = {v ∈ T ( σ, π, C) | W (v) ≤ (1 + 4ǫ)C and ∃e = (v, u), W (u) > (1 + 4ǫ)C}. By Lemma ??, we have v∈S 2 Φ(v) = O(ǫ). This completes the proof of the lemma. Lemma 6.1 Let σ be the optimal policy. Suppose σ chooses b as the next item to consider. and decides to discard b if X b realizes to t. Then σ should discard b if X b realizes to a larger size s ≥ t.
We use DP(s) to denote that the expected profit of the optimal policy σ on ( ψ, s). Initially, which is the expected profit of repeatedly packing copies of b until one copy realizes to a nonzero size. We compute all DP(s) values for s = s k in increasing order of k = 0, 1, . . . , S − 1. Suppose we choose item b when the remaining capacity is s. Then DP(s) = s/ǫ 5 k=0 [ p b (s k ) + π b (s k )DP(s − s k )]. Therefore, the recursion of the dynamic program is the following: .
Each DP(s) can be computed with in O(n · C/ǫ 5 ) time, and there are O(C/ǫ 5 ) different values of s. Thus the running time of the dynamic program is O(n · C 2 /ǫ 10 ) = O(n). By applying the fast zero delay convolution in [22], we can speed up the dynamic program and further reduce the running time to O(n · C/ǫ 5 log 2 (C/ǫ 5 )).
Since the policy can be represented as a decision tree, Lemma 4.2 still holds in this case. Theorem D.1 can be proved following the same argument as SK.
Theorem D.1. For any ǫ > 0, there is a linear time FPTAS for SK-U when the knapsack capacity is relaxed to C + ǫ.