A new kind of signed permutations is proposed in this paper. Based on the standard permutation defined by {1,2,…,n}, we assign a sign (either positive or negative) to each number, including the boundary elements at both ends, the resulting permutation is called a signed permutation. Eight combinatorial statistics about ascents, descents, sign changes with respect to the signs are introduced. With the help of the context-free grammar theory, a series of combinatorial properties of such signed permutations are presented, mainly in the aspects of (homogeneous) γ-positivity, (homogeneous) bi-γ-positivity, determinantal expressions, Pólya-frequency, unimodal, log-concave, real-rooted, asymptotic normality.

In this paper, we consider the min–max heterogeneous weighted delivery (MMHWD) problem. Concretely, given a weighted graph G=(V,E;w) with length function w:E→ℝ^+ satisfying the triangle inequality, a fixed depot r∈ V , m items and k vehicles having nonuniform speeds λ _1 , λ _2 , … , λ _k , respectively, each item j is initially located at its source vertex s_j and needs to be uninterruptedly delivered to its target vertex t_j for j=1,2, … , m , each vehicle i can move along edges of G and only continuously deliver one item at a time, the goal is to find a set 𝒞={C_1,C_2,… , C_k} of k tours for these k vehicles, each starting and ending at r, to collectively deliver all items such that the maximum completion time of vehicles is minimized, where the completion time of a vehicle is its total length divided by its speed. We obtain two main results. (1) We design a 134.4434· (1+δ ) -approximation algorithm to solve the MMHWD problem, and this algorithm runs in time O(n^6 + n^4/δ+log _2 w(E)) , where δ >0 is a small constant. (2) We provide a (φ +9/5-1/k) -approximation algorithm to resolve the MMHWD problem, and that algorithm runs in time O(n^3) , where φ is the ratio of the largest vehicle speed to the smallest one.

In this paper, we address three variations of the windy k-traveling salesman problem (the k-WTSP), which are related to the asymmetric traveling salesman problem. Concretely, given a weighted connected graph G=(V,E;w;r) of order n and an integer k≥ 1 , where r∈ V and a windy cost function w:A →ℝ^+ , where A={(v_i,v_j),(v_j,v_i) | v_iv_j∈ E} , i.e., for each edge v_iv_j∈ E , we denote w(v_i,v_j) to be the cost to traverse this edge v_iv_j from v_i to v_j and w(v_j,v_i) to be the cost to traverse the same edge v_iv_j from v_j to v_i , respectively, the k-WTSP is asked to find k circuits, starting and ending at r, such that each vertex of G is contained in at least one of these k circuits, the objective is to minimize the total costs of these k circuits. In addition, the minmax windy k-traveling salesman problem (the minmax k-WTSP) is asked to find k circuits as mentioned-above, the objective is to minimize the maximum cost of these k circuits. Finally, the minmax windy k-circuit cover problem (the minmax k-WCCP) is asked to find k circuits such that each vertex of G is contained in at least one of these k circuits, the objective is to minimize the maximum cost of these k circuits. We have three key contributions as follows. (1) We design a 3/2(α +1) -approximation algorithm to solve the k-WTSP in time O(n^3) , where α =max{w(v_i,v_j)/w(v_j,v_i) | v_iv_j∈ E} ; (2) We present a (3/2(α +1)+2(1-1/k)) -approximation algorithm to solve the minmax k-WTSP in time O(n^3) ; (3) We provide a (3/2(α +1)+k) -approximation algorithm to solve the minmax k-WCCP in time O(n^3) .

In this paper, we consider the bin covering problem with strong divisibility and rejection profit (the BC-SDRP problem, for short). Specifically, given a lot of identical bins with integer capacity L and a set A={a_1,a_2,… ,a_n} of n items with strongly divisible sizes, i.e., either s_i | s_j or s_j | s_i for each pair of two distinct items a_i and a_j in A and s_max | L , where each item a_i in A has an integer size s_i and s_max=max{s_i | a_i∈ A} , a bin with capacity L is called to be covered by the items if this bin receives some items with summation of sizes at least L, each item a_i in A is either put into a bin such that this bin used is covered, or rejected with rejection profit that we pay. No item can be put into more than one bin. We consider the BC-SDRP problem and its variation. (1) Given a rejection profit p∈ℝ^+ , the BC-SDRP problem is asked to find a subset X⊆ A and a scheme of items in X to cover some identical bins with capacity L, the objective is to maximize the number k(X) of such bins covered by items in X plus the total rejection profit p · |A ∖ X| of rejected items not in X; (2) Given a rejection cardinality r_0∈ℤ^+ , the bin covering problem with strong divisibility and bounded rejection cardinality (the BC-SDBRC problem, for short) is asked to find a subset X⊆ A and a scheme of items in X to cover some identical bins with capacity L under a constraint of the number of rejected items not in X at least r_0 , the objective is to maximize the number k(X) of such bins covered by items in X. As our main contributions, with the heavy aid of our exact algorithm in polynomial time provided to optimally solve the minimum cardinality bin covering problem with strong divisibility, we design two exact combinatorial algorithms to solve the BC-SDRP problem and the BC-SDBRC problem, respectively.

In this paper, we consider the min-max heterogeneous weighted delivery problem (the MMHWD problem). Specifically, given a weighted graph G=(V,E;w) with length function w:E→R^+ satisfying the triangle inequality, a fixed depot r∈ V , m items, and k vehicles having nonuniform speeds λ _1 , λ _2 , … , λ _k , each item is initially located at its source vertex s_j and it needs to be delivered to its target vertex t_j , j=1,2, … , m , each vehicle can move along some edges of G and only deliver one item at a time and each item only can be continuously delivered by one vehicle, it is asked to find a set 𝒞={C_1,C_2,… , C_k} of k tours for these k vehicles, each starting and ending at the same depot r, and collectively delivering all items, the objective is to minimize the maximum completion time of vehicles, where the completion time of a vehicle is its total length divided by its speed. We obtain the two main results. (1) Given any small constant δ >0 , we design an 134.4434(1+δ ) -approximation algorithm to solve the MMHWD problem, its time complexity is bounded by a polynomial in the input size and 1/δ ; (2) We provide an (φ +9/5-1/k) -approximation algorithm to resolve the MMHWD problem, where φ is the ratio of the largest vehicle speed to the smallest one.

In this paper, we consider the constrained Steiner strong connectivity augmentation (CStSCA) problem. Concretely, given a weighted digraph D=(V,A;w) , where w:A → R^+ is a weight function, K ( ⊆ V ) is a vertex-set consisting of k fixed vertices (called as terminals) and T_k=(V_k,A_k) is a strongly connected Steiner subgraph (of D), i.e., T_k contains at least one directed path from each terminal s to other each terminal t, where s, t∈ K , we are asked to find an arc-set A'⊆ A \ A_k to satisfy the constraints that, given each arc e ∈ A_k , the subgraph D[A' ∪ A_k\{e}] is still a strongly connected Steiner subgraph (of D), the objective is to minimize the summation of weights of all arcs in A' , where the summation is taken among all arc-sets to satisfy the constraints as mentioned-above. In particular, given a vertex-set K={x,y} , we refer the CStSCA problem as to the constrained directed circuit augmentation (CDCA) problem, and given a vertex-set K=V , we refer the CStSCA problem as to the constrained strong connectivity augmentation (CSCA) problem. We obtain the following three main results. (1) We design an 2-approximation algorithm to solve the CDCA problem in time O(mn); (2) Using the preceding algorithm in (1) as a subroutine for many times, we present an 2k-approximation algorithm to solve the CStSCA problem in time O(kmn); (3) We provide an 2-approximation algorithm to solve the CSCA problem in time O(n(m+nlog n)log n) .

In this paper, we consider the heterogeneous rooted tree cover (HRTC) problem, which further generalizes the rooted tree cover problem. Specifically, given a complete graph G=(V,E; w,f; r) and k construction teams, having nonuniform construction speeds λ _1 , λ _2 , … , λ _k , where r∈ V is a fixed common root, w:E→ℝ^+ is an edge-weight function, satisfying the triangle inequality, and f:V→ℝ^+_0 (i.e., ℝ^+∪{0}) is a vertex-weight function with f(r)=0 , we are asked to find k trees for these k construction teams, each tree having the same root r, and collectively covering all vertices in V, the objective is to minimize the maximum completion time of k construction teams, where the completion time of each team is the total construction weight of its related tree divided by its construction speed. In addition, substituting k paths for k trees in the HRTC problem, we also consider the heterogeneous rooted path cover (HRPC) problem. Our main contributions are as follows. (1) Given any small constant δ >0 , we first design a 58.3286(1+δ ) -approximation algorithm to solve the HRTC problem, and this algorithm runs in time O(n^2(n+log n/δ)+log (w(E)+f(V))) . Meanwhile, we present a simple 116.6572(1+δ ) -approximation algorithm to solve the HRPC problem, whose time complexity is the same as the preceding algorithm. (2) We provide a max{2ρ , 2+ρ -2/k} -approximation algorithm to resolve the HRTC problem, and that algorithm runs in time O(n^2) , where ρ is the ratio of the largest team speed to the smallest one. At the same time, we can prove that the preceding max{2ρ , 2+ρ -2/k} -approximation algorithm also resolves the HRPC problem.

In this paper, we address the trip-constrained vehicle routing cover problem (the TcVRC problem). Specifically, given a metric complete graph G=(V,E;w) with a set D (⊆ V) of depots, a set J (=V\ D) of customer locations, each customer having unsplittable demand 1, and k vehicles with capacity Q, it is asked to find a set 𝒞 ={C_i | i=1,2,… ,k} of k tours for k vehicles to service all customers, each tour for a vehicle starts and ends at one depot in D and permits to be replenished at some other depots in D before continuously servicing at most Q customers, i.e., the number of customers continuously serviced in per trip of each tour is at most Q (except the two end-vertices of that trip), where each trip is a path or cycle, starting at a depot and ending at other depot (maybe the same depot) in D, such that there are no other depots in the interior of that path or cycle, the objective is to minimize the maximum weight of such k tours in 𝒞 , i.e., min _𝒞max{w(C_i) | i=1,2,… ,k } , where w(C_i) is the total weight of edges in that tour C_i . Considering k vehicles whether to have common depot or suppliers, we consider three variations of the TcVRC problem, i.e., (1) the trip-constrained vehicle routing cover problem with multiple suppliers (the TcVRC-MS problem) is asked to find a set 𝒞={C_i | i=1,2,… ,k } of k tours mentioned-above, the objective is to minimize the maximum weight of such k tours in 𝒞 ; (2) the trip-constrained vehicle routing cover problem with common depot and multiple suppliers (the TcVRC-CDMS problem) is asked to find a set 𝒞={C_i | i=1,2,… ,k } of k tours mentioned-above, where each tour starts and ends at same depot v in D, each vehicle having its suppliers at some depots in D (possibly including v), the objective is to minimize the maximum weight of such k tours in 𝒞 ; (3) the trip-constrained k-traveling salesman problem with non-suppliers (the TckTS-NS problem, simply the TckTSP-NS) is asked to find a set 𝒞={C_i | i=1,2,… ,k} of k tours mentioned-above, where each tour starts and ends at same depot v in D, each vehicle having non-suppliers, the objective is to minimize the maximum weight of such k tours in 𝒞 . As for the main contributions, we design some approximation algorithms to solve these three aforementioned problems in polynomial time, whose approximation ratios achieve three constants 8-2/k , 7/2-1/k and 5, respectively.

As a result of the substantial increase in mobile data traffic that has placed a lot of pressure on cloud computing centers, it is necessary to select the network edge servers for data processing, this process is called edge computing. In order to use the network edge servers more efficiently, it is usually expected that the number of objects served by any edge server will exceed a certain number and also be controlled within a certain number. In order to efficiently solve the aforementioned problem, motivated by the Cloud-Edge Collaborative Computing Framework, we model the task offloading problem as a constrained assignment problems with bounds and maximum penalty (CA-BMP). Specifically, given m machines and n independent jobs, the machine g_i receives at least l_i and at most u_i jobs to execute, and each job must be either continuously executed on some machine with its processing time, or rejected with its penalty that we must pay for. We consider the CA-BMP problem and its important variant. (1) The CA-BMP problem is to find an assignment scheme of jobs to satisfy the constraints as mentioned-above, and the objective is to minimize the total processing times of executed jobs plus maximum penalty of rejected jobs; (2) The penalized assignment problem with bounds (the PA-B problem) is to find an assignment scheme of jobs to satisfy the constraints as mentioned-above, the objective is to minimize the total processing times of executed jobs plus maximum penalty of executed jobs. As our main contributions, we design two exact combinatorial algorithms to solve the CA-BMP problem and the PA-B problem, respectively. In addition, we give numerical examples to illustrate the execution processes of the two algorithms we proposed.

In this paper, we address the vertex-traversing-constrained mixed Chinese postman problem (the VtcMCP problem), which is a further generalization of the Chinese postman problem, and this new problem has many practical applications in real life. Specifically, given a connected mixed graph G=(V, E∪ A; w,b) with length function w(· ) on edges and arcs and traversal function b(· ) on vertices, we are asked to determine a tour traversing each link (i.e., either edge or arc) at least once and each vertex v at most b(v) times, the objective is to minimize the total length of such a tour, where n=|V| is the number of vertices and m=|E∪ A| is the number of links of G, respectively. We obtain the following four main results. (1) Given any two constants β≥ 1 and α≥ 1 , we prove that there is no polynomial-time algorithm with approximation ratios (1,β ) or (α , 1) for solving the VtcMCP problem, where an (h, k)-approximation algorithm for solving the VtcMCP problem is one algorithm that produces a solution with violating the vertex-traversing constraints by at most a ratio of h and with costing at most k times the optimal value; (2) We design a (3, 2)-approximation algorithm 𝒜 to solve the VtcMCP problem in time O(m^2log n) ; (3) We prove the fact that this algorithm 𝒜 in (2) is indeed an exact algorithm to optimally solve the VtcMCP problem for the case E=∅ ; (4) We present an exact algorithm to optimally solve the VtcMCP problem in time O(m^3) for the case A=∅ .

We consider the heterogeneous rooted tree cover (HRTC) problem. Concretely, given an undirected complete graph G=(V,E) with a root r∈ V , an edge-weight function w:E→ R^+ satisfying the triangle inequality, a vertex-weight function f:V∖{r}→ R^+_0 , and k construction teams having nonuniform construction speeds λ _1 , λ _2 , … , λ _k , we are asked to find k trees for these k construction teams to cover all vertices in V, each tree starting at the same root r, i.e., k trees having a sole common vertex called root r, the objective is to minimize the maximum completion time, where the completion time of each team is the total construction weight of its related tree divided by its construction speed. In this paper, we first design a 58.3286(1+δ ) -approximation algorithm to solve the HRTC problem in time O(n^3(1+1/δ)+log (w(E)+f(V\{r}))) for any δ >0 . In addition, we present a max{2ρ , 2+ρ -2/k} -approximation algorithm for resolving the HRTC problem in time O(n^2) , where ρ is the ratio between the maximum and minimum speed of these k teams.

In this paper, we address the constrained knapsack problem with divisible item sizes and penalties (the CK-DSP problem, for short), which is modelled as follows. Given a set $$A=\{a_{1},a_{2},\ldots ,a_{n}\}$$ of n items and a knapsack K with capacity L, where each item $$a_{i}\in A$$ has a size $$s_{i}\in Z^{+}$$ , a profit $$c_{i}\in R^{+}$$ , a penalty $$p_{i}\in R^{+}$$ , and these n item sizes are divisible, i.e., either $$s_{i}|s_{j}$$ or $$s_{j}|s_{i}$$ for any two distinct items $$a_{i}$$ and $$a_{j}$$ in A, each item $$a_{i}\in A$$ must be either put into K under the constraint that the summation of sizes of items in K does not exceed L, or rejected with its penalty $$p_{i}$$ that we must pay for, it is asked to find a subset $$X\subseteq A$$ to satisfy the constraint $$s(X)=\sum _{a_i\in X}s_i \le L$$ . We consider three versions of the CK-DSP problem, respectively. (1) The constrained knapsack problem with divisible item sizes and total penalties (the CK-DSTP problem, for short) is asked to find a subset $$X\subseteq A$$ to satisfy the constraint $$s(X) \le L$$ , the objective is to maximize the value of total profits of the items in X minus total penalties paid for the rejected items not in X; (2) The constrained knapsack problem with divisible item sizes and maximum penalty (the CK-DSMP problem, for short) is asked to find a subset $$X\subseteq A$$ to satisfy the constraint $$s(X) \le L$$ , the objective is to maximize the value of total profits of the items in X minus maximum penalty paid for the rejected items not in X; (3) The penalized knapsack problem with divisible item sizes (the PK-DS problem, for short) is asked to find a subset $$X\subseteq A$$ to satisfy the constraint $$s(X) \le L$$ , the objective is to maximize the value of total profits of the items in X minus maximum penalty paid for the items in X. As our contributions, we design three exact combinatorial algorithms to solve the CK-DSTP problem, the CK-DSMP problem and the PK-DS problem, and these three algorithms run in time $$O(n\log n)$$ , $$O(n^{2}\log n)$$ and $$O(n^{2}\log n)$$ , respectively, where n is the number of items with divisible sizes.

In this paper, we address the k -Chinese postman problem under interdiction budget constraints (the k -CPIBC problem, for short), which is a further generalization of the k -Chinese postman problem and has many practical applications in real life. Specifically, given a weighted graph G=(V,E;w,c;v_1) equipped with a weight function w:E→ℝ^+ that satisfies the triangle inequality, an interdiction cost function c:E→ℤ^+ , a fixed depot v_1∈ V , an integer k∈ℤ^+ and a budget B∈ℕ , we are asked to find a subset S_k⊆ E such that c(S_k)=∑ _e∈ S_kc(e)⩽ B and that the subgraph G\ S_k is connected, the objective is to minimize the value min _𝒞_E\ S_kmax{w(C_i) | C_i∈𝒞_E\ S_k} among such all aforementioned subsets S_k , where 𝒞_E\ S_k is a set of k -tours (of G\ S_k ) starting and ending at the depot v_1 , jointly traversing each edge in G\ S_k at least once, and w(C_i)=∑ _e∈ C_iw(e) for each tour C_i∈𝒞_E\ S_k . We obtain the following main results: (1) Given an α -approximation algorithm to solve the minimization knapsack problem, we design an (α +β ) -approximation algorithm to solve the k -CPIBC problem, where β = 7/2-1/k-⌊1/k⌋ . (2) We present a β -approximation algorithm to solve the special version of the k -CPIBC problem, where c ( e ) ≡ 1 for each edge e in G and β is defined in (1).

In the paper, we consider a generalization of the classical assignment problem, which is called the constrained assignment problem with bounds and penalties (CA-BP). Specifically, given a set of machines and a set of independent jobs, each machine has a lower and upper bound on the number of jobs that can be executed, and each job must be either executed on some machine with a given processing time or rejected with a penalty that we must pay for. No job can be executed on more than one machine. We aim to find an assignment scheme for these jobs that satisfies the constraints mentioned above. The objective is to minimize the total processing time of executed jobs as well as the penalties from rejected jobs. The CA-BP is related to some practical applications such as edge computing, which involves selecting tasks and processing them on the edge servers of an internet network. As a result, a motivation of this study is to improve the efficiency of internet networks by limiting the lower bound of the number of objects processed by each edge server. Our main contribution is modifying the previous network flow algorithms to satisfy the lower capacity constraints, for which we design two exact combinatorial algorithms to solve the CA-BP. Our methodologies and results bring novel perspectives into other research areas related to the assignment problem.

In this paper, we address the constrained parallel-machine scheduling problem with divisible processing times and penalties (the CPS-DTP problem), which is a further generalization of the parallel-machine scheduling problem with divisible processing times (the PS-DT problem). Concretely, given a set M of m identical machines and a set J of n independent jobs, each job has a processing time and a penalty, the processing times of these n jobs are divisible, and we implement these n jobs under the requirement that each job in J must be either continuously executed on one machine with its processing time, or rejected with its penalty that we must pay for. We may consider three versions of the CPS-DTP problem, respectively. (1) The constrained parallel-machine scheduling problem with divisible processing times and total penalties (the CPS-DTTP problem) is asked to find a subset A of J and a schedule T for jobs in A to satisfy the aforementioned requirement, the objective is to minimize the makespan of such a schedule T for jobs in A plus the summation of penalties paid for jobs not in A ; (2) The constrained parallel-machine scheduling problem with divisible processing times and maximum penalty (the CPS-DTMP problem) is asked to find a subset A of J and a schedule T for jobs in A to satisfy the aforementioned requirement, the objective is to minimize the makespan of such a schedule T for jobs in A plus maximum penalty paid for jobs not in A ; (3) The constrained parallel-machine scheduling problem with divisible processing times and bounded penalty (the CPS-DTBP problem) is asked to find a subset A of J and a schedule T for jobs in A to satisfy the aforementioned requirement and the summation of penalties paid for jobs not in A is no more than a fixed bound, the objective is to minimize the makespan of such a schedule T for jobs in A . As our main contributions, we design three exact algorithms to solve the CPS-DTTP problem, the CPS-DTMP problem and the CPS-DTBP problem, and these three algorithms run in time O((nlog n+nm)C) , O(n^2log n) and O((nlog n+nm)log C) , respectively, where C is the optimal value of same instance for the PS-DT problem.

In this paper, we address the line-constrained bottleneck k-Steiner tree (LcBkStT) problem. Specifically, given an input line l, a set P of n points in ℝ^2 and a positive integer k, we are asked to find at most k Steiner points located on this line l and additionally a spanning tree T_l on these n+k points, the objective is to minimize the length of the longest edge in T_l , where the edges in T_l are not allowed to cross this line l and the length of each edge in T_l is equal 0 if the two endpoints of that edge are located on the aforementioned line l. Using a technique of oriented Voronoi diagram, we design an exact algorithm for the LcBkStT problem in O(n log n + f(k)· n^k) time, where f(k) is a function dependent only on the positive integer k. This algorithm is an exact algorithm for the LcB1StT problem (for k=1 ) in O(n log n) time.

In this paper, we address the line-capacitated minimum Steiner tree problem (the Lc-MStT problem, for short), which is a variant of the (Euclidean) capacitated minimum Steiner tree problem and defined as follows. Given a set $$X=\{r_{1},r_{2},\ldots , r_{n}\}$$ of n terminals in $${\mathbb {R}}^2$$ , a demand function $$d:X \rightarrow {\mathbb {N}}$$ and a positive integer C, we are asked to determine the location of a line l and a Steiner tree $$T_l$$ to interconnect these n terminals in X and at least one point located on this line l such that the total demand of terminals in each maximal subtree (of $$T_l$$ ) connected to the line l, where the terminals in such maximal subtree are all located at the same side of this line l, does not exceed the bound C. The objective is to minimize total weight $$\sum _{e\in T_l}w(e)$$ of such a Steiner tree $$T_l$$ among all line-capacitated Steiner trees mentioned-above, where weight $$w(e)=0$$ if two endpoints of that edge $$e\in T_l$$ are located on the line l and otherwise weight w(e) is the Euclidean distance between two endpoints of that edge $$e\in T_l$$ . In addition, when this line l is as an input in $${\mathbb {R}}^2$$ and $$\sum _{r\in X} d(r) \le C$$ holds, we refer to this version as the 1-line-fixed minimum Steiner tree problem (the 1Lf-MStT problem, for short). We obtain three main results. (1) Given a $$\rho _{st}$$ -approximation algorithm to solve the Euclidean minimum Steiner tree problem and a $$\rho _{1Lf}$$ -approximation algorithm to solve the 1Lf-MStT problem, respectively, we design a $$(\rho _{st}\rho _{1Lf}+2)$$ -approximation algorithm to solve the Lc-MStT problem. (2) Whenever demand of each terminal $$r\in X$$ is less than  $$\frac{C}{2}$$ , we provide a $$(\rho _{1Lf}+2)$$ -approximation algorithm to resolve the Lc-MStT problem. (3) Whenever demand of each terminal $$r\in X$$ is at least $$\frac{C}{2}$$ , using the Edmonds’ algorithm to solve the minimum weight perfect matching as a subroutine, we present an exact algorithm in polynomial time to resolve the Lc-MStT problem.

We consider the constrained parallel-machine scheduling problem with divisible processing times and penalties (the CPS-DTP problem, for short). Specifically, given a set M={a_1,a_2,… ,a_m} of m identical machines, and a set J={b_1,b_2,… ,b_n} of n jobs, each job b_j∈ J has a processing time p_j∈ Z^+ and a penalty e_j∈ Z^+ , and the job processing times are divisible, i.e., either p_i|p_j or p_j|p_i for any two different jobs b_i and b_j in J. Each job b_j is either executed in processing time p_j with which we schedule this job on one of m machines, or rejected with its penalty e_j that we must pay for, it is asked to determine a subset A⊆ J such that each job b_j∈ A has to be scheduled only on one of m machines and each job b_j∈ J\ A has to be rejected. We consider three versions of the CPS-DTP problem, respectively. (1) The constrained parallel-machine scheduling problem with divisible processing times and total penalties (the CPS-DTTP problem, for short) is asked to determine a subset A⊆ J to satisfy the constraint mentioned-above, the objective is to minimize the makespan of the schedule T for accepted jobs in A plus the value of total penalties of the rejected jobs in J\ A ; (2) The constrained parallel-machine scheduling problem with divisible processing times and maximum penalty (the CPS-DTMP problem, for short) is asked to determine a subset A⊆ J to satisfy the constraint mentioned-above, the objective is to minimize the makespan of the schedule T for accepted jobs in A plus the maximum penalty paid for rejected jobs in J\ A ; (3) The constrained parallel-machine scheduling problem with divisible processing times and bounded penalty (the CPS-DTBP problem, for short) is asked to determine a subset A⊆ J to satisfy the constraint mentioned-above and the value of total penalties of the rejected jobs in J\ A is no more than a given bound, the objective is to minimize the makespan of the schedule T for accepted jobs in A. In this paper, we design an exact algorithm in pseudo-polynomial time to solve the CPS-DTTP problem, an exact algorithm in strongly polynomial time to solve the CPS-DTMP problem and an exact algorithm in polynomial time to solve the CPS-DTBP problem, respectively.

In this paper, we address the problem of constructing a Steiner tree in the Euclidean plane $$\mathbb {R}^2$$ using stock pieces of materials with fixed length, which is modelled as follows. Given a set $$X=\{r_{1},r_{2},\cdots ,r_{n}\}$$ of n terminals in $$\mathbb {R}^2$$ and some stock pieces of materials with fixed length L, we are asked to construct a Steiner tree T interconnecting all terminals in X, and each edge in T must be constructed by a part of that stock piece of material. The objective is to minimize the cost of constructing such a Steiner tree T, where the cost includes three components, (1) The cost of Steiner points needed in T; (2) The construction cost of constructing all edges in T and (3) The cost of stock pieces of such materials used to construct all edges in T. We can obtain two main results. (1) Using techniques of constructing a Euclidean minimum spanning tree on the set X and a strategy of solving the bin-packing problem, we present a simple 4-approximation algorithm in time $$O(n\log n)$$ to solve this new problem; (2) Using techniques of computational geometry to solve two nonlinear mathematical programming to obtain a key Lemma 8 and using other strategy of solving the bin-packing problem, we design a 3-approximation algorithm in time $$O(n^{3})$$ to resolve this new problem.