Algorithm 分段最小二乘法

给出一个算法，该算法将平面上的一系列点（x_1，y_1），（x_2，y_2），…，…，（x_n，y_n）和一个整数k作为输入，并返回由最多k个点组成的最佳分段线性函数f，该函数使平方和误差最小。您可以假设您可以访问一个算法，该算法通过Θ（n）时间内的一组n个点计算一个段的平方和误差。解决方案应使用O（n^2k）时间和O（nk）空间

---

有人能帮我解决这个问题吗？非常感谢你

如果您可以对

n^2

中的某个段进行最小二乘，那么使用动态规划可以很容易地在

n^2 k^2

中执行您想要的操作。您可以将其优化为单个

k

。

（这对于您的家庭作业来说已经太晚了，但希望它能有所帮助。）
首先是python/numpy中仅针对

k=4

的动态编程， 帮助您了解动态规划的工作原理； 一旦理解了这一点，为任何k编写循环都应该很容易。
另外，

Cost[]

是一个二维矩阵，空间O（n^2）； 关于空间O（n k），请参见结尾的注释

到目前为止，我们有一个nxn成本矩阵，空间O（n^2）。 要深入到O（nk）空间， 仔细查看dyn程序代码中的

成本[i，j]

访问模式：

for nleft .. to n:
    Cost_nleft = Cost[j,nleft ]  -- time nleft or nleft^2
    for k in 3 4 5 ...:
        min [ C[k-1, j-1] + Cost_nleft[j]  for j .. to nleft ]

此处

成本\u nleft

是一行完整的n x n成本矩阵，~n段，根据需要生成。 对于线段，这可以在时间O（n）内完成。 但是如果“通过一组n个点的一个段的错误需要O（n）个时间”，

---

看来我们赶上了时间O（n^3）。有人评论吗？

O（n^（2k））

或

O（n^2*k）

？同样，函数必须是连续的吗？它是O（n^2*k），函数不需要是连续的。我认为如果

k=O（n）

的话是不可能的，因为你可能至少需要计算每个中缀（子串/连续子序列）的最小二乘值输入的一部分。这些单独花费你的

O（n）

O（n）algorithm blackbox的

Ω（n^3）

OPs。问题的其余部分意味着像我建议的DP解决方案是理想的解决方案，因此可能是问题解决者的错误，或者您遗漏了一些信息？

""" spreads( all y[:j] ) in time O(n)

define spread( y[] ) = sum (y - average y)^2
    e.g. spread of 24 hourly temperatures y[0:24] i.e. y[0] .. y[23]
    around a horizontal line at the average temperature
        (spread = 0 for constant temperature,
        24 c^2 for constant + [c -c c -c ...],
        24 * variance(y) )

    How fast can one compute all 24 spreads
    1 hour (midnight to 1 am), 2 hours ... all 24 ?

    A simpler problem: compute all 24 averages in time O(n):
        N = np.arange( 1, len(y)+1 )
        allav = np.cumsum(y) / N
            = [ y0,  (y0 + y1) / 2,  (y0 + y1 + y2) / 3 ...]
    An identity:
        spread(y) = sum(y^2) - n * (av y)^2
    Voila: the code below, all spreads() in time O(n).

    Exercise: extend this to spreads around least-squares lines
    fit to [ y0,  [y0 y1],  [y0 y1 y2] ... ], not just horizontal lines.
"""

from __future__ import division
import sys
import numpy as np


#...............................................................................
def spreads( y ):
    """ [ spread y[:1], spread y[:2] ... spread y ] in time O(n)
        where spread( y[] ) = sum (y - average y )^2
            = n * variance(y)
    """
    N = np.arange( 1, len(y)+1 )
    return np.cumsum( y**2 ) - np.cumsum( y )**2 / N

def spreads_allij( y ):
    """ -> A[i,j] = sum (y - av y)^2, spread of y around its average
        for all y[i:j+1] 
        time, space O(n^2)
    """
    y = np.asanyarray( y, dtype=float )
    n = len(y)
    A = np.zeros((n,n))
    for i in range(n):
        A[i,i:] = spreads( y[i:] )
    return A

for nleft .. to n:
    Cost_nleft = Cost[j,nleft ]  -- time nleft or nleft^2
    for k in 3 4 5 ...:
        min [ C[k-1, j-1] + Cost_nleft[j]  for j .. to nleft ]