1.Introduction

Portfolio optimization is one of the most important issues in financial markets and has many applications in financial planning and decision making. In the early 1950s, the theoretical foundations of this issue and the modern portfolio theory were founded by Markowitz [1,2]. Traditional asset allocation methods like Markowitz theorem gives the solution as a percentage and this ratio may suggest allocation of half of a share on the market, which is impractical. Many portfolio optimization problems deal with allocation of assets which carry a relatively high market price. Therefore, it is necessary to determine the integer value of assets when we deal with portfolio optimization. Therefore, Vaezi et al. [3–5] study the portfolio optimization problem with integer variables. The Genetic Algorithm(GA) and Discrete Firefly Algorithm (DFA) is designed to find the near optional solutions of knapsack-based portfolio optimization with discrete variables. The aim of this study is to find a more efficient method for the portfolio optimization problems with discreet variables. Hence, in this study, an algorithmic method based on dynamic programming is designed for the knapsack-based constrained portfolio optimization to find the optional solutions, exactly.

Dynamic programming is an efficient mathematical method for multi-stage optimization problems. Dynamic planning, using systems-oriented processes based on the two properties of overlapping sub-problems and optimal infrastructure, provides a combination of sequential decisions that maximize computational efficiency. Bellman [6] introduced this method in 1953. Unlike linear programming, there is no standard framework for formulizing dynamic programming problems. In fact, dynamic programming provides a general approach to solve these types of problems. In each case, special equations and mathematical relations must be written that match the conditions of the problem. The main contribution to multi-stage financial decisions has been made by Merton [7,8]. AÏT-SAHALI and Brandt [9] also used this template based on dynamic programming in continuous time. Sadjadi et al. [10] proposed a dynamic programming approach for the classical mean-variance Markowitz model, which included risky and riskless assets. Thus, Zhu et al. [11] presented a generalized mean-variance portfolio optimization with the possibility of controlling bankruptcy risk using the Lagrangian dual method and the parametric approach of the dynamic programming. Shin [12] presented the optimal consumption and portfolio selection model with risky and riskless assets using the dynamic programming based on the approach presented by Karatzas et al. [13] to extract the value function and optimal strategies in closed form. Using Bi-level programming and dynamic programming techniques, Chen and Song [14] examined a multi-period portfolio optimization by considering and controlling bankruptcy risk in the financial market. Moreover, some studies have used a dynamic programming approach based on the Hamilton-Jacobi-Bellman equations to examine limited portfolio optimization in the probability or expected size of wealth or consumption [15–19]. Palczewski [20] suggested an efficient numerical algorithm based on Bellman’s dynamic programming approach to optimize a dynamic portfolio optimization with transaction costs that depend on different times and scenarios. Najafi and Pourahmadi [21] proposed a heuristic method based on dynamic programming for a multi-period portfolio optimization problem with transaction costs under uncertain conditions. Moreover, Guigues [22–24] suggested dual dynamic programming with cut selection for convex optimization problems and proved that the obtained method is faster than methods such as simplex in portfolio optimization problems. Mohebbi and Najafi [25] considered a multi-period horizon and transaction costs in the proposed model. They used a median absolute deviation as a risk measurement. Moreover, the uncertain condition was also considered based on the scenario tree in this model and dynamic programming was applied to solve this model. Moreover, Cui et al. [26] analyzed management fees in portfolio optimization using stochastic dynamic programming and Valladão et al. [27] provided a Markov chain stochastic dual dynamic programming in order to assign the asset allocation. As well as, Zhang et al. [28] combined the approximate dynamic programming method with the game theory and create an iteration method to apply the optimal portfolio. Hence, some studies have concentrated on the project portfolio optimization problem by applying stochastic dynamic programming such as Nowak and Trzaskalik [29].

As noted above, the mentioned methods based on dynamic programming are presented to solve classical portfolio optimization problems with continuous variables. Given that capital markets are facing a wider range of investors day by day and investors have very little time to choose the appropriate shares, any delay in decision-making can lead to a reduction in investor returns. Therefore, in this study, we are focused to propose an algorithmic method based on dynamic programming to solve the knapsack-based constrained portfolio optimization with discrete variables.

The proposed algorithm based on dynamic programming divides complex large-scale portfolio optimization problems into simpler sub-problems and stores their results to prevent recalculation of results. The proposed algorithm based on dynamic programming finds the optimal solution for the sub-problems and then makes an informed choice by combining the results of these sub-problems to find the most optimal solution. In fact, in the proposed algorithm, instead of calculating the same sub-problems over and over again, the solutions are stored in the first memory and used in the next steps if needed. In the proposed algorithm, this feature is a great idea to save time and memory, where using the extra space, the time required to find the optimal solution is improved. According to the comparison of the results of solving the proposed algorithm based on dynamic programming with the results of solving the metaheuristic algorithms, the proposed algorithm has the ability to achieve the most optimal solution in an acceptable time. Moreover, the greedy algorithm seeks an optimal solution at every local stage. Thus, greedy algorithms can offer a hypothesis that seems optimal at the time, but looks worrying in the future and does not guarantee global optimization.

The outline of the paper is as follows. According to the knapsack problem, the portfolio selection model is presented in Section 2. In Section 3, a proposed algorithm based on dynamic programming is designed for the knapsack-based constrained portfolio optimization. In section 4, two case studies of the US stock exchange are analyzed. In Section 5, the results of the suggested algorithm are compared with another method to show the efficiency of the proposed techniques. Finally, a summary of the paper and some results are provided in Section 6.

2. Portfolio optimization problem

The portfolio selection model is based on the knapsack problem and the following notations are applied:

the expected return of a portfolio;

Z the objective function with the coefficient (λ) as a penalty;

λ the coefficient of the cardinality constraint;

N, the dimension of the decision variable;

B, the budget;

, the rate of return per unit of share i;

ρ_i, the price per unit of share i;

l_i, the lower bound of share i;

u_i, the upper bound of share i;

k, the number of y_i that can be in the portfolio;

x_i, the integer variable that indicates the number of share i;

y_i, the binary variable; y_i = 1, if share i is involved in the portfolio, andy_i = 0 in any other way.

The proposed model is formulated as follows: (1)

S. t.

(2)

(3)

(4)

(5)

(6)

Eq (1) provides the portfolio that has the highest returns with respect to a consent of the considered constraints. Eqs (2), (3) and (4) are the budget, cardinality, and quantity constraints, respectively. This model, which has discrete variables (Eqs (5) and (6)), has two very important features; achieving the optimal number of shares as an integer and with masterly efficiency in portfolio optimization for high priced stocks. These features have added some real aspects of financial markets to the model and distinguish them from other previous models (Vaezi et al. [3–5]).

As the number of constraints in the portfolio selection models increases, the complexity of implementing the dynamic programming approach increases and sometimes makes the process difficult or impossible. We have tried to simplify this process by adding a cardinality constraint with a coefficient to the objective function. Therefore, the previous model is rewritten as follows: (7)

S.t.

(8)

(9)

(10)

(11)

In fact, Eq (3) is added to the objective function with the coefficient (λ) as a penalty. The important point is that the objective function becomes non-convex in this case.

3. Proposed algorithm based on dynamic programming

Dynamic programming is generally a powerful technique for algorithm design and can be considered as a kind of exhaustive search. Dynamic programming divides a complex problem into sub-problems and stores their results to prevent recalculation of results. Instead of calculating the same sub-problem over and over again, it is necessary to save your solution in the first memory and use it in the next steps if needed. This is a great idea to save time and memory, where it is accessible to use the extra space in order to improve the time required to find a solution [30].

An important feature of problems that can be solved by dynamic programming is interference. This feature distinguishes dynamic programming from other methods such as the divide and conquer technique [31].

In other methods such as greedy algorithms, the best option is only chosen by considering the existing conditions. Thus, greedy algorithms can provide a hypothesis that seems optimal at the time but does not guarantee a global optimization in the future. However, dynamic programming finds the optimal solution for the sub-problems and makes an informed choice to find the most optimal solution by combining the results of these sub-problems [32].

The first step to solve the problems using a dynamic programming approach is to determine the stage, state, and action for that problems. In the proposed dynamic programming approach, each stage belongs to a type of share or asset. Moreover, the state is the amount of available budget, which is defined as an interval. In fact, the problem shifts from continuous to discrete states with budget interruptions. Finally, the action is considered the number of shares. The number of shares fluctuates between their predetermined upper and lower bounds and is an integer. The solution method is the backward recursion approach using the following recursive equation.

(12)

In Eq (12), i, S_i and x_i are the stage, state, and action, respectively. ϕ(i, S_i, x_i) is the value considered for decisions making based on three input parameters. In fact, this value is the rate of return obtained from . λ is obtained by a sequential approximation method.

Note that, in addition, to calculate the rate of return, the amount of consumption budget resulting from this decision is also calculated according to ρ_ix_i in each section. Thus, f*(i+1, S_i+1) is the maximum profit or return of the stage i+1 for the remaining capital.

Given that the present problem has become a non-convex optimization problem, it is important to pay attention to the final table and select the global optimal point in the proposed approach. In the following, the pseudocode of the proposed dynamic programming algorithm is described in detail.

Step 1 describes the structure of dynamic scheduling tables. In this step, the solution method, the state, the number of rows, the actions, and the number of columns (m_i). The solution method is the backward recursion approach (i = N,…,1). Note that, the state depends on the length of the selected step (L) for the budget interval defined by the user. The states intervals are defined as [S_Γ−1, S_Γ), Γ∈{1,2,…,n} and according to S_Γ = Γ*L (S₀ = S₁ = 0, S_n = B). Therefore, the number of rows (n) is defined according to . Moreover, the actions in stage i are determined by the number of shares that fluctuate between their predetermined lower bound (l_i) and upper bound (u_i). Hence, the number of table columns in stage i (m_i) is determined by the number of actions in stage i according to m_i = u_i−l_i+1. Hence, six variables with the symbols; R_i, P_i, , P_i+1, P_T and R_T are being assigned in each cell. R_i and P_i are the return and price of the current stage (stage i) in each cell. are the best return and its price of the pervious stage (stage i+1) in each cell. P_T and R_T are the total price and return in each cell. In addition, the last two columns contain the maximum values of the objective function in each row and the action assigned to it, respectively.

Step 2 describes how to fill each cell in the first state table. Moreover, Step 3 describes how to fill each cell in the next states tables. Step 4 also provides the final solution. Due to the objective function of the problem is non-convex, the final solution to the problem is to select the maximum value from the optimal column values associated with each row in the final table and the actions assigned to that value. Finally, the pseudocode of the proposed dynamic programming approach is as follows:

Algorithm 1: Pseudocode of dynamic programming.

Step 1: Table shape

    For i = N,…,1 then

    Set m_i = u_i−l_i+1 and j = 1,2,…,m_i

    Set and Γ = 1,2,…,n

    Create a table with m_i columns and n rows and call it the i-th window

    Put x_ij = l_i+(j−1) at the top of column j

    Assign the Γ−th row of the table to interval [S_Γ−1,S_Γ)

    If Γ = 1, then

    Set S_Γ−1 = S_Γ = 0

    End if

    If Γ<n, then

    Set S_Γ = Γ*L

    End if

    If Γ = n, then

    Set S_n = B

    End if

    Display the point of the table where the j−th column and the Γ−th row meets C_Γj.

    Assign six variables with the symbols; in each cell, which in the general view of the table we display them with the symbols;

    Consider two columns for each table to store the value of

    Assign two variables with the symbols; in each cell of , which in the general view of the table we display them with the symbols;

Step 2: First state

    If i = N then

    Set

    For j = 1,2…,m_i do

    Set w_ij = x_ij*ρ_i and

    Find the interval which the w_ij belongs to it.

    Suppose that w_ij belongs to k-th interval.

    Set C_kj.P_i = w_ij and C_kj.R_i = r_ij

    End for

    For p = 1,2,…,n.

    Find the maximum value among the C_pj. R_i∀ j = 1,2…,m_i

    Suppose

    Get the optimal vector based on the optimal answer index

    End for

    End if

Step 3: Next states

    If i<N then

    Fore j = 1,2…,m_i do

    Set w_ij = x_ij*ρ_i and

    Find the interval which the w_ij belongs to it.

    Suppose that w_ij belongs to k-th interval.

    Set C_kj.P_i = w_ij and C_kj.R_i = r_ij

    Set Z_kj = S_k−w_ij

    Go to i+1−th window

    Find the interval which Z_kj belongs to that

    Suppose Z_kj belongs to I−th interval

    If then

    Set

    Else if then

    Set

    End if

    Set

    For p = 1,2,…,n. p≠k

    Set q_pj = S_p−w_ij

    Go to i+1−th window

    Find the interval which q_pj belongs to that

    Suppose q_pj belongs to I−th interval

    If q_pj>0 and then

    Set

    Else if q_pj>0 and then

    Set

    Set ξ = C_pj. P_i+1+w_ij

    If ξ∈p−th interval then

    Set C_pj.P_i = w_ij and C_pj.R_i = r_ij

    Set C_pj.P_T = C_pj.P_i+1+C_pj.P_i and

    Else if ξ∉p−th interval then

    Set C_pj.P_i = 0 and C_pj.R_i = 0

    Set

    Set C_pj.P_T = C_pj.P_i+1 and

    End if

    Else if q_pj<0 then

    Set C_pj.P_i = 0 and C_pj.R_i = 0

    Set

    Set C_pj.P_T = C_pj.P_i+1 and

    End if

    End for

    End for

    For p = 1,2,…,n then

    Find the maximum value among the C_pj.R_T ∀ j = 1,2…,m_i

    Suppose

    Get the optimal vector based on the optimal answer index

    End for

    End if

Step 4: Last solution

    If i = 1 then

    Set

    Set

    End if

    End for

Figs 1 and 2 show the flowchart of the proposed algorithm based on dynamic programming to better understand the suggested approach.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Table shape.

https://doi.org/10.1371/journal.pone.0271811.g001

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Flowchart of the proposed algorithm.

https://doi.org/10.1371/journal.pone.0271811.g002

4.Numerical results

In this section, two case studies are presented. The first case study for the knapsack-based portfolio optimization problem is considered in small dimensions so that the proposed approach is better understood and the problem can be resolved manually to verify the validity of the results. The second case study for the knapsack-based portfolio optimization problem is considered in larger dimensions to further investigate the program execution time and sensitivity analysis of the proposed algorithm in each state.

4.1 Case study (1)

Table 1 provides the information on the prices (ρ_i), returns(), lower bounds (l_i) and upper bounds (u_i) of shares belong to five environmental companies. To obtain this information, daily time series data during a five-year period from 1/9/2014 to 1/9/2019 has been used.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Information on environmental shares.

https://doi.org/10.1371/journal.pone.0271811.t001

In the case study, the budget (B) and the step length (L) are 650$ and 65, respectively. Therefore, the number of the state is 10. As well as, given that there are five different types of shares, five stages are defined in the case study. The actions are also considered the number of shares in each stage. Moreover, the number of y_i that can be in the portfolio is considered 2 (K = 2) and the solution method is backwards.

The first step to solve the case study is to obtain the optimal value of the coefficient of the cardinality constraint (λ) that is λ*. λ* is obtained from the sequential approximation method using the designed MATLAB code (S1 Appendix). Moreover, the Intlinprog solver in MATLAB has also been used to check the accuracy and validity of the designed MATLAB code results (S2 Appendix). Eventually, Information on the objective function and variables for different values of λ in the interval [–2 2] with a step length of 0.05 is provided in S3 Appendix. According to the results, the first place where K in the cardinality constraint equals 2 (K = 2) is where λ is -1.1(λ* = −1.1). Eventually, this model was solved by the proposed algorithm code based on dynamic programming provided in S4 Appendix. The software output is provided in S5 Appendix. The results include , and takes 1.320s to precede. Moreover, to gain validity and reliability of the designed code, the case study is manually solved in the form of dynamic scheduling tables (S6 Appendix).

Table 2 shows the results of various changes in the state by changes in the step length (L) belonging to budget intervals and sensitivity analysis.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Sensitivity analysis of environmental shares.

https://doi.org/10.1371/journal.pone.0271811.t002

In this case study, the change of L does not change the answer. In other words, the error rate of different changes in the state by changes in the step length (L) belongs to budget intervals is zero for this case study in the proposed dynamic programming approach.

4.2 Case study (2)

The second case study includes the Dow Jones Industrial Average listed on the New York Stock Exchange. The data includes daily time series over a period of 5 years from 1/9/2014 to 1/9/2019. Table 3 provides the information on the prices (ρ_i), returns(), lower bounds (l_i) and upper bounds (u_i) of shares.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Information on Dow Jones shares.

https://doi.org/10.1371/journal.pone.0271811.t003

In the case study, the budget (B) and the number of y_i that can be in the portfolio (K) are 3100$ and 6, respectively. Table 4 provides information on the objective function and variables for different step lengths (L) belonging to budget intervals. Noted that each L has a special λ, which is obtained with a sequential approximation method and step length of 0.05.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 4. Sensitivity analysis of Dow Jones shares.

https://doi.org/10.1371/journal.pone.0271811.t004

According to Table 4, the answers of are the same for different step lengths (L) belong to budget intervals and selected λ for each L. Therefore, there is no error in this part. However, there is a difference in the selected number of each selected share . Due to one of the factors that affect the objective function is , the objective function also changes. This type of error sometimes occurs due to the transformation of the budget state from continuous to an interval in the proposed approach.

Eventually, according to the program execution time in each state and the results, we find that the suggested dynamic programming method is very efficient.

5. Comparative study

In the section, the results of the suggested algorithm based on dynamic programming compare with another method to show the efficiency of the proposed techniques. To compare the efficiency of the proposed techniques with well-known existing techniques, Discrete Firefly Algorithm (DFA) and Genetic Algorithm (GA) designed to solve portfolio optimization problem with discrete variables according to Vaezi et al. [3–5].

In addition, to select appropriate parameters, the Taguchi method is used for five parameters of DFA. Finally, parameters selected in this algorithm are attractiveness (β₀ = 1), randomization parameter (φ = 0.2), absorption coefficient (γ = 1), number of iterations (Max-Generation = 500), and number of fireflies (Population = 29).

The average results of DFA compare with the average results of the proposed algorithm based on dynamic programming and their results are reported in Table 5.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 5. The average results of solving DFA and proposed algorithm and comparing them with each other.

https://doi.org/10.1371/journal.pone.0271811.t005

As can be seen in Table 5, the standard errors of mean (SE. Mean), standard deviations (S.D.) and probability values (P-value) are 46.5, 65.7 and 0.042, simultaneously.

Next, the appropriate parameters of GA are Number of iterations (MaxIt = 500), Population size (nPop = 500), Single point crossover whit probability 0.8 and Swap mutation for permutation with probability 0.2. These parameters are also selected using the Taguchi method.

Moreover, the average results of GA compare with the average results of the proposed algorithm based on dynamic programming and their results are also reported in Table 6.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 6. The average results of solving GA and proposed algorithm and comparing them with each other.

https://doi.org/10.1371/journal.pone.0271811.t006

As can be seen in Table 6, the standard errors of mean (SE. Mean), standard deviations (S.D.) and probability values (P-value) are 55.6, 78.6 and 0.050, simultaneously.

Note that the mean result of proposed algorithm based on dynamic programming is more accurate than the mean result of GA and DFA and also the program execution time of the proposed algorithm is acceptable, the proposed algorithm based on dynamic programming is very valid. Finally, all results confirm the reliability and credibility of the proposed algorithm based on dynamic programming to solve the constrained portfolio optimization problem whit discreet variables.

6. Conclusion

In the paper, we have presented a dynamic programming algorithm to solve the portfolio selection model based on the knapsack problem. This model, which has discrete variables, has two very important features; achieving the optimal number of shares as an integer and with masterly efficiency in portfolio optimization for high priced stocks. These features have added some real aspects of financial markets to the model and distinguish them from other previous models. To solve the knapsack based portfolio selection model in larger and more complex dimensions by proposed algorithm based on dynamic programming, MATLAB code has been used. Then, to show the applicability and validity of the proposed dynamic programming algorithm, two case studies have been considered. The first case study consists of shares belong to five environmental companies. The case study was solved using designed MATLAB code. Then, it was solved manually in the form of dynamic programming tables. Finally, by comparing the results of the two approaches, the validity of the designed code was analyzed. Hence, the second case study, which was larger in dimensions and included the Dow Jones shares, was reviewed. Finally, the results of the suggested algorithm based on dynamic programming were compared with another method to show the efficiency of the proposed techniques. To compare the efficiency of the proposed techniques with well-known existing techniques, DFA and GA were designed to solve portfolio optimization problem with discrete variables according to Vaezi et al. [3–5].

Note that the mean result of proposed algorithm based on dynamic programming was more accurate than the mean result of GA and DFA and also the program execution time of the proposed algorithm was acceptable, the proposed algorithm based on dynamic programming was very valid. Finally, all results confirmed the reliability and credibility of the proposed algorithm based on dynamic programming to solve the constrained portfolio optimization problem whit discreet variables. Eventually, according to the program execution time in each state, the results confirmed that the designed dynamic programming algorithm is absolutely valid.

Moreover, the presentation and development of a dynamic programming approach for the portfolio optimization problem based on the knapsack problem, considering investment risk, uncertainty conditions and other practical constraints, can be considered as examples of future research.

Supporting information

Acknowledgments

We are also immensely grateful to the Editor-in-chief, Guest Editors and anonymous referees for sharing their insightful comments with us during the course of this research.