Java 如何提高树木特定叶片数的计算速度

在给定的约束条件下，我无法解决编程任务

条件：

你有N块砖

根据以下约束条件，计算使用这些砖可以建造多少楼梯：

每个楼梯都应该使用所有给定的砖建造

不允许有两个相同高度的台阶

楼梯至少应有两级台阶

最多可提供250块砖

示例：

给定3块砖，您可以建造1个楼梯：

step 1 - height 1
step 2 - height 2

step 1 - height 1
step 2 - height 3

给定4块砖，您还可以建造1个楼梯：

step 1 - height 1
step 2 - height 2

step 1 - height 1
step 2 - height 3

给定5块砖，您可以建造2个楼梯：

step 1 - height 2            step 1 - height 1
step 2 - height 3            step 2 - height 4

解决方案的实现应如下所示（我使用的是Java）：

自动分级器有几个技术限制，例如线程是不允许的，很多Java类是有限的等等

我尝试使用树状结构来解决这个问题，其中每个节点保存有关剩余砖块数量和当前台阶高度的信息，每个边表示台阶的建筑高度

例如，以下结构表示台阶高度为（1,2,4）（1,6）（2,5）（3,4）的楼梯

我尝试了几种方法：

建筑楼梯自下而上（从最低台阶到最高台阶）和自上而下（从最高台阶到最低台阶）

使用深度优先和广度优先搜索

使用递归或迭代

因此，我有几个通过单元测试的工作解决方案（正确解决所有示例问题）。不幸的是，我无法获得最高分数，因为自动评分器告诉我，我的解决方案落后于允许的时间限制，因此存在一些更为优化的方法。 我想关键是通过在当前节点的基础上计算楼梯的可能数量来限制沿分支的遍历。不幸的是，我没有足够的知识进行以下改进，并将感谢任何帮助。 以下是我的解决方案之一：

import org.testng.Assert;

public class Task0302 {

static int numberOfStairCases = 0;

public static int answer(int n) {   
  numberOfStairCases = 0;
  run(n, n - 1);
  return numberOfStairCases;
}

static void run(final int hasBricks, final int maximalAllowedHeight) {
  if (hasBricks > bricksAllowed(maximalAllowedHeight))
    return;
  if (hasBricks == bricksAllowed(maximalAllowedHeight)) {
    numberOfStairCases++;
    return;
}

int currentStepHeight = Math.min(hasBricks, maximalAllowedHeight);
final int minHeight = minPossibleHeight(hasBricks);
 do {    
   run(hasBricks - currentStepHeight, currentStepHeight - 1);
   currentStepHeight--;
 } while (currentStepHeight >= minHeight);
}

static int minPossibleHeight(int havingBricks) {
  return (int) ((Math.sqrt(8 * havingBricks + 1) - 1) / 2);
}

static int bricksAllowed(int currentHeight) {
  return (currentHeight + 1) * currentHeight / 2;
}

public static void main(String[] args) {
 Assert.assertEquals(answer(3), 1);
 Assert.assertEquals(answer(4), 1);
 Assert.assertEquals(answer(5), 2);
 Assert.assertEquals(answer(200), 487067745);
 System.out.println("Passed");
 }
}

---

对不起，这里很乱，因为我大部分时间是在晚上学习，整天工作。Python2也可以使用，但我对它不是很专业。

你的问题相当于用唯一的正整数计算N的求和方法的数量，忽略顺序。这里有一个参考：

在上面的链接中使用生成函数的一个O（n^2）算法是计算多项式乘积：乘积（（1+x^k）表示k=1..n），然后查看x^n的系数

这听起来很难，但它的代码相对简单（这里是伪代码）：

您可以将其视为动态规划解决方案。在k循环的n个步骤之后，每个A[i]将存储使用整数1到n求和到i的不同方式的数目。或者等价地，在k个循环的N个步骤之后，可以考虑数组A来表示多项式A〔0〕+A〔1〕X+A〔2〕X^ 2＋…+。A[N]x^N，等于乘积（k=1..N时为1+x^k）

---

（实际上，这个解决方案包括一个台阶大小为N的“楼梯”——因此，除了这个特殊情况，你必须减去1才能得到结果）。

给你一些阅读：非常感谢，它已经被接受了，现在我有时间阅读这个理论。