Java 提高执行时间

如何提高以下程序的执行时间。 我在“递归”和“素数”函数中都使用了动态规划。 但是没有得到有效的执行时间

问题：受害者的房子里有一堵4xN大小的墙。受害者也有无限的权利 在她的房子里提供4x1和1x4尺寸的砖块。处处 配置时，必须使用砖块完全覆盖墙壁。Gale Bertram想知道砖块在墙上的排列方式总数，以便每次都出现新的配置。 让配置的数量=M

---

因此，他想让Patrick计算质数的个数（比如p）到M（也就是说，您在这里犯了两个主要错误（或者更确切地说，考虑到两个低效率）：

<>你正在重新初始化并重新计算每一个循环中的<代码> A/Eng>数组。那些不会改变，只是通过上次分配一个大小为40的数组来重用上次的结果（你也可能想考虑更好的命名约定……）

您不是在任务的“主要”部分使用动态规划。动态规划是关于保存中间结果以备将来使用，您保存的只是答案，希望它再次被使用（不再使用它，因为

n

对于唯一的

n

-再次命名约定将是唯一的）

---

第1部分不太可能增加太多时间，因为计算很简单，而且N您可能希望进一步优化

int prime（int N）

函数。（当然，您可以使用“net”中的任何有效算法，但是：）为了避免反复进行相同的计算，请注意，您可以计算

prime（N+m）

如果您已经有了

prime（n）

，速度会更快

（我认为您已经朝这个方向思考了，因为您正在对已经计算的数字使用一些“缓存”。）

编辑： 见奥杜斯的答案#2:）

编辑2：

要详细说明该想法，请执行以下操作：

---

问：如果我知道素数

c

的数量

您是否尝试过使用cpu探查器或任何其他减少cpu时间的技术？因为您目前有正在工作的代码，并且您希望尝试并改进它，您可能会更幸运。鉴于您已经有
a
的重复关系，您可以运行另一个程序我要生成
a
的条目，并用它代替递归函数。你甚至可以在同一个程序中创建一个筛，但筛无论如何都很快。@Ben，你能给出关于“筛”的更多细节吗我将素数值存储在全局数组b中，并对其进行检索以避免重复计算。请您提供一些有关优化过程的详细信息。正如Ordous所说：您已经在“缓存”，例如，
prime（1000）的结果
，但下次需要计算素数（1001）时，您不会使用此结果，尽管您可以这样做。我做了一些更正，但仍然没有得到。请检查代码。公共静态整型素数（int n）{int count=0；如果（b[n]！=0）返回b[n]；否则{for（int i=2；i@Torrtuga请不要在评论中发布代码，读起来很可怕……但是，是的，看起来好多了。你仍然有几个错误：将
b[i]=count
从条件中去掉，否则你将重新计算素数的结果，同时循环到
sqrt（i）
，而不是
i/2
。此外，习惯上使用
布尔值作为标志，而不是
int
谢谢。在要求的时间内获得了输出。sqrt（i）确实起到了作用。非常感谢！！
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
class Solution{
    public static int[] b = new int[217287];
    public static void main(String[] args){
        Scanner stdin = new Scanner(System.in);
    int t = stdin.nextInt();
    int[] a = new int[41];
    for(int j=0;j<4;j++){
            a[j] = 1;          //till n<=3, number of possiblities = 1. These will work as base cases.
        }
        a[4] = 2;
    for(int x=0;x<t;x++){
        int n = stdin.nextInt();
        for(int i=5;i<=n;i++){
            a[i] = -1;         //initialise all value in the array as -1.
        }
        if(n<4)
            System.out.println("0"); // if n<4, number of possibilities =1. So no prime number before that is 0.
        else{
                     //for n=4, possibilities = 2. This is a base case.
        int num1 = recursive(a,n);          // storing number of possibilities in num1.
        int num2 = prime(num1);    //calling to calculate number of prime numbers before or equal to num1.
        System.out.println(num2);
        }
    }
}
public static int recursive(int[] a, int n){
    if(a[n]!=-1)                             // retrieving a[n] value if already calculated.
        return a[n];
    else{
        a[n] = recursive(a,n-1) + recursive(a,n-4); // calling recursively.If we fill with a 4*1 first tile then number 
                                                    //tiles left is n-1(try visualising).If we fill 1*4 tile first
                                                    // we have n-4 tile left.
        return a[n];
    }
}
public static int prime(int n){
    int count = 0;
    if(b[n]!=0)
        return b[n];
    else{
    for(int i=2;i<=n;i++){
        if(b[i]!=0){
            count = b[i];
        }
        else{
        int flag = 0;           
        for(int j=2;j<=i/2;j++){
            if(i%j==0){
                flag = 1;
                break;
                }
            }
    if(flag==0){
        count++;
        b[i]=count;
    }
    }
    }
    return count;
    }
}

public static int prime2( final int n ) {
    int count;
    if ( n <= 2 ) {
        count = 1;
    } else {
        count = prime2(n-1);
        if ( isPrime(n) ) {
            count = count + 1;
        }
    }
    return count;
}