An Improved Unbounded-DP Algorithm for the Unbounded Knapsack Problem with Bounded Coefficients

Abstract

Benchmark instances for the unbounded knapsack problem are typically generated according to specific criteria within a given constant range R, and these instances can be referred to as the unbounded knapsack problem with bounded coefficients (UKPB). In order to increase the difficulty of solving these instances, the knapsack capacity C is usually set to a very large value. While current efficient algorithms primarily center on the Fast Fourier Transform (FFT) and (min,+)-convolution method, there is a simpler method worth considering. In this paper, based on the basic Unbounded-DP algorithm, we utilize a recent branch and bound (B&B) result and basic theory of linear Diophantine equation, and propose an improved Unbounded-DP algorithm with time complexity of $O\left(R^4\right)$ and space complexity of $O\left(R^3\right)$. Additionally, the algorithm can also solve the All-capacities unbounded knapsack problem within the complexity $O(R^4+C)$. In particular, the proof techniques required by the algorithm are primarily covered in the first-year mathematics curriculum, which is convenient for subsequent researchers to grasp.

1. Introduction

Definition 1

([1,2,3,4,5]). Given a multiset N consisting of $n^{\prime }$ item types and a total of n items, where all items of the j-th type have the same profit $p_j$, weight $w_j$, and $p_j,w_j\in {\mathbb{N}}^{+}$. Each type can be selected unlimited times. The goal of the unbounded knapsack problem (UKP) is to find an optimal multisubset (i.e., a set that allows multiple copies of the same element) of the multiset N such that its total profit is maximized without exceeding the knapsack capacity C. The problem can be formulated as follows.

$$\begin{array}{c}\hfill \max f\left(\mathbf{X}\right)=\sum _{j=1}^{n^{\prime }}{p}_j{x}_j\end{array}$$

(1)

$$\begin{array}{cc}\hfill s.t.& \sum _{j=1}^{n^{\prime }}{w}_j{x}_j\le C,\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill & x_j\in \mathbb{N}.\hfill \end{array}$$

(3)

The variable $x_j$ denotes the frequency with which the j-th type is selected. The UKP is akin to the 0–1 knapsack problem (0–1 KP), sharing the same objective and capacity constraints. A key distinction of the UKP is that the j-th type can be selected an unlimited number of times, as detailed in Equation (3). Specifically, without loss of generality, we arrange items in descending order of their profit density ratio, i.e., $p_1/w_1\ge p_2/w_2\ge \cdots \ge p_{n^{\prime }}/w_{n^{\prime }}$.

The UKP is not only a variant of the 0–1 KP, it is also a special form of integer linear programming when the constraint number is only 1 (i.e., $m=1$). As such, it is an $\mathcal{NP}$-hard problem [6,7,8,9,10,11]. $\mathcal{NP}$-hard problems have widespread applications in cryptology [12], commercial decision-making, and industrial manufacturing, leading to significant economic value. A well-known example of the UKP is the change-making problem, also referred to as the coin-changing problem. It involves determining how a cashier can minimize the number of coins used when providing change to a customer, considering an unlimited supply of coins for each denomination [13]. Therefore, efficient and exact algorithms have attracted the attention of numerous researchers. Unfortunately, the research progress on efficient algorithms is slow due to limitations in mathematical tools [14,15]. Currently, there is no exact polynomial-time algorithm to solve the UKP, except for dynamic programming (DP), which can provide an exact solution in pseudo-polynomial time complexity [16,17].

Although there are currently no efficient algorithms to solve general $\mathcal{NP}$-hard problems exactly, taking into consideration practical application context, extensive research has been conducted on improving algorithms in the following three directions. The first direction is based on methods such as linear relaxation within the framework of the branch and bound algorithm (B&B) [18]. By improving the Dantzig bound [19] and later the cutting plane method [9,20,21], it aims to solve as many decision variables as possible in polynomial time complexity, reducing the number of exhaustive subproblems and enhancing the algorithm’s solving speed. The selection of upper bounds is typically within a time complexity of $O\left(n^2\right)$, such as in [22,23,24,25]. The second direction utilizes mathematical tools, including number theory, to enhance the speed of basic dynamic programming (BDP) and reduce the pseudo-polynomial time complexity, such as in [26,27,28,29]. The third direction involves adding as few and as general constraints as possible to transform $\mathcal{NP}$-hard problems into $\mathcal{P}$, such as utilizing specific data features [30,31,32,33,34] or fixing the number of variables [35,36,37,38,39].

To demonstrate the performance of improved algorithms, researchers typically test them on benchmark instances of varying scales, which are generated according to specific criteria. Given a positive integer R, it raises an intriguing question of whether an instance with parameters ranging from 1 to R can be solved in polynomial time. Taking the UKP as an example, if the profit $p_j$ and weight $w_j$ of each type in an instance are positive integers that do not exceed R, the number of possible decisions is limited to at most $R^2$. To incorporate bounded coefficients, the unbounded knapsack problem with bounded coefficients (UKPB) introduces the following constraints to the UKP model:

$$\begin{array}{c}\hfill p_j,w_j\le R.\end{array}$$

(4)

Dynamic programming can solve the 0–1 KP exactly within the polynomial time complexity $O\left(n^{2}R\right)$ when inequality (4) holds for any capacity constraint C. Whereas, for any capacity constraint C in the UKPB, the input length can be expressed as ${\log }_{2}C$. The BDP solves the UKPB exactly in complexity $O\left(nC\right)$, while basic B&B solves it in time complexity $O\left({\prod }_{j=1}^{n^{\prime }}\frac{C}{w_j}\right)$. Clearly, when C is a sufficiently large number, neither BDP nor basic B&B can solve the UKPB exactly within polynomial time complexity. It is important to note that the polynomial-solvable algorithm is not straightforward in its design and implementation. However, by fixing the number of variables, a polynomially solvable algorithm for integer linear programming, and therefore also for the UKPB, was presented in the famous paper by Lenstra [2,38], with the proof technique derived from the geometry of numbers.

Since the coefficients of UKPB are bounded, when the time complexity of an algorithm depends solely on R and $n^{\prime }$, the algorithm will still have a polynomial time complexity. As a result, many researchers have conducted a series of studies on algorithms, in terms of R or $n^{\prime }$, by Fast Fourier Transform (FFT) and the (min, +)-convolution method [13,29,40,41,42,43,44]. Although Chan and He [13] proposed an algorithm that can solve the UKPB and AUKP in complexity $O\left(R^2\log R\right)$ and $O(R^2\log R+C)$, respectively, the algorithm cannot provide the optimal solution but optimal objective value. Due to the hardness of the solving method, it is worth expecting simpler and more efficient algorithms.

1.1. Our Results

In this paper, we propose an exact and simple pseudo-polynomial time complexity algorithm for the UKPB. The time and space complexities of the algorithm are $O\left(R^4\right)$ and $O\left(R^3\right)$, respectively, where R is an upper bound of coefficients. These complexities do not change with the capacity of the knapsack C. In particular, since R is a given integer, the time and space complexities of the algorithm are both $O\left(1\right)$. Therefore, the algorithm is a constant time complexity algorithm. Moreover, the algorithm can also be used to solve the All-capacities unbounded knapsack problem (AUKP) in complexity $O(R^4+C)$. Compared with the results of Chan and He [13], our algorithm can provide not only an optimal objective value but also the optimal solution.

Furthermore, the method primarily employs fundamental mathematical concepts that are typically included in the first-year mathematics curriculum, such as Elementary Number Theory and Data Structure. The proof tools employed are straightforward, ensuring subsequent researchers can easily grasp and build upon them.

1.2. Sketch of Proof Techniques

Our method first obtains the break type b and residual capacity r using the common greedy algorithm [2,5]. Then, the types in the set N are divided into two disjoint subsets, $N_1$ and $N_2$, where the profit density of types in $N_1$ and $N_2$ are equal to and less than the break type, respectively. That is, $N_1=\left\{j\right|p_j/w_j=p_1/w_1\}$ and $N_2=\left\{j\right|p_j/w_j<p_1/w_1\}$. Finally, through linear relaxation, we obtain an upper bound for the problem.

For the types in $N_2$, we employ a recent B&B theoretical result by Dey et al. [45], derived from analyzing the performance of the B&B in solving random integer linear programming problems, and obtain an upper bound on the number of times a type in $N_2$ can be selected. In other words, for the j-th type in $N_2$, if a solution has $x_j>R^2$, then the solution cannot be optimal. Consequently, types in $N_2$ can be exactly solved with a space complexity of $O\left(R^3\right)$ and a time complexity of $O\left(R^4\right)$ using the unbounded-DP method [2].

For the types in $N_1$, we first utilize the unbounded-DP to solve the subproblem with a capacity of $2R^2+2R$. When the knapsack capacity C exceeds $R^2+2R$, we transform the problem of finding the optimal type selection into a linear Diophantine equation (LDE) [46,47,48,49,50,51,52]. Since R is bounded, the LDE of $N_1$ is defined over the finitely generated field [53]. We employ the Euclidean algorithm to compute the greatest common divisor of the types of weights in $N_1$, denoted as $\gcd \left(W_1\right)$, which can be computed with a time complexity of $O\left(n\log R\right)$. Subsequently, we apply Bézout’s theorem and classical results of Frobenius numbers [52,54,55,56] to obtain an optimal solution for the problem.

For the AUKP, like the single-capacity UKPB, we first use the unbounded-DP algorithm to solve the subproblem with a capacity of $R^3+2R^2+2R$ in time complexity $O\left(R^4\right)$. When the knapsack capacity C exceeds $R^3+2R^2+2R$, we solve the problem recursively by the above algorithm in complexity $O(R^4+C)$.

1.3. Organization of the Paper

The rest of this paper is organized as follows: Section 2 provides an overview of the preliminary tools required for the subsequent proofs. The main theoretical results and their proofs are presented in Section 3. Section 4 applied the algorithm to solve the AUKP. In Section 5, we summarize the paper.

2. Preliminary

2.1. Dynamic Programming

For $\mathcal{NP}$-hard problems that satisfy the Bellman Optimality Principle, dynamic programming (DP) has been an important method for solving them. BDP, which typically takes the time and space complexity respectively of both $O\left(nC\right)$, yields the optimal solution to the UKP, denoted by $\mathbf{Y}$ [2]. Let $\mathrm{DP}(j,k)$ represent the optimal solution for selecting the first j items under the constraint of a given knapsack capacity of k. Clearly, $\mathrm{DP}(n,C)$ is the optimal solution to the original problem and can be obtained through the following recursive equation

$$\begin{array}{c}\hfill \begin{array}{c}\hfill \mathrm{DP}(j,k)=\left\{\begin{array}{cc}\mathrm{DP}(j-1,k),\hfill & \mathrm{if}k<w_j,\hfill \\ \max \{\mathrm{DP}(j-1,k),\mathrm{DP}(j-1,k-w_j)+p_j\},\hfill & \mathrm{if}k\ge w_j.\hfill \end{array}\right.\end{array}\end{array}$$

(5)

BDP requires n arrays of size C for a given capacity constraint. As the capacity increases, the storage cost increases significantly. With the development of data structures, an unbounded dynamic programming (unbounded-DP) approach based on linked list storage and addressing unbounded constraints has been proposed in [2]. Although the time complexity remains unchanged, the space complexity of the unbounded-DP can be reduced to $O(n^{\prime }+C)$, which is a significant improvement. The pseudo-code for the unbounded-DP is presented as follows.

The unbounded-DP algorithm first initializes a recursive array DP of length $C+1$ and a types selection array T. Next, the algorithm employs a recursive method similar to BDP to obtain the array DP (Algorithm 1, lines 2–5). Clearly, the objective function value is $f\left(\mathbf{Y}\right)=\mathrm{DP}(C+1)$. Finally, the optimal solution $\mathbf{Y}$ is obtained from the array T (Algorithm 1, lines 7–8).

Algorithm 1 Unbounded-DP

Require: $n^{\prime },W,P,C$ Ensure: $\mathbf{Y}$ 1: $\mathrm{DP}=\mathrm{zeros}(1,C+1)$ 2: $\mathrm{T}=\mathrm{DP}$ 3: for $j=1:n^{\prime }$  do 4:     for $k=w_j+1:C+1$ do 5:         if $\mathrm{DP}(k-w_j)+p_j>\mathrm{DP}\left(k\right)$ then 6:                $\mathrm{DP}\left(k\right)=\mathrm{DP}(k-w_j)+p_j$, $\mathrm{T}\left(k\right)=j$ 7:         end if 8:     end for 9: end for 10: $t=C+1$, $\mathbf{Y}=\mathrm{zeros}(1,n^{\prime })$ 11: while $t>1$  do 12:     $k=\mathrm{T}\left(t\right)$, $y_k=y_k+1$, $t=t-w_k$ 13: end while

It is worth noting that for the UKP, even state-of-the-art dynamic programming algorithms such as EDUK have a time complexity of $O\left(nC\right)$ [2,5,57]. Furthermore, the most special case of the UKP, where all types have the same profit density, is known as the unbounded subset sum problem (USSP). Unfortunately, both for the UKP and USSP, the time and space complexity of state-of-the-art dynamic programming algorithms include at least one term of C [2,5,28,29]. In particular, Pisinger proposed an encoding method for USSP that achieves exact solutions with a time complexity of $\frac{nC}{\log C}$ and a space complexity of $\frac{C}{\log C}$ [58]. Clearly, these methods are still not polynomial-time algorithms for UKPB.

2.2. Branch and Bound

B&B, proposed by Ailsa and Alison [18], is often more efficient for solving linear integer programs with a larger knapsack capacity, and it is widely used for solving the 0–1 KP and its variants [2]. Given an instance of the UKP, B&B embeds all possible solutions in a search tree. Each level of the search tree represents a decision variable, and the j-th level of the search tree has $\lfloor \frac{C}{w_j}\rfloor$ nodes. The entire search tree contains a total of ${\prod }_{j=1}^{n^{\prime }}\lfloor \frac{C}{w_j}\rfloor$ nodes. Faced with an exponential number of solutions, B&B first introduces a lower bound for the original problem commonly obtained from a greedy algorithm or heuristic algorithm as $\underline{v}\left(\mathcal{P}\right)$. Then, the algorithm fixes a decision variable with a value of $\alpha$ where $\alpha \in \mathbb{N}$ and generates a subproblem. Through linear relaxation, the subproblem is transformed into a convex problem [59], and its optimal solution is quickly obtained in the $O\left(n\right)$ time complexity, denoted as $\overline{v}\left(\mathcal{P}\right|x_j=\alpha )$. Clearly, if $\overline{v}\left(\mathcal{P}\right|x_j=\alpha )<\underline{v}\left(\mathcal{P}\right)$, then we can conclude that $y_i\ne \alpha$ and prune the branch in the search tree. While B&B can quickly solve general instances, it still requires an exhaustive search of the exponential number of feasible solutions for certain special structured instances [2].

During the process of solving subproblems, the computation method of the upper bound, first proposed by Dantzig [19], is undoubtedly essential. For the UKP, a well-known upper bound can be expressed as follows:

$$\begin{array}{c}\hfill U=\lfloor \frac{C}{w_1}\rfloor p_1+\lfloor \frac{r{p}_2}{w_2}\rfloor \end{array}$$

where r is the residual capacity and

$$\begin{array}{c}\hfill r:=C-\lfloor C/w_1\rfloor w_1.\end{array}$$

(6)

By utilizing the upper bound, we can obtain the following results in the 0–1 KP.

Theorem 1

([22]). For the j-th item, if

$$\begin{array}{c}\hfill \left|\begin{array}{cc}-p_j& r-w_j\\ p_b& w_b\end{array}\right|>0,\end{array}$$

(7)

we can conclude that $y_j=0$, where $\mathit{Y}$ denotes the optimal solution.

Recently, Dey et al. [45] proposed that, for a fixed number of constraints, B&B can achieve exact solutions in polynomial time for random integer programs with good probability. Yang [60] applied the result to the 0–1 KP and derived the following theorem.

Theorem 2.

Given a set of items $N^{\prime }$ where the j-th item satisfies the inequality

$$\begin{array}{c}\hfill \frac{p_j}{w_j+r/i}>\frac{p_b}{w_b}\end{array}$$

(8)

for $i\in \mathbb{N}$, we can conclude that ${\displaystyle \sum _{j\in N^{\prime }}}|x_j-y_j|\le i-1$.

Clearly, Theorem 2 cannot apply to the UKP, and we need to make improvements to it.

2.3. Linear Diophantine Equation

Both Theorems 1 and 2 rely on the profit density of the types, and as a result, these two methods are unable to achieve exact solutions for the USSP, which is a special case of the UKP, within polynomial time complexity.

It is interesting to note that within the field of operations research, the USSP has a similar counterpart in number theory known as the linear Diophantine equation (LDE). Classic results exist concerning the integer solutions of the LDE, which can be expressed as follows.

Lemma 1

([61,62]). Given two positive integers a and b, where $a<b$, the greatest common divisor of a and b, denoted as $\gcd (a,b)$, can be computed in time complexity $O\left(\log a\right)$ by the Euclidean algorithm.

Theorem 3

([51,63]). Let $\gcd \left(W_1\right)$ denote the greatest common divisor of the weights associated with each type in the multisubset $N_1$. If $\gcd \left(W_1\right)|C$, then the equation

$$\begin{array}{c}\hfill \sum _{j\in N_1}{x}_j{w}_j=C\end{array}$$

(9)

has infinitely many integer solutions.

In Theorem 3, if Equation (9) has an infinite number of solutions, the existence of non-negative integer solutions becomes an important question. Frobenius was the first to bring up this problem, i.e., determining when Equation (9) must have non-negative integer solutions as C varies, and this is known as the Frobenius Problem (FP) [64]. FP has attracted significant attention from researchers [52,54,55,56], and a classic result in this field can be formulated as follows.

Theorem 4

([51,52,63,64]). If $C\ge (\min \left\{W_1\right\}-1)(\max \left\{W_1\right\}-1)$ and $\gcd \left(W_1\right)|C$, then Equation (9) must have at least one non-negative integer solution.

Additionally, Theorem 4 serves as a generalization of Exercise 19 in Section 3.7 of [51].

3. A Constant Time Complexity Algorithm for the UKPB

For the UKPB and a given constant R, the maximum number of decision variables is no more than $R^2$. From the dominate rule, we can reduce the value of $n^{\prime }$, and thus obtain the following lemma.

Lemma 2.

For two types $j_1$ and $j_2$ with identical weights, i.e., $w_{j_1}=w_{j_2}$, if $p_{j_1}>p_{j_2}$, then we have $y_{j_2}=0$. Consequently, we have $n^{\prime }\le R$.

According to Lemma 2, the time and space complexity of a constant time complexity algorithm can only include constants R and the number of types $n^{\prime }$. In this paper, we propose an algorithm that can exactly solve the UKPB within a time complexity of $O\left(R^4\right)$ and a space complexity of $O\left(R^3\right)$. The key to this algorithm lies in restricting the selection times of types under the premise of ensuring the existence of an exact solution.

3.1. An Upper Bound for the Selected Times of the Type in Set $N_2$

Motivated by Theorem 2, a corresponding theorem applicable to the UKP can be formulated as follows.

Theorem 5

([60]). Given a subset $S_i$ of $N_2$ such that for $i\in {\mathbb{N}}^{+}$, the j-th type satisfies the inequality

$$\begin{array}{c}\hfill \left|\begin{array}{cc}{p}_j& w_j-r/i\\ p_b& w_b\end{array}\right|>0,\end{array}$$

(10)

then we have ${\displaystyle \sum _{j\in S_i}}\left|y_j\right|\le i-1$.

For a subset $S_i$ of $N_2$ that satisfies the inequality (10), each type can be selected at most $i-1$ times. In the case of the UKPB, if there exists an integer i with an upper bound represented by $\mathrm{ploy}\left(R\right)$, the types in $N_2$ can be selected at most $\mathrm{ploy}\left(R\right)$ times. Furthermore, the time and space complexity of solving the UKPB using dynamic programming does not depend on the capacity C. We provide an upper bound for the constant i based on the definition of $N_2$ as follows.

Theorem 6.

For the j-th type in $N_2$, if $p_b,w_b,p_j,w_j\le R$, then we have $i\le R^2$.

Proof of Theorem 6.

By the definition of the j-th type, considering that $p_b,w_b,p_j,w_j$ are all integers, we have the

$$\begin{array}{c}\hfill p_b{w}_j-p_j{w}_b\ge 1.\end{array}$$

(11)

Bringing equality (6) and inequality (11) into inequality (10), we can conclude that

$$\begin{array}{c}\hfill i>\frac{p_b{w}_b}{p_b{w}_j-p_j{w}_b}.\end{array}$$

Clearly, if $\frac{w_b{p}_b}{p_b{w}_j-p_j{w}_b}\le R^2$, then the original proposition holds. Suppose to the contrary that

$$\begin{array}{c}\hfill \frac{p_b{w}_b}{p_b{w}_j-p_j{w}_b}>R^2.\end{array}$$

(12)

Bring inequality (11) into inequality (12), then we have

$$\begin{array}{cc}\hfill p_b{w}_b& >R^2(p_b{w}_j-p_j{w}_b)\ge R^2.\hfill \end{array}$$

(13)

Since $p_b,w_b\le R$, we can infer that

$$\begin{array}{c}\hfill p_b{w}_b\le R^2.\end{array}$$

(14)

The inequalities expressed in inequality (13) and inequality (14) are contradictory, therefore, the original proposition holds. The proof of Theorem 6 is complete.    □

According to Theorems 5 and 6, it follows that the subsequent conclusion can be deduced.

Theorem 7.

$$\begin{array}{c}\hfill \sum _{j\in N_2}{y}_j{w}_j\le R^3.\end{array}$$

(15)

Proof of Theorem 7.

From Theorems 5 and 6, we conclude that $S_{R^2}=N_2$. Therefore, for the optimal solution $\mathbf{Y}$, the types in $N_2$ can be selected at most $R^2-1$ times, i.e., ${\displaystyle \sum _{j\in N_2}}{y}_j\le R^2-1$. The maximum weight of a type in $N_2$ is R. Consequently, for the optimal solution $\mathbf{Y}$, we can conclude that ${\displaystyle \sum _{j\in N_2}}{y}_j{w}_j\le R^3$. The proof of Theorem 7 is completed.    □

From Theorem 7 and the unbounded-DP algorithm, we can conclude as follows.

Theorem 8.

All types of set $N_2$ can be exactly solved in time complexity $O\left(R^4\right)$ and space complexity $O\left(R^3\right)$.

3.2. An Algorithm for Types of Set $N_1$

Theorem 8 utilizes unbounded-DP to generate $R^3$ subproblems. Given an integer t on the interval $[1,R^3]$, we need to find an optimal solution in $N_1$ within the polynomial time complexity, such that the weighted sum of the optimal solution does not exceed $C-t$. At least one of the time and space complexities of directly applying the unbounded-DP to solve the subproblems exhibits a growth rate greater than C. Consequently, further processing of the subproblems is required. By employing Theorems 3 and 4, we can derive the following conclusion.

Theorem 9.

All types of set $N_1$ can be exactly solved in time complexity $O\left(R^3\right)$ and space complexity $O\left(R^2\right)$.

Proof of Theorem 9.

We first divide the problem into two subcases: $C-t<2R^2+2R$ and $C-t\ge 2R^2+2R$.

• Case 1. When $C-t<2R^2+2R$, we can solve the problem exactly by directly applying the unbounded-DP within a time complexity of $O\left(R^3\right)$ and a space complexity of $O\left(R^2\right)$.

• Case 2. When $C-t\ge 2R^2+2R$, there exists a value of $t^{\prime }$ such that $\gcd \left(W_1\right)|t^{\prime }$ within the interval $(R^2,R^2+R]$. According to Theorem 4, there must be a non-negative integer solution ${\mathit{X}}^{\prime }$ such that

  $$\begin{array}{c}\hfill \sum _{j\in N_1}{x}_j^{\prime }{w}_j=t^{\prime },\end{array}$$

  and the solution ${\mathit{X}}^{\prime }$ can be solved by unbounded-DP in the time complexity $O\left(R^3\right)$ and space complexity $O\left(R^2\right)$. Next, we perform the modulo operation on $C-t$. Let $t^{″}$ be a number congruent to $C-t$ modulo $t^{\prime }$, denoted as $t^{″}\equiv C-t\left(\mathrm{mod}{t}^{\prime }\right)$, where $R^2\le t^{\prime }<t^{″}\le 2t^{\prime }\le 2R^2+2R$. Consequently, we have a non-negative integer solution ${\mathit{X}}^{″}$ such that

  $$\begin{array}{c}\hfill \sum _{j\in N_1}{x}_j^{″}{w}_j=⌊\frac{t^{″}}{\gcd \left(W_1\right)}⌋\gcd \left(W_1\right).\end{array}$$

Clearly, the solutions ${\mathit{X}}^{″}$ and ${\mathit{X}}^{\prime }$ are both solved in the same way. Additionally, for the original problem, there exists one optimal solution that satisfies the equation:

$$\begin{array}{c}\hfill \mathit{Y}={\mathit{X}}^{″}+⌊\frac{C-t}{t^{\prime }}-1⌋{\mathit{X}}^{\prime }.\end{array}$$

Since the solutions ${\mathit{X}}^{\prime }$ and ${\mathit{X}}^{″}$ are both obtained through the unbounded-DP within time and space complexities of $O\left(R^3\right)$ and $O\left(R^2\right)$, respectively, the exact algorithm for $\mathit{Y}$ will have the same time and space complexities as the exact algorithm for ${\mathit{X}}^{\prime }$.

The proof of Theorem 9 is complete.    □

3.3. Complexity Analysis

In order to calculate the overall time and space complexity of the algorithm presented in this paper, we summarize all the algorithmic operations as Algorithm 2. The pseudocode for the algorithm is provided below.

Algorithm 2 Our algorithm for UKPB

Require: $n^{\prime },W,P,C$ Ensure: $\mathbf{Y}$ 1: Computing the profit density of all types, and obtaining the multisubset $N_1$ and $N_2$. 2: Computing $\gcd \left(W_1\right)$ and $t^{\prime }$. 3: Calling Unbounded-DP to establish an iterative array ${\mathrm{DP}}_1$ for $N_2$ with capacity $R^3$. 4: Calling Unbounded-DP to establish an iterative array ${\mathrm{DP}}_2$ for $N_1$ with capacity $2R^2+2R$. 5: Creating a temporary array $A=\mathrm{zeros}(1,R^3)$ 6: for $t=0:R^3$  do 7:     $t^{″}\equiv C-t\left(\mathrm{mod}{t}^{\prime }\right)$ and $t^{\prime }<t^{″}\le 2t^{\prime }$ 8:     $A\left(t\right)={\mathrm{DP}}_2\left(t^{″}\right)+⌊\frac{C-t}{t^{\prime }}-1⌋{\mathrm{DP}}_2\left(t^{\prime }\right)$ 9: end for 10: $k=\underset{1\le t\le R^3}{\mathrm{argmax}}({\mathrm{DP}}_1\left(t\right)+A\left(t\right))$. 11: Return optimal solution $\mathbf{Y}$ by Unbounded-DP

Algorithm 2 first computes the profit density of types in the multiset N and divides the set N into two multisubsets, $N_1$ and $N_2$, based on the profit density. This operation is performed within time and space complexities of $O\left(R\right)$ (line 1, Algorithm 2). Then, the $\gcd \left(W_1\right)$ is computed by the Euclidean algorithm with a time complexity of $O\left(R\log R\right)$ (line 2, Algorithm 2). Next, unbounded-DP is called for multisubsets $N_1$ and $N_2$ with a capacity of $R^3$ and $2R^2+2R$, respectively (lines 3–4, Algorithm 2). The time complexities for lines 3–4 are $O\left(R^4\right)$ and $O\left(R^3\right)$, respectively, in Algorithm 2.

To eliminate the coefficient C from the time and space complexities, we utilize relevant conclusions from the LDE to accelerate the speed complexity and minimize the space complexity of the exact algorithm. This is demonstrated in lines 6–8, with a time complexity of $O\left(R^3\right)$ for lines 6–8. Since the lengths of ${\mathrm{DP}}_1$ and array A are both $R^3$, the time complexity of line 9 is also $O\left(R^3\right)$. Finally, the unbounded-DP is used to return the optimal solution $\mathbf{Y}$ with a time complexity of $O\left(R^3\right)$.

In summary, the time and space complexities of Algorithm 2 are $O\left(R^4\right)$ and $O\left(R^3\right)$, respectively. For the UKPB, since the coefficients of weight and profit are both bounded by a given constant R, the UKPB can be exactly solved in constant time and space complexities.

3.4. A Small Instance

To illustrate how Algorithm 2 solves the UKPB, we introduce a small-scale example as follows.

Example 1.

Consider a small instance of the UKP with a knapsack capacity of C = 10,000 and $n=3$ types. The profit and weight of each type are as follows.

j	1	2	3
$p_j$	6	7	4
$w_j$	6	7	5

In Example 1, types are numbered in order of profit density from highest to lowest. It is evident that $N_1=\{1,2\}$ and $N_2=\left\{3\right\}$. Additionally, we have $R=7$. Next, Example 1 can be solved by employing Algorithm 2. The computation process is detailed as follows.

Step 1.

The Euclidean algorithm is used to obtain $\gcd \left(W_1\right)=1$ and $t^{\prime }=R^2+1=50$.

Step 2.

Calling unbounded-DP to solve $N_1$ and $N_2$, respectively, we obtain iterative arrays ${\mathrm{DP}}_2$ and ${\mathrm{DP}}_1$. The capacity of ${\mathrm{DP}}_1$ is $R^3=343$ and that of ${\mathrm{DP}}_2$ is $2R^2+2R=112$, respectively.

Specifically, in comparison to the method proposed in [13], due to the value of $N_2$ as calculated in inequality (12) as

$$\begin{array}{c}\hfill \frac{p_1{w}_1}{p_1{w}_3-p_3{w}_1}=\frac{36}{30-24}=6,\end{array}$$

the capacity of ${\mathrm{DP}}_2$ in Algorithm 2 only needs to be $6\times w_3=30$ to be sufficient for Example 1, which is significantly less than $R^3=343$.

Step 3.

The temporary array A is obtained by iterating through a loop indexed by t. For example, when $t=1$, we have $t^{″}\equiv C-t\left(\mathrm{mod}{t}^{\prime }\right)\equiv 9999\left(\mathrm{mod}50\right)\equiv 49$. Consequently,

$$\begin{array}{c}\hfill A\left(1\right)={\mathrm{DP}}_2\left(49\right)+⌊\frac{9999}{50}-1⌋{\mathrm{DP}}_2\left(50\right).\end{array}$$

Step 4.

Finding the value of k via a search process, and subsequently utilizing unbounded-DP to determine the optimal solution $\mathbf{Y}$

Since $\gcd \left(W_1\right)=1|C$, we can determine $\mathbf{Y}=\{1662,4,0\}$.

4. The Algorithm for the AUKP

For the AUKP, as implemented in Algorithm 2, we initially employ the unbound-DP algorithm to address a subproblem with a capacity of $R^3+2R^2+2R$. For those problems with capacities exceeding $R^3+2R^2+2R$, we recursively apply the same approach to subproblems of capacity $t^{‴}$, ensuring that $R^3+t^{\prime }<t^{‴}\le R^3+2t^{\prime }$. The complexity of Algorithm 3 is $O(R^4+C)$. The pseudocode is illustrated as follows:

Algorithm 3 Our algorithm for AUKP

Require: $n^{\prime },W,P,C$ Ensure: $\mathbf{Y}$ 1: Computing the profit density of all types, and obtaining the multisubset $N_1$ and $N_2$. 2: Computing $\gcd \left(W_1\right)$ and $t^{\prime }$. 3: Calling Unbounded-DP to establish an iterative array DP for all items with capacity $R^3+2R^2+2R$. 4: Creating a temporary array $B=\mathrm{zeros}(1,C)$ and $B(1:R^3+2R^2+2R)=\mathrm{DP}$. 5: for $t=R^3+2R^2+2R:C$ do 6:     $t^{‴}\equiv C\left(\mathrm{mod}{t}^{\prime }\right)$ and $R^3+t^{\prime }<t^{‴}\le R^3+2t^{\prime }$ 7:     $B\left(t\right)=\mathrm{DP}\left(t^{‴}\right)+⌊\frac{C-t^{‴}}{t^{\prime }}⌋\mathrm{DP}\left(t^{\prime }\right)$. 8: end for 9: Return optimal solution $\mathbf{Y}$

5. Conclusions

In this paper, we extend the theoretical results of [45,60] and propose an algorithm with pseudo-polynomial time and space complexities that do not depend on the capacity C. We specifically focus on the UKP benchmark instances where the difficulty of the problem often arises from setting the capacity coefficient C to a large value. Our algorithm is capable of achieving exact solutions within time and space complexities of $O\left(R^4\right)$ and $O\left(R^3\right)$, respectively. Additionally, considering that the value of R is typically a given constant in the benchmark instance generation rules, for the UKP benchmark, our algorithm achieves constant time and space complexities.

In particular, the mathematical tools employed in this paper are covered in the first-year mathematics curriculum. The proof techniques are relatively straightforward and facilitate further research and potential improvements by subsequent researchers.