我需要帮助找到递归算法的复杂性;我知道为了解决这个问题,我必须找到线性递归,然后应用主定理。据我所知,如果只考虑一个参数,就可以很容易地找到递归;
在这种情况下,有两个参数(i,j)。考虑以下调用的函数(A,1,n):
integer stuff(integer [] A, integer i, integer j){
if i ≥ j then return i – j
integer h ← 0
for integer k ← 1 to floor((j – i + 1)/3) do {
我有一个叫做二进制和的方法
Algorithm BinarySum(A, i, n):
Input: An array A and integers i and n
Output: The sum of the n integers in A starting at index i
if n = 1 then
return A[i]
return BinarySum(A, i, n/ 2) + BinarySum(A, i + n/ 2, n/ 2)
忽略了让一个简单的问题变得复杂的事实,我被要求找到大O。这是我的思考过程。对于大小为N的数组,我将制作1+2+4 ..+N个递归调用。这
考虑元素唯一性问题,其中给出了一个范围,i,i+ 1,。。。,j,数组的索引,A,我们想确定这个范围的元素,Ai,Ai+1,。。。,Aj,都是唯一的,也就是说,在这组数组条目中没有重复元素。考虑下面的递归算法(ineffi)。
public static boolean isUnique(int[] A, int start, int end) {
if (start >= end) return true; // the range is too small for repeats
// check recursively if first part of array A
我对递推方程概念很陌生,需要以下算法的帮助
G(n)
Require: A positive integer n.
if n <= 1 then
return n
else
return 5*g(n - 1) - 6* g(n- 2)
end if
我给出了以下关于上述问题的重现公式:
T(n) = n,如果n<=1
T(n) = 5*T(n-1) - 6.T(n-2),若n>1
如果这是正确的,我还必须设置一个重复次数的乘法执行这个算法。请帮帮忙。
在双色最近对问题中,我们在平面上得到一组红点R和一组蓝点B。问题是返回两个点对,一个红色和一个蓝色,其距离在所有红色-蓝色对中是最小的。
我的算法就是其中的一种。
1: If both R and B store only a constant number of points, sort the points according to <y , com- pute a bichromatic closest pair using a brute- force algorithm, and return.
2: Assume |R| >= |B|, otherwise reve
在T(n) = T(n-1) +2+ T(n+1)以下是否存在递推关系?
我只是计算中间变量赋值和最后一行,因为所有的if语句都排除了其他语句.这个方法正确吗?
/*
* V is sorted
* V.size() = N
* The function is initially called as searchNumOccurrence(V, k, 0, N-1)
*/
int searchNumOccurrence(vector<int> &V, int k, int start, int end) {
if (start > end) ret
我现在正在学习关于重复关系的知识。我可以解决它们并计算出它们的界限,但我不确定的是如何为一个特定的算法求出一个递归关系。下面是我书中的一个例子:
// Sort array A[] between indices p and r inclusive.
SampleSort (A, p, r) {
// Base Case: use HeapSort
//
if (r - p < 12) {
HeapSort(A, p, r) ;
}
// Break the array into 1st quarter, 2nd
用R语言给出了一个问题,以求递推关系x(n) = 2*x(n-1) - x(n-2)的第30项,其中x(1) =0和x(2) = 1。我知道答案是29来自数学推论。但作为R的新手,我对如何在这里工作有点困惑。以下是我的代码:
loop <- function(n){
a <- 0
b <- 1
for (i in 1:30){
a <- b
b <- 2*b - a
}
return(a)
}
loop(30)
结果,我得到了1,这是远远不够的。
如果您想知道为什么这看起来像Python-ish,到目前为止,我只接触过Pyth
T(n) = { 0 If n = 0
{ T(square root n) + 1 If n > 0
我正试图用替换来解决这个问题。
我猜:O(lg lg n)
通过归纳
T(n) = c lg lg n
T(n) =< c (lg lg square root n) + 1
自square root n = n^1/2 =< c(1/2 lg lg n) + 1以来
我无法继续这个部分来获得lg lg n,我看到了许多使用权力的解决方案。还有别的路吗?
有人能画一棵递归树来帮助我理解吗?
1
||
n^1/2
||
void function(int A[], int i, int j){
if (j == i+1)
if (A[i] > A[j])
swap(A,i,j)
else {
int k = (j-i+1)/3;
function(A,i,j-k);
function(A,i+k,j);
function(A,i,j-k);
}
}
这段代码摘自我的算法分析课上的一次期中考试。学生们被要求导出一个描述这个函数
我很难理解如何发展循环关系。我得到的代码是
int result = bizarre(n, n);
public static int bizarre (int first, int second)
{
if (second <= 1)
{
int temp = 0;
for (int i = 0; i < first; i++)
temp += i;
return temp;
}
return bizarre (first, second-1);
}
据我所知,
T(n) = n + 1
T(1)
有fnc的:
bool ISINTREE( int x, BinTree<int> t)
{
bool b = false
if (!t.isEmpty())
{
if (x == t.getRoot())
{ b = true }
else
{
if (ISINTREE(x,t.leftTree()))
{ b = true }
if (ISINTREE(x,t.rightTree()))
{ b = true }
}
}
r