どのように私はJavaでこれら二つの相互再帰関数を最適化するのでしょうか？

JD RUDIE：

私は、その合計値とこれらの複合相互再帰関数の出力のリストを提供しますが、その実行は私の現在の実装でタイムアウトに保つ方法を記述する必要があります。

public static long fAnn(long n) {
      if (n == 0) return 1;
      else return n - fJohn(fAnn(n-1));
    }

    public static long fJohn(long n) {
      if (n <= 0) return 0;
      else return n - fAnn(fJohn(n-1));
    }
public static List<Long> john(long n) {
    List<Long> res = new ArrayList<Long>();

    for (long i = 0; i < n; i++) {
      res.add(fJohn(i));
    }

    return res;       
}

public static long sumJohn(long n) {
    long sum = 0;
    for (long i = 0; i < n; i++) sum += fJohn(i);
    return sum;
}
public static long sumAnn(long n) {
    long sum = 0;
    for (long i = 0; i < n; i++) sum += fAnn(i);
    return sum;
}

私は、関数の関数バックの最後の値を渡すのではと思ったが、私は本当にわから私はそれを行うことができる方法はありませんよ。

JD RUDIE：

私は@Tim Beigeleisenのアドバイスを取って、私が代わりにここで最初の答えを探してのこの機能に取った素朴な再帰的なアプローチを改善するために、より動的なプログラミングについて学ぶことにしました。

ここに私が思い付いたコードは次のとおりです。

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;


public class Johnann {
    private static Map<Long, Long> jMem;
    private static Map<Long, Long> aMem;


    public static long fAnn(long n) {
      if (n < 2) {
        aMem = new HashMap<Long, Long>();
        aMem.put(n, (long)1);
        return 1;
      }
      else if (aMem.keySet().contains(n)) {
        return aMem.get(n);
      }
      else {
        long res = n - fJohn(fAnn(n-1));
        aMem.put(n, res);
        return res;
      }
    }


    public static long fJohn(long n) {
      if (n < 2) {
        jMem = new HashMap<Long, Long>();
        jMem.put(n, (long)0);
        return 0;
      }
      else if (jMem.keySet().contains(n)) {
        return jMem.get(n);
      }
      else {
        long res = n - fAnn(fJohn(n-1));
        jMem.put(n, res);
        return res;
      }
    }

    public static List<Long> john(long n) {
        List<Long> res = new ArrayList<Long>();

        for (long i = 0; i < n; i++) {
          res.add(fJohn(i));
        }

        return res;
    }

    public static List<Long> ann(long n) {
        System.out.println(n);
        List<Long> res = new ArrayList<Long>();

        for (long i = 0; i < n; i++) {
          res.add(fAnn(i));
        }

        return res;
    }


    public static long sumJohn(long n) {
        if (n == 0) return 0;
        else if (n < 2) return 1;
        long sum = 0;
        for (long i = 0; i < n; i++) sum += fJohn(i);
        return sum;
    }
    public static long sumAnn(long n) {
        if (n == 0) return 0;
        else if (n < 2) return 1;
        long sum = 0;
        for (long i = 0; i < n; i++) sum += fAnn(i);
        return sum;
    }
}

私は、例えば、代わりにマップのArrayListのを使用し、他の、より良い実装を見ました：

import java.util.*;

public class Johnann {

    private enum Person {JOHN, ANN}

    private static List<Long> getListForName(Person person, long n) {
        List<Long> ann = new ArrayList<>(Arrays.asList(1L));
        List<Long> john = new ArrayList<>(Arrays.asList(0L));

        for (int dayAnn = 1, dayJohn = 1; dayAnn < n || dayJohn < n; ) {
            if (john.size() > ann.get(dayAnn - 1)) {
                ann.add(dayAnn - john.get(Math.toIntExact(ann.get(dayAnn - 1))));
                dayAnn++;
            }
            if (ann.size() > john.get(dayJohn - 1)) {
                john.add(dayJohn - ann.get(Math.toIntExact(john.get(dayJohn - 1))));
                dayJohn++;
            }
        }
        return (person == Person.JOHN ? john : ann).subList(0, Math.toIntExact(n));
    }

    public static List<Long> john(long n) {
        return getListForName(Person.JOHN, n);
    }

    public static List<Long> ann(long n) {
        return getListForName(Person.ANN, n);
    }

    public static long sumJohn(long n) {
        return john(n).stream().mapToLong(Long::longValue).sum();
    }

    public static long sumAnn(long n) {
        return ann(n).stream().mapToLong(Long::longValue).sum();
    }
}

これは、道より速く、おそらくだったが、私は、動的プログラミングについて多くのことを学び、この問題によって再帰呼び出しを最適化することだけで幸せです。