将数组拆分为 K 个子数组，其中相邻元素之间的绝对差之和最小

这个问题可以用动态规划来解决。具体的思路是，用一个二维数组 dp[i][j] 表示将前 i 个元素分成 j 组时相邻元素之间的绝对差之和的最小值。其中 dp[i][1] 就是前 i 个元素的总和，因为只分成一组时，相邻元素之间的绝对差之和就是它们的距离，即相邻元素之间的差。

对于 dp[i][j]，我们可以用一个变量 sum 来表示前 k 个元素的和（其中 k<i），然后枚举最后一组的起点（记为 k+1），得到 dp[i][j] 的值。

具体的状态转移方程如下：

$dp[i][j]=min{dp[k][j-1]+abs(sum-a[k+1][i])}$ (j-1<=k<i)

其中 a[k+1][i] 表示从 k+1 到 i 的元素的总和，abs 表示绝对值。这个方程的意思是：我们可以先将前 k 个元素分成 j-1 组，然后将剩下的元素分成一组，从而得到 dp[i][j]。这样得到的绝对差之和是 dp[k][j-1]（前 k 个元素分成 j-1 组的绝对差之和），加上从第 k+1 个元素到第 i 个元素的绝对差之和 abs(sum-a[k+1][i])。

最后，答案即为 dp[n][k]，其中 n 表示元素的个数。因为要分成 k 组，所以最终答案就是将前 n 个元素分成 k 组时相邻元素之间的绝对差之和的最小值。

下面是使用 Python 实现上述算法的代码片段：

def splitArray(nums: List[int], k: int) -> int:
    n = len(nums)
    dp = [[float('inf')]*(k+1) for _ in range(n+1)]
    sums = [0]*(n+1)
    for i in range(1, n+1):
        sums[i] = sums[i-1] + nums[i-1]
        dp[i][1] = sums[i]
    for j in range(2, k+1):
        for i in range(j, n+1):
            for p in range(j-1, i):
                dp[i][j] = min(dp[i][j], dp[p][j-1]+abs(sums[i]-sums[p]))
    return dp[n][k]

该函数接收一个数组 nums 和一个整数 k，返回将数组 nums 分成 k 个子数组时相邻元素之间的绝对差之和的最小值。

其中，sums 列表表示前缀和，即 sums[i] 表示前 i 个元素的和。dp[i][j] 表示将前 i 个元素分成 j 组时相邻元素之间的绝对差之和的最小值。我们需要初始化 dp[i][1] 为前 i 个元素的和。

接着，我们使用三重循环来计算 dp[i][j] 的值。其中，最外层的循环枚举组数 j（从 2 到 k），次外层的循环枚举元素个数 i（从 j 到 n），最内层的循环枚举最后一组的起点 p（从 j-1 到 i-1），更新 dp[i][j] 的值。在更新 dp[i][j] 的过程中，我们需要用到前缀和 sums。最后，返回 dp[n][k] 即可。

该算法的时间复杂度为 O(n^3)，空间复杂度为 O(nk)。