An efficient Algorithm to partition a Sequence of Integers into Subsets with equal Sums

TL;DR

This paper introduces an efficient algorithm for partitioning a sequence of integers into subsets with equal sums, addressing a specific NP-hard problem in a more practical context.

Contribution

The paper presents a novel efficient algorithm for the homogeneous subset sum partition problem, improving upon existing methods for this NP-hard challenge.

Findings

Algorithm efficiently partitions sequences into equal-sum subsets

Significant reduction in computational complexity for the homogeneous case

Potential applications in resource allocation and load balancing

Abstract

To partition a sequence of n integers into subsets with prescribed sums is an NP-hard problem in general. In this paper we present an efficient solution for the homogeneous version of this problem; i.e. where the elements in each subset add up to the same sum.

Equations

$$\sum _{x\in T_j}x$$

$$X_1(n,k)$$

$$X_2(n,k)$$

$$x$$

$$x=2k(i-1)+2k-(j-1)=2ki-(j-1)$$

$$x=2k(i-1)+j$$

$$\sum _{x\in T_j}x$$

$$=2k\frac{n^2}{4k^2}+\frac{n}{2k}=\frac{n(n+1)}{2k}=t$$

$$X_1^{\prime }(n,k)$$

$$X_2^{\prime }(n,k)$$

$$x$$

$$x=2k(i-1)+2k-j=2ki-j$$

$$x=2k(i-1)+(j-1)$$

$$\sum _{x\in T_j}x$$

$$=2k\frac{(n+1{)}^2}{4k^2}-\frac{n+1}{2k}=\frac{n(n+1)}{2k}=t$$

$$T_j$$

$$T_{\frac{2n-t}{2}+1,1}$$

$$n^{\prime }$$

$$k^{\prime }$$

$$t^{\prime }$$

$${\Delta }_{n^{\prime }}$$

$$t^{\prime }$$

$${\Delta }_{n^{\prime }}$$

$$k^{\prime }\cdot t^{\prime }$$

$$T_j$$

$$n^{\prime }$$

$$k^{\prime }$$

$$t^{\prime }$$

$${\Delta }_{n^{\prime }}$$

$$k^{\prime }\cdot t^{\prime }$$

$$T_{j,1}$$

$$n-(i-1)+n-2k+i$$

$$n^{\prime }$$

Full text

**An efficient Algorithm to partition a Sequence of Integers into Subsets with equal Sums **

Alexander Büchel1,2​​, Ulrich Gilleßen2​​, Kurt-Ulrich Witt1,2

Bonn-Rhein-Sieg University of Applied Sciences

Department of Computer Science

1b-it Applied Science Institute

2Research Group Discrete Mathematics and Optimization (ADIMO)

Sankt Augustin, Germany

alexander.buechel@smail.inf.h-brs.de, ulrich.gillessen@smail.inf.h-brs.de kurt-ulrich.witt@h-brs.de

February 20${}^{\text{th}}$, 2018

Abstract

Let $I_{n}=\left\{0,1,\ldots,n\right\}$ and $k,t$ be non-negative integers such that $t\geq n$ and $k\cdot t={n+1\choose 2}$. In this paper we present an efficient algorithm which partitions the elements of $I_{n}$ into $k$ mutually disjoint subsets $T_{j}$ such that $\cup_{j=1}^{n}T_{j}=I_{n}$ and $\sum_{x\in T_{j}}x=t$ for each $j\in\left\{1,2,\ldots,k\right\}$. The algorithm runs in ${\cal O}\left(\,n\cdot\left(\,\frac{n}{2k}+\log\frac{n(n+1)}{2k}\,\right)\,\right)$ time.

Key words: Set partition problem, Cutting sticks problem

1 Introduction

For $n\in\mathbb{N}$ let $I_{n}=\left\{0,1,\ldots,n\right\}$, $I_{n}^{+}=I_{n}-\left\{0\right\}$, and $\Delta_{n}=\sum_{l=0}^{n}l=\frac{n(n+1)}{2}$. We call a collection of $k$ mutually disjoint subsets $T_{j}\subseteq I_{n}$ a $(t_{1},t_{2},\ldots,t_{k})$-partition of $I_{n}$ if

• (i)

$\sum_{x\in T_{j}}x=t_{j}$ for $1\leq j\leq k$,

• (ii)

$\sum_{j=1}^{k}t_{j}=\Delta_{n}$ and

• (iii)

$\cup_{j=1}^{n}T_{j}=I_{n}$.

Given the set $I_{n}$ and the non-negative integers $t_{j}$, $1\leq j\leq k$, with $\sum_{j=1}^{k}t_{j}=\Delta_{n}$ the related decision problem $\Pi(n,t_{1},\ldots,t_{k})$ is to decide, whether there exists a $(t_{1},\ldots,t_{k})$-partition of $I_{n}$. Fu und Hu, (1992) show, that for $k,l,t\in\mathbb{N}$ with $0<l\leq\Delta_{n}$ and $(k-1)t+l+\Delta_{k-2}=\Delta_{n}$ a $(t,t+1,\ldots,t+k-2,l)$-partition of $I_{n}$ exists. Chen et al., (2005) prove, that a $(t_{1},\ldots,t_{k})$-partition of $I_{n}$ exists, if $\sum_{j=1}^{k}t_{j}=\Delta_{n}$ and $t_{j}\geq t_{j+1}$ for $1\leq j\leq k-1$ and $t_{k-1}\geq n$ hold. In Büchel et al., (2016) we present a [math]/$1$-linear program to solve partition problems.

In the special case, where $t_{j}=t=\sf const$ we call $T_{1},\ldots,T_{k}$ a $(k,t)$-partition of $I_{n}$. Given $n,k,t\in\mathbb{N}$ with $t\geq n$ and $\Delta_{n}=k\cdot t$ the decision problem reduces to the question, whether a $(k,t)$ partition of $I_{n}$ exists. Straight and Schillo, (1979) show that for all $k,t$ with $\Delta_{n}=k\cdot t$ and $t\geq n$ a partition of $I_{n}$ exists. Ando et al., (1990) withdraw the condition $\Delta_{n}=k\cdot t$ and prove that $I_{n}$ can be partitioned into $k$ disjoint subsets $T_{j}$ with $\sum T_{j}=t$ if and only if $k(2k-1)\leq k\cdot t\leq\Delta_{n}$.

Where as the cited papers study for which $k$-tuples $(t_{1},\ldots,t_{k})$-partitions of $I_{n}$ exist, we are interested in efficient algorithms to determine partitions. In this paper we consider problem instances $\Pi(n,k,t)$ with $t\geq n$ and $\Delta_{n}=k\cdot t$. In chapter 3 we introduce the recursive algorithm $\Pi\mathit{Solve}$ which efficiently determines a partition for each instance $\Pi(n,k,t)$. Before, in chapter 2 we present the so called meander algorithm which solves problem instances $\Pi(n,k,t)$, where $n$ is even and $2k$ is a divisor of $n$ or where $n$ is odd and $2k$ divides $n+1$, respectively. The reason is, that $\Pi\mathit{Solve}$ can be stopped, when one of these conditions is reached, and the remaining partition can be determined directly by means of the meander algorithm. In chapter 4 we analyze the run time complexity of $\Pi\mathit{Solve}$. Chapter 5 summarizes the paper and mentiones some ideas to improve $\Pi\mathit{Solve}$.

2 Meander Algorithm

For $a\in\mathbb{N}_{{}_{0}}$ and $b\in\mathbb{N}$ we denote $b\!\left|a\right.$ if $b$ is a divisor of $a$. Given the problem instance $\Pi(n,k,t)$ the meander algorithm applies if $n$ ist even and $2k\!\left|n\right.$ or if $n$ is odd an $2k\!\left|n+1\right.$, respectively. The algorithm distributes the elements of the set $I_{n}$ into the subsets $T_{j}$ such that

[TABLE]

2.1 Case: $\boldsymbol{n}$ even and $\boldsymbol{2k\!\left|n\right.}$

Figure 1 shows the part of the meander algorithm which solves problem instances $\Pi(n,k,t)$ when $n$ even and $2k$ divides $n$.

To prove that the algorithm determines a correct $(k,t)$-partition of $I_{n}$ we have to show (i) that the set of elements assigned to the subsets $T_{j}$ in (1) and (2) is equal to $I_{n}^{+}$ and (ii) that the resulting partition fulfills condition (2.1). We will verify (i) in Lemma 2.1 and (ii) in Lemma 2.2. Let

[TABLE]

be the sets of elements of $I_{n}^{+}$ which are distributed in assignment (1) or assignment (2), respectively.

Lemma 2.1

Let $\Pi(n,k,t)$ be a problem instance such that $n$ even and $2k\!\left|n\right.$, then $I_{n}^{+}=X_{1}(n,k)\cup X_{2}(n,k)$.

Proof*   For each $x\in I_{n}^{+}$ there exist unambiguously $i,r$ such that*

[TABLE]

We consider the two following sets of remainders $r\in I_{2k}^{+}$: $R_{1}=\left\{2k-(j-1)\mid 1\leq j\leq k\right\}$ and $R_{2}=\left\{j\mid 1\leq j\leq k\right\}$. Since $r\in R_{1}$, if $k+1\leq r\leq 2k$, it follows $R_{1}\cap R_{2}=\emptyset$ and $R_{1}\cup R_{2}=I_{2k}^{+}$. Thus with respect to (2.4) we get either

[TABLE]

or

[TABLE]

It follows $x\in X_{1}(n,k)\cup X_{2}(n,k)$. Hence we have shown $I_{n}^{+}\subseteq X_{1}(n,k)\cup X_{2}(n,k)$.

If $x\in X_{1}(n,k)$, then $k+1\leq x\leq n$, and if $x\in X_{2}(n,k)$ then $1\leq x\leq n-k$. Thus, if $x\in X_{1}(n,k)\cup X_{2}(n,k)$, we have $1\leq x\leq n$, hence $x\in I_{n}^{+}$ and thereby $X_{1}(n,k)\cup X_{2}(n,k)\subseteq I_{n}^{+}$.

${\Box}$

Lemma 2.2

Let $\Pi(n,k,t)$ be a problem instance with $n$ even and $2k\!\left|n\right.$, then the output $T_{j}$, $1\leq j\leq k$, of $\mathtt{meandereven}(n,k,t)$ fulfills condition (2.1).

Proof*   For each $j\in\left\{1,\ldots,k\right\}$ we have*

[TABLE]

Qed.

${\Box}$

Theorem 2.1

$\mathtt{meandereven}(n,k,t)$**

a)* determines a correct partition of $I_{n}$ for all problem instances $\Pi(n,k,t)$ with $n$ even and $2k\!\left|n\right.$, and*

b)* runs in ${\cal O}(n)$ time.*

Proof*   a) follows immediately from Lemma 2.1 and 2.2, and b) is obvious.*

${\Box}$

2.2 Case: $\boldsymbol{n}$ odd and $\boldsymbol{2k\!\left|n\!+\!1\right.}$

To solve problem instances $\Pi(n,k,t)$ with $n$ odd and $2k\!\left|n+1\right.$ we adapt slightly the $\mathtt{mean}$-$\mathtt{dereven}$-algorithm (see Fig. 2). The correctness of the $\mathtt{meanderodd}$-algorithm can be shown analogously to the proof of the correctnes of the $\mathtt{meandereven}$-algorithm. At this point we define the sets of elements asssigned due to labels (1) and (2) in the $\mathtt{meanderodd}$-algorithm as

[TABLE]

Lemma 2.3

Let $\Pi(n,k,t)$ be a problem instance such that $n$ odd and $2k\!\left|n+1\right.$, then $I_{n}=X_{1}^{\prime}(n,k)\cup X_{2}^{\prime}(n,k)$.

Proof*   For each $x\in I_{n}$ there exist unambiguously $i,r$ such that*

[TABLE]

We consider the sets of remainders $r\in I_{2k-1}$: $R_{1}^{\prime}=\left\{2k-j\mid 1\leq j\leq k\right\}$ and $R_{2}^{\prime}=\left\{j-1\mid 1\leq j\leq k\right\}=\left\{j\mid 0\leq j\leq k-1\right\}$. Since $r\in R_{1}^{\prime}$, if $k\leq r\leq 2k-1$, it follows $R_{1}\cap R_{2}=\emptyset$ and $R_{1}\cup R_{2}=I_{2k-1}$. Thus with respect to (2.7) we get

[TABLE]

or

[TABLE]

respectively. It follows $x\in X_{1}^{\prime}(n,k)\cup X_{2}^{\prime}(n,k)$. Hence we have shown $I_{n}\subseteq X_{1}^{\prime}(n,k)\cup X_{2}^{\prime}(n,k)$.

If $x\in X_{1}^{\prime}(n,k)$, then $k\leq x\leq n$, and if $x\in X_{2}^{\prime}(n,k)$ then $0\leq x\leq n-k$. Thus, if $x\in X_{1}^{\prime}(n,k)\cup X_{2}^{\prime}(n,k)$, we have $0\leq x\leq n$, hence $x\in I_{n}$ and thereby $X_{1}^{\prime}(n,k)\cup X_{2}^{\prime}(n,k)\subseteq I_{n}$.

${\Box}$

Lemma 2.4

Let $\Pi(n,k,t)$ be a problem instance with $n$ odd and $2k\!\left|n+1\right.$, then the output $T_{j}$, $1\leq j\leq k$, of $\mathtt{meanderodd}(n,k,t)$ fullfills condition (2.1).

Proof*   For each $j\in\left\{1,\ldots,k\right\}$ we have*

[TABLE]

Qed.

${\Box}$

Theorem 2.2

$\mathtt{meanderodd}(n,k,t)$**

a)* determines a correct partition of $I_{n}$ for all problem instances $\Pi(n,k,t)$ with $n$ odd and $2k\!\left|n+1\right.$, and*

b)* runs in ${\cal O}(n)$ time.*

Proof*   a) follows from Lemma 2.3 and 2.4, and b) is obvious.*

${\Box}$

3 The Algorithm $\boldsymbol{\Pi\mathit{Solve}}$

In this section we present the different cases which the $\Pi\mathit{Solve}$-algorithm distinguishes. The input to the algorithm is the set $I_{n}$ and integers $k,t\in\mathbb{N}$ with $t\geq n$ and $\Delta_{n}=k\cdot t$. The output is a partition $T_{j}$, $1\leq j\leq k$, which fullfills condition (2.1).

3.1 Case: $\boldsymbol{2n>t}$

In this case the algorithm makes a distinction between the cases $t$ even and $t$ odd.

3.1.1 Case: $\boldsymbol{t}$ even

The algorithm starts with filling $\frac{2n-t}{2}$ sets as follows:

[TABLE]

Obviously these sets are disjoint and fullfill condition (2.1). The union of these sets is the set $\left\{t-n,\ldots,\frac{t}{2}-1,\frac{t}{2}+1,\ldots,n\right\}$. Thus the elements of the set $I_{t-n-1}$ and the element $\frac{t}{2}$ remain, these have to be distributed into the empty $k-\frac{2n-t}{2}$ sets. To do this, each of these sets is split into two subsets:

[TABLE]

The total number of these subsets is $2(k-n)+t$. The set $T_{\frac{2n-t}{2}+1,1}$ is filled with the element $\frac{t}{2}$:

[TABLE]

Thus it remains to distribute the elements of $I_{t-n-1}$ into the $2(k-n)+t-1$ sets $T_{\frac{2n-t}{2}+1,2}$ and $T_{j,s}$, $\frac{2n-t}{2}+2\leq j\leq k$, $s\in\left\{1,2\right\}$, i.e. it remains to solve the problem instance $\Pi(n^{\prime},k^{\prime},t^{\prime})$ where

[TABLE]

We have to verify that this instance fulfills the input conditions

[TABLE]

and

[TABLE]

Using (3.4) – (3.6) we get on one side

[TABLE]

and on the other side

[TABLE]

Since for our initial problem $\Pi(n,k,t)$ the condition $\Delta_{n}=k\cdot t$ holds, the verification of (3.7) follows immediately from (3.9) and (3.10).

From $2n>t$ and $t$ even it follows $2n-2\geq t$ and from this we get $\frac{t}{2}\geq t-n-1$. Using (3.4) and (3.6) condition (3.8) is verified, too.

Thus the algorithm can recursively continue to solve the initial problem by determining a solution for the instance $\Pi(n^{\prime},k^{\prime},t^{\prime})$.

3.1.2 Case: $\boldsymbol{t}$ odd

In this case the algorithm initially fills $\frac{2n-t+1}{2}$ sets as follows:

[TABLE]

Obviously these sets are disjoint and fullfill condition (2.1). The union of these sets builds the set $\left\{t-n,\ldots,n\right\}$. Thus the elements of the set $I_{t-n-1}$ remain, these have to be distributed into the empty $k-\frac{2n-t+1}{2}$ sets. Thus the instance $\Pi(n^{\prime},k^{\prime},t^{\prime})$ has to be solved, where

[TABLE]

To proof that this instance is feasible we have to verify, that the input conditions (3.7) and (3.8) are fulfilled in this case as well. Using (3.12) – (3.14) we get on one side

[TABLE]

and on the other side

[TABLE]

Since $\Delta_{n}=k\cdot t$ the verification of (3.7) follows immediately from (3.16) and (3.10).

From $2n>t$ it follows $n>t-n-1$. From this we get by means of the input condition $t\geq n$ and the definitions (3.12) and (3.14): $t^{\prime}=t\geq n>t-n-1=n^{\prime}$, i.e. condition (3.8) is fulfilled.

3.2 Case: $\boldsymbol{2n\leq t}$

In this case each set $T_{j}$ is split into two disjoint subsets: $T_{j}=T_{j,1}\cup T_{j,2}$, $1\leq j\leq k$. The sets $T_{j,1}$ will be filled as follows:

[TABLE]

Thereby the elements $n-2k+1,\ldots,n$ are already disributed, and the two elements in each of these sets add up to

[TABLE]

It remains to partition the elements of $I_{n-2k}$ into the sets $T_{j,2}$ such that the sum of elements in each $T_{j,2}$ equals $t-(2(n-k)+1)$. Thus it remains to solve the problem instance $\Pi(n^{\prime},k^{\prime},t^{\prime})$ with

[TABLE]

As well as in the former cases we have to assure, that the input conditions (3.7) and (3.8) are fulfilled. On the one side we have

[TABLE]

and on the other side

[TABLE]

(3.7) follows immediately from (3.22) and (3.23).

From $t\geq 2n$ it follows $n+1\geq 4k$. By subtraction we get $t-n-1\geq 2n-4k$ and from this and definitions (3.19) and (3.21) $t^{\prime}=t-2n+2k-1\geq n-2k=n^{\prime}$, i.e. condition (3.8) is verified.

The considerations so far lead to the algorithm $\Pi\mathit{Solve}$ shown in figure 3, and we proved that it works correctly in all cases.

4 Complexity

In this section we analyse the worst case run time complexity of the $\Pi\mathit{Solve}$-Algorithm. The algorithm consists of four subalgorithms related to the cases we distinguish: (1) $2k\!\left|n\right.$ or $2k\!\left|n+1\right.$, (2) $t\geq 2n$, (3) $t<2n$ and $t$ even, (4) $t<2n$ and $t$ odd. We abbreviate these cases by $m$ (meander), $s$ (smaller), $ge$ (greater even), and $go$ (greater odd), respectively. Then the run $\Pi\mathit{Solve}(n,k,t)$ can be represented by a sequence $\rho^{\prime}(n,k,t)\in\left\{m,s,ge,go\right\}^{+}$.

Example 4.1

a)* Let $n=1337$. The list of runs for all partitions of $I_{1337}$ is:*

[TABLE]

b)* Let $n=9999$, then we have*

[TABLE]

${\Box}$

Let $\alpha$ be a non empty sequence over $\Omega^{\prime}=\left\{m,s,ge,go\right\}$, then $\mathit{first}(\alpha)$ is the first and $\mathit{last}(\alpha)$ the last symbol of $\alpha\in{\Omega^{\prime}}^{+}$, and $\mathit{head}(\alpha)$ is the sequence without the last symbol. $\left|w\right|_{a}$ is the number of occurrences of symbol $a\in\Omega^{\prime}$ in the sequence $w\in\Omega^{\prime\ast}$.

Obviously we have

Lemma 4.1

Let $\Pi(n,k,t)$ be a problem instance, then $\mathit{last}(\rho^{\prime}(n,k,t))=m$ and $m$ is not a member of $\mathit{head}(\rho^{\prime}(n,k,t))$.

${\Box}$

Thus, we may neglect the last symbol of $\rho^{\prime}(n,k,t)$ and denote $\rho(n,k,t)=\mathit{head}(\rho^{\prime}(n,k,t))$. As well we do not need the alphabet $\Omega^{\prime}$, because $\rho(n,k,t)\in\left\{s,\mathit{ge},\mathit{go}\right\}^{\ast}$. We denote this alphabet by $\Omega$.

Next we show, that the last call before the recursion stops with the $m$-case cannot be $s$.

Lemma 4.2

Let $\Pi(n,k,t)$ be a problem instance. If $\left|\rho(n,k,t)\right|\geq 1$, then $\mathit{last}(\rho(n,k,t))\not=s$.

Proof*   We assume $\mathit{last}(\rho(n,k,t))=s$. Let $\Pi(\nu,\kappa,\tau)$ be the problem instance before the last $s$-call. Then by (3.19) and (3.20) after the $s$-call we have $\nu^{\prime}=\nu-2\kappa$ and $\kappa^{\prime}=\kappa$. Since the next call is $m$ it has to be $2\kappa^{\prime}\!\left|\nu^{\prime}\right.$ or $2\kappa^{\prime}\!\left|\nu^{\prime}+1\right.$, i.e. $2\kappa\!\left|\nu-2\kappa\right.$ or $2\kappa\!\left|\nu-2k+1\right.$. It follows $2\kappa\!\left|\nu\right.$ or $2\kappa\!\left|\nu+1\right.$. Hence the instance $\Pi(\nu,\kappa,\tau)$ would have been solved by an $m$-call, a contradiction to our assumption $\mathit{last}(\rho(n,k,t))=s$.*

${\Box}$

Corollary 4.1

Let $\Pi(n,k,t)$ be a problem instance. If $\left|\rho(n,k,t)\right|\geq 1$, then $\mathit{last}(\rho(n,k,t))\in\left\{\mathit{ge},\mathit{go}\right\}$.

${\Box}$

4.1 Case: $\boldsymbol{2n>t}$ and $\boldsymbol{t}$ odd

From $2n>t$ we can conclude $t>2(t-n-1)$. Using (3.12) and (3.14) we get $t^{\prime}>2n^{\prime}$. This leads to

Lemma 4.3

Let $\Pi(n,k,t)$ be a problem instance with $2n>t$, $t$ odd and $\rho^{\prime}(n,k,t)=\alpha\mathit{go}\beta$, $\alpha\in\Omega^{\ast}$, $\beta\in\Omega^{\prime+}$, then

a)* $\mathit{first}(\beta)=m$, if $\left|\beta\right|=1$,*

b)* $\mathit{first}(\beta)=s$, if $\left|\beta\right|\geq 2$.*

${\Box}$

Thus, after the case $\mathit{go}$ the recursion ends by call of the meander algorithm or the recursion continues with the $\mathit{s}$ case either.

Corollary 4.2

Let $\Pi(n,k,t)$ be a problem instance with $2n>t$ and $t$ odd, then $\left|\rho(n,k,t)\right|_{s}\geq\left|\rho(n,k,t)\right|_{go}$.

${\Box}$

4.2 Case: $\boldsymbol{2n>t}$ and $\boldsymbol{t}$ even

From (3.6) it follows immediately

[TABLE]

4.3 Case: $\boldsymbol{2n\leq t}$

In this case if the algorithm performs the instance $\Pi(n,k,t)$, then the next instance to solve may be $\Pi(n^{\prime},k,t^{\prime})$ with $n^{\prime}=n-2k$ and $t^{\prime}=t-2(n-k)-1$ (cf. subsection 3.2, equations (3.19) and (3.21), respectively). By $n^{(\ell)}$ and $t^{(\ell)}$ we denote the value of $n$ and $t$ in the $\ell^{\text{th}}$ recursion call in the case $2n^{(\ell)}\leq t^{(\ell)}$. Thus we have $n^{(0)}=n$, $n^{(2)}=n^{\prime}=n-2k$ and $t^{(0)}=t$, $t^{(1)}=t^{\prime}=t-2(n-k)-1$, for example. By induction we get

[TABLE]

Now we determine the order of the maximum value of $\ell$ guaranteeing the condition $2n^{(\ell)}\leq t^{(\ell)}$. Using (4.2) and (4.3) we get

[TABLE]

To determine $\ell$ we solve the quadratic equation

[TABLE]

which has the solutions

[TABLE]

i.e.

[TABLE]

Finally we get

[TABLE]

Thus, we have just proven

Lemma 4.4

Let $\Pi(n,k,t)$ be a problem instance. If $\rho(n,k,t)=s^{\ell}\,x$ with $x\in\left\{\mathit{ge},\mathit{go}\right\}$, then $\ell\leq\dfrac{n}{2k}$.

${\Box}$

Corollary 4.2, inequality (4.1) and Lemma 4.4 lead to

Theorem 4.1

Let $\Pi(n,k,t)$ be a problem instance.

a)*   Then the recursion depth of $\Pi\mathit{Solve}(n,k,t)$ is ${\cal O}\left(\,\frac{n}{2k}+\log\frac{n(n+1)}{2k}\,\right)$.*

b)*   Since the complexity of operations the algorithm performs in each recursion call (assigning elements of $I_{n}$ to some set $T_{j}$, arithmetic comparisons and oprerations) is ${\cal O}(n)$ it follows that the worst case run time complexity of $\Pi\mathit{Solve}$ is*

[TABLE]

. ${\Box}$

5 Conclusion

In section 3 we present the recursive algorithm $\Pi\mathit{Solve}$ which solves following subset partition problems: Given $n,k,t\in\mathbb{N}$ and $I_{n}$ with $t\geq n$ and $\Delta_{n}=k\cdot t$, then the algorithm partitions the integers from [math] to $n$ into $k$ mutually disjoint sets such that the elements in each set add up to $t$. The recursion can be stopped, if $n$ ist even and ${2k}$ is a divisor ${n}$ or if $n$ is odd and ${2k}$ is a divisor of ${n+1}$, respectively, because in these cases the meander algorithms presented in section 2 can be applied, which directly determines a partition.

We prove that the algorithm works correctly and runs in

[TABLE]

time for each problem instance $\Pi(n,k,t)$.

In Jagadish, (2015) an approximation algorithm for the cutting sticks-problem is presented. Because the cutting sticks-problem can be transformed into an equivalent partitioning problem our algorithms can be applied to the corresponding cutting sticks-problems.

Further research may investigate whether ideas from the previous chapters and cited papers can be used to improve the efficiency of the $\Pi\mathit{Solve}$-algorithm. In Büchel et al., (2016), Büchel et al., 2017a and Büchel et al., 2017b we present efficient solutions for problem instances $\Pi(n,k,t)$, where $n=q\cdot k$, $q,k$ odd; $n=m^{2}-1$, $m\geq 3$; $n=p-1$, $p\in\mathbb{P}$; $n=p$, $p\in\mathbb{P}$; $n=2p$; and $p\in\mathbb{P}$, where $\mathbb{P}$ is the set of prime numbers. Thus we may augment the $\Pi\mathit{Solve}$-algorithm by related conditions to stop further recursion calls.

Acknowledgement: We would like to thank Arkadiusz Zarychta who created a tool by means of which we are able to test the algorithm and to analyse experimentally its performance.