Fatal编程技术网
  • algorithm/
  • Algorithm 算法：查找分治算法的递归方程

Algorithm 算法：查找分治算法的递归方程

algorithm recursion

Algorithm 算法：查找分治算法的递归方程,algorithm,recursion,runtime,divide-and-conquer,Algorithm,Recursion,Runtime,Divide And Conquer,我有下面的“分而治之”算法A1 A1将大小为n的问题划分为大小为n/4的4个子问题。 然后，解出它们并将解组合到12n时间 如何编写给出算法运行时间的递归方程。回答“如何编写给出算法运行时间的递归方程”的问题 你应该这样写： 让T（n）表示输入大小为n的算法的运行时间 T（n）=4*T（n/4）+12*n 回答“如何编写给出算法运行时间的递归方程” 你应该这样写： 让T（n）表示输入大小为n的算法的运行时间 T（n）=4*T（n/4）+12*n 最佳描述的递归关系由以下公式给出： T(n)=4*

我有下面的“分而治之”算法A1

A1将大小为n的问题划分为大小为n/4的4个子问题。 然后，解出它们并将解组合到12n时间

如何编写给出算法运行时间的递归方程。

回答“如何编写给出算法运行时间的递归方程”的问题

你应该这样写： 让T（n）表示输入大小为n的算法的运行时间

T（n）=4*T（n/4）+12*n

回答“如何编写给出算法运行时间的递归方程”

你应该这样写： 让T（n）表示输入大小为n的算法的运行时间

T（n）=4*T（n/4）+12*n

最佳描述的递归关系由以下公式给出：

T(n)=4*T(n/4)+12*n
其中，
T（n）
=输入大小为n的给定算法的运行时间，
4
=子问题的数量，
n/4
=每个子问题的大小

使用主定理，时间复杂度计算为：
theta（n*logn）

最能描述的递推关系如下：

T(n)=4*T(n/4)+12*n
其中，
T（n）
=输入大小为n的给定算法的运行时间，
4
=子问题的数量，
n/4
=每个子问题的大小

使用主定理计算时间复杂度为：
theta（n*logn）

尽管主定理确实给出了答案的捷径，但必须理解大O运行时的推导。分治递归关系的形式为
T（n）=q*T（n/j）+cn
，其中
q
是子问题的数量，
j
是我们为每个子问题划分数据的量，
cn
是在每个级别上划分/组合/操作每个子问题所需的时间
cn
也可以是
cn^2
或
c
，无论运行时是什么

在您的例子中，有4个大小为n/4的子问题，每个级别在
12n
时间内求解，给出了
T（n）=4*T（n/4）+12n
的递归关系。从这个循环中，我们可以导出算法的运行时间。假设它是一个分而治之的关系，我们可以假设基本情况是
T（1）=1

为了解决这个问题，我将使用一种叫做替换的技术。我们知道
T（n）=4*T（n/4）+12n
，所以我们将替换
T（n/4）。T（n/4）=4*T（n/16）+12（n/4）
。把这个插入到方程中，我们得到了
T（n）=4*（4*T（n/16）+12n/4）+12n
，我们可以简化为
T（n）=4^2*T（n/16）+2*12n
。同样，我们在方程中还有更多的工作要做，以捕获所有级别的功，因此我们用
T（n/16），T（n）=4^3*T（n/64）+3*12n
。我们看到这个模式出现，并且知道我们想要一直到我们的基本情况，
T（1）
，这样我们就可以得到
T（n）=4^k*T（1）+k*12n
。这个等式定义了分治算法中的总工作量，因为我们已经替换了中的所有级别，我们仍然有一个未知变量k，我们希望它是
n
我们通过求解方程
n/4^k=1
得到
k
，因为我们知道我们已经达到了只对一个变量调用算法的地步。我们求解n，得到
k=log4n
。这意味着我们已经做了
log4n
替换。我们将其插入到
k
中，得到
T（n）=4^log4n*T（1）+log4n*12n
。我们将其简化为
T（n）=n*1+log4n*12n
。由于这是大O分析，并且由于对数的基性质的变化，
log4n
处于
O（log2n）
中，我们得到
T（n）=n+12n*logn
，这意味着
T（n）
处于
nlogn
的大O中，尽管主定理确实给出了答案的捷径，必须理解Big O运行时的派生。分治递归关系的形式为
T（n）=q*T（n/j）+cn
，其中
q
是子问题的数量，
j
是我们为每个子问题划分数据的量，
cn
是在每个级别上划分/组合/操作每个子问题所需的时间
cn
也可以是
cn^2
或
c
，无论运行时是什么

在您的例子中，有4个大小为n/4的子问题，每个级别在
12n
时间内求解，给出了
T（n）=4*T（n/4）+12n
的递归关系。从这个循环中，我们可以导出算法的运行时间。假设它是一个分而治之的关系，我们可以假设基本情况是
T（1）=1

为了解决这个问题，我将使用一种叫做替换的技术。我们知道
T（n）=4*T（n/4）+12n
，所以我们将替换
T（n/4）。T（n/4）=4*T（n/16）+12（n/4）
。把这个插入到方程中，我们得到了
T（n）=4*（4*T（n/16）+12n/4）+12n
，我们可以简化为
T（n）=4^2*T（n/16）+2*12n
。同样，我们在方程中还有更多的工作要做，以捕获所有级别的功，因此我们用
T（n/16），T（n）=4^3*T（n/64）+3*12n
。我们看到这个模式出现，并且知道我们想要一直到我们的基本情况，
T（1）
，这样我们就可以得到
T（n）=4^k*T（1）+k*12n
。这个方程定义了分治算法中的总工作量，因为我们已经替换了中的所有级别，但是，我们仍然有一个未知变量k，我们希望它是
n
我们通过解方程
n/4^k=1
得到
k
，因为我们知道我们已经达到了