尝试编写迭代算法但无法使其工作

看起来你必须在 3 之前保留 n 值，所以通常你必须在 n 之前保留所有序列。为此，最好将其封装在单独的类中。

public final class SequenceMaker {

    private final Map<Long,Long> cache = new HashMap<>();
    private long max = 2;

    {
        for (long n = 0; n <= 2; n++)
            cache.put(n,n);
    }

    public long calculate(long n) {
        if (n > max) {
            for (long i = max + 1; i <= n; i++)
                cache.put(i,cache.get(i - 1) + cache.get(i - 3));

            max = n;
        }
        
        return cache.get(n);
    }
}

客户端代码可能如下所示：

public static void main(String... args) {
    SequenceMaker sequenceMaker = new SequenceMaker();

    for (int i = 0; i < 14; i++) {
        System.out.print(sequenceMaker.calculate(i));
        System.out.print(" ");
    }
}

输出： 0 1 2 2 3 5 7 10 15 22 32 47 69 101

P.S. 如果你不担心性能，那么你可以避免使用缓存。

public final class SequenceMaker {

    public long calculate(long n) {
        long[] cache = new long[4];

        for (long i = 0; i <= n; i++) {
            cache[0] = i <= 2 ? i : cache[1] + cache[3];
            cache[1] = cache[2];
            cache[2] = cache[3];
            cache[3] = cache[0];
        }

        return cache[3];
    }
}

或者使用Deque：

public final class SequenceMaker {

    public long calculate(long n) {
        Deque<Long> queue = new ArrayDeque<>(3);

        for (long i = 0; i <= n; i++)
            queue.addFirst(queue.size() < 3 ? i
                                            : queue.removeLast() + queue.getFirst());

        return queue.element();
    }
}

第一个问题是您没有对 (n - 1) 和 (n - 3) 进行递归调用。以下代码解决了该问题：

public long calculate(long n) {
    if (n <= 2) {
        return n;
    } else {
        return calculate(n - 1) + calculate(n - 3);
    }
}

您在此处描述的问题与 Fibonacci Number 非常相似。 Here 您将获得一篇关于如何使用递归和迭代方式计算 Fibonacci Number 的文章。这是您问题的相应迭代算法：

public class Calculate{
    
    public static long calculate(long n) {
        if(n < 3) return n;
        
        int [] cache = new int [3];
        int tmp;
        cache[0] = 0;
        cache[1] = 1;
        cache[2] = 2;
        
        for(int i=3; i<=n; i+=1) {
            tmp = cache[2] + cache[0];
            cache[0] = cache[1];
            cache[1] = cache[2];
            cache[2] = tmp;
        }
        return cache[2];
    }

     public static void main(String []args){
        for(int i=0; i<20; i+=1) {
            System.out.print(" " + calculate(i));
        }
        System.out.println("");
     }
}

样本输出：

 0 1 2 2 3 5 7 10 15 22 32 47 69 101 148 217 318 466 683 1001

在这里你可以看到，我只缓存了这个系列的最后三个元素。这是因为要计算这个系列的n-th条目，我们只需要这个系列的(n-1)-th和(n-3)-th条目。因此，此解决方案中的 cache 数组充当滑动窗口。如果内存不是问题，您可以保留一个大小为 (n+1) 的数组。

诀窍是认识到总和是 nth 和 nth+2nd 元素的总和。所以你可以这样做而无需递归。但是您需要跟踪两个较早的元素才能做到这一点。

int a = -1;
int b = -0;
int c = 1;
for (int i = 0; i < 14; i++) {
    int v = fnc(a,c);
    a = b;
    b = c;
    c = v;
    System.out.println(v + " ");
}

印刷品

0 1 2 2 3 5 7 10 15 22 32 47 69 101 

只添加适当元素的方法

public static int fnc(int a,int c) {
    if (c < 2) {
        return a + 1;
    }
    return a + c;
}

实际上，您根本不需要方法，只需使用 a、b 和 c 的早期值就可以这样做。

for (int i = 0; i < 14; i++) {
    int v = a + c;
    if (c < 2) {
        v = a + 1;
    }
    
    a = b;
    b = c;
    c = v;
    
    System.out.print(v + " ");
}