我有以下两个相互递归的函数,
由于Python不能很好地处理尾调用优化,所以程序员应该将这些函数表示为有状态循环。Python社区使用什么技术将这类方程转换为显式循环?
还是这些转换依赖于算法和每个递归函数必须分开分析?
递归实现
那就让C1 = xpa, C2 = p and C3 = xpb
def obaraSaika(p,s00x,i,j,xpa,xpb):
if i < 0 or j < 0: return 0
if i == 0 and j == 0: return s00x
if i >= 1: return xpa*(o
大多数情况下,我们需要理解其他人的代码--例如,我正在研究Sedgewick的在线资源中的图算法,具体的代码示例取自循环检测算法这里:
private void dfs(Graph G, int u, int v) {
marked[v] = true;
for (int w : G.adj(v)) {
// short circuit if cycle already found
if (cycle != null) return;
if (!marked[w]) {
我有以下函数,它应该在笛卡儿平面上产生所有坐标,我可以从原点分n步到达:
原点是‘位置’,步骤的数目是‘强度’,这是一个int 1-10。但是,我一直得到一个堆栈溢出错误。每次我这么说的时候,我都会在ArrayList的位置上说清楚。有什么想法?
更新代码:
// Returns all positions reachable in 'strength' steps
public ArrayList<Int2D> findEscapeSpace(Int2D location, Field f) {
// Are we still within
我试图找到并解决的动态规划方法的递归关系。作为一个免责声明,这是一个家庭作业的一部分,我已经完成了,但对分析感到困惑。
下面是我的(工作)代码:
int shop(int m, int c, int items[][21], int sol[][20]) {
if (m < 0) return NONE; // No money left
if (c == 0) return 0; // No garments left
if (sol[m][c] != NONE) return sol[m]
我目前正在处理一个处理大量递归调用的附带项目。我不是一个计算机科学家,所以我不知道如何优化我的代码。我知道递归函数不是很有效,我听说您经常可以用尾调用来替换它,但我不太清楚如何做到这一点。该函数接受三个数组: appendList、sequence和used。其他参数、基、长度、索引和最后一个单词都是整数。
function Recursion(appendList, base, length, sequence, used, lastWord, index)
#Global variables:
global G_Seq_List
global G_Seq_Index
used = one
我还没有实现任何东西,但我在考虑使用递归来识别网格中“主动连接”到给定单元的所有单元,也就是那些“活动的”单元,即通过与有关的(活动的)单元单元共享一个脸而直接连接的单元,或者通过与其(活动的)邻居之一共享一个脸来更远地/间接地连接的单元。断开连接是因为网格中的一些单元可能被认为是“非活动”(不管定义如何)。我的想法/伪代码如下:
//Call function to traverse connections
traverse_connections(cell);
//Traverse function definition
bool traverse_connections(cell) {
我现在正在学习关于重复关系的知识。我可以解决它们并计算出它们的界限,但我不确定的是如何为一个特定的算法求出一个递归关系。下面是我书中的一个例子:
// 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
我一直在尝试围绕递归关系的概念,我看到了如何划分,征服和合并。我不能理解的是,如何从多参数函数中推导出正确的递归关系,该函数处理一组值,一个最低指数和一个最高指数。 更多上下文:我的基本情况是最低的索引等于最高的索引。当满足该条件时,我返回最低索引中的元素。(这也是最高的)它是唯一的元素。 我的递归情况是当q和p不相等时。代码如下: int maximum(int[] A, int p, int q) {
if (p == q) {
return A[p];
}
int k, l, max1, max2, max3;
k = p + Math.floor((q-p+2)/3);
我试图为以下两个递归函数寻找复杂性,但不知道如何处理递归函数的复杂性分析。
查找所有可能的子集
def subsetsHelper(self, nums, index, path, res):
if path is None:
return
res.add(path)
for i in range(index, len(nums)):
self.subsetsHelper(nums, i + 1, path + [nums[i]], res)
def subsetsWithDup(self, nums):
res = []
我发现很难理解两个具体的实现,它们解决了代码强制上的这个问题。
我知道这和背包问题很相似。然而,当我自己解决它,我没有意识到算法。我从我自己对动态规划的理解中解决了这个问题。我的想法是把丝带的剩余长度看作下一个州。这是我的密码
#include<iostream>
using namespace std;
int main(){
int n,res1=0,res2,x=0;
int a,b,c;
cin >> n >> a >> b >> c;
for(int i=0;i <= n/
我正在学习如何解决棒材切割利润最大化的问题。但是当我写这段代码的时候,它并没有产生极端的结果。他给出的结果是20,但正确的结果是10。
这是代码:
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int _max(int a, int b) { if (a > b) return a; else return b; }
int cut_rod(int prices[], int size)
{
if (size == 0) return size;
我有以下几种方法来获得一棵红黑树的高度,这是可行的(我发送根)。现在我的问题是,这是如何运作的?我已经绘制了一棵树,并尝试对每个递归调用一步一步地执行,但我无法完成它。我知道代码是做什么的一般概念,这是经过所有的叶子和比较,但谁能给出一个明确的解释吗?
int RedBlackTree::heightHelper(Node * n) const{
if ( n == NULL ){
return -1;
}
else{
return max(heightHelper(n->left), hei
void doSomething(int *a, int left, int right){
if (left == right){
for (int j = 0; i < right; ++j)
cout << a[j];
cout << endl;
return;
}
for (int i = left; i < right; ++i){
std::swap(a[left], a[i]);
doSomething(a, left + 1, right);
我必须对河内塔问题进行迭代求解。我正在尝试将尾递归调用转换为迭代调用。我正在遵循我在教科书中找到的一种算法来转换它。我遵循了这个算法,尽管我的代码类似于递归变体,但我的输出与指定的表单不匹配。现在,根据这本书所告诉我的,使用迭代的递归调用是奇怪的,但有效的。
public class DemoIterative
{
public static void TowersOfHanoi(int numberOfDisks,
String startPole, String tempPole, String endPole)
{
while (numberOf
我对算法分析很陌生。我刚刚写了一个分而治之的算法,它应该在O(n)时间内从一个数组中找到一个最大数,并且我不得不形成它的递归。
以下是我的算法。
int findMax(int *A, int S, int E){
if(S == E){ //1 unit of time
return A[S];
}
else if(S == (E-1)){ // 1 unit of time
if(A[S] > A[E]){ // 1 unit of time
return A[S];
}
我试图理解用于fibonacci级数的递归机制。
#include<stdio.h>
int fib(int n);
int main()
{
int x, n;
scanf("%d", &n);
x = fib(n);
printf("fibonacci number %d = %d\n", n, x);
return 0;
}
int fib(int n)
{
if (n == 0)
{
return 0;
}
else if (n == 1)
我正在用Python编写一个动态规划算法,它似乎非常适合较小的输入,但对于大型输入却超时,这可能是因为递归调用。我在网上读到这个,它说大多数现代编程语言都不能很好地处理递归,将它们转换为迭代方法是一个更好的主意。
我的算法如下:
def get_val(x,y,g,i,xlast,ylast):
# checks if array over
if(i>(len(x)-1)):
return 0
# else returns the max of the two values
# dist returns the euclidian dist