Java 装配线调度递归解决方案错误

基本上，我是以递归的方式解决装配线调度问题，基于提供的公式

可以从问题陈述中提取以下信息以使其更简单：

两条装配线，1和2，每个装配线的工位从1到n

汽车底盘必须按顺序（在两条装配线中的任何一条）通过从1到n的所有工位。i、 e.如果站i与站j不在同一移动距离，则不能从站i跳到站j

汽车底盘可以在同一条线上向前移动一个工位，或在另一条线上对角移动一个工位。从i号线移动到j站需要额外的成本ti，j。同一生产线内的移动不产生任何费用

i线j站所用时间为ai，j

Si，j表示i线上的站j

将问题分解为更小的子问题： 如果已知第（i-1）个阶乘，我们可以很容易地找到第i个阶乘。我们可以在这里申请类似的基金吗？ 如果已知底盘离开站Si，j-1的最短时间，则可以通过组合ai，j和ti，j快速计算离开站Si，j的最短时间

T1（j）表示汽车底盘离开装配线1上的j站所需的最短时间

T2（j）表示汽车底盘离开装配线2上的站j所需的最短时间

基本情况： 只有当汽车底盘进入汽车工厂时，进入时间ei才会进入画面

离开1号线第一站所需时间如下： T1（1）=1号线的进入时间+在S1,1站花费的时间 T1（1）=e1+a1,1 同样，从2号线第一站出发所需的时间如下所示： T2（1）=e2+a2,1

递归关系： 如果我们看一下问题陈述，它很快就归结为以下观察结果： 站S1、j处的汽车底盘可以来自站S1、j-1或站S2、j-1

案例#1：其前一站为S1，j-1 离开车站S1，j的最短时间由下式给出： T1（j）=离开S1站的最短时间，j-1+在S1站的时间，j T1（j）=T1（j-1）+a1，j

案例2：其上一站为S2，j-1 离开车站S1，j的最短时间由下式给出： T1（j）=离开站点S2，j-1所需的最短时间+变更装配线所产生的额外成本+在站点S1，j所花费的时间 T1（j）=T2（j-1）+T2，j+a1，j

最小时间T1（j）由情况#1和#2中获得的两个最小值给出。 T1（j）=min（（T1（j-1）+a1，j），（T2（j-1）+T2，j+a1，j）） 同样，到达站点S2的最短时间j由下式给出： T2（j）=min（（T2（j-1）+a2，j），（T1（j-1）+T1，j+a2，j））

汽车底盘出厂所需的最短总时间如下所示： Tmin=min（离开车站Si所用的时间，n+离开汽车厂所用的时间） Tmin=min（T1（n）+x1，T2（n）+x2）

动态编程版本很好，但是，在我的递归版本中有一些隐藏的错误，有人能帮我找出错误吗？ 谢谢

DP包；
公共类AssemblyLineScheduling{
公共静态void main（字符串[]args）{
int[]a={{4,5,3,2}，
{2, 10, 1, 4}};
int[]t={{0,7,4,5}，
{0, 9, 2, 8}};
int[]e={10,12}；
int[]x={18,7}；
系统输出println（carAssemblyDP（a，t，e，x））；
系统输出println（carAssembly（a，t，e，x））；
}
公共静态int-carAssembly（int[]a，int[]t，int[]e，int[]x）{
int n=a[0]。长度为-1；
返回Math.min（carAssemblyRec（a，t，e，x，n，0）+x[0]，
carAssemblyRec（a，t，e，x，n，1）+x[1]）；
}
公共静态int-carAssemblyRec（int[]a，int[]t，int[]e，int[]x，int-n，int-line）{
如果（n==0）{
返回e[line]+a[line][0]；
}
int T0=Math.min（carAssemblyRec（a，t，e，x，n-1，0）+a[0][n]
，carAssemblyRec（a，t，e，x，n-1，1）+t[1][n]+a[0][n]）；
int T1=Math.min（carAssemblyRec（a，t，e，x，n-1，1）+a[1][n]
，carAssemblyRec（a，t，e，x，n-1，0）+t[0][n]+a[1][n]）；
返回数学最小值（T0，T1）；
}
公共静态int-carAssemblyDP（int[]a，int[]t，int[]e，int[]x）{
int n=a[0]。长度；
int[]T1=新的int[n]；
int[]T2=新的int[n]；
T1[0]=e[0]+a[0][0]；
T2[0]=e[1]+a[1][0]；
对于（inti=1；i我将回答我的问题

public static int carAssemblyRec(int[][] a, int[][] t, int[] e, int[] x, int n, int line){  
    if(n == 0){  
        return e[line] + a[line][0];  
    }  

    int T0 = Integer.MAX_VALUE;  
    int T1 = Integer.MAX_VALUE;  
    if(line == 0){      
        T0 = Math.min(carAssemblyRec(a, t, e, x, n-1, 0) + a[0][n],             
                            carAssemblyRec(a, t, e, x, n-1, 1) + t[1][n] + a[0][n]);    
    }else if(line == 1){       
        T1 = Math.min(carAssemblyRec(a, t, e, x, n-1, 1) + a[1][n],             
                             carAssemblyRec(a, t, e, x, n-1, 0) + t[0][n] + a[1][n]);   
    }  

    return Math.min(T0, T1);  
} 

调试？另外，不要强迫我们点击你的链接-在问题本身中加入理解问题所必需的内容。
public static int carAssemblyRec(int[][] a, int[][] t, int[] e, int[] x, int n, int line){  
    if(n == 0){  
        return e[line] + a[line][0];  
    }  

    int T0 = Integer.MAX_VALUE;  
    int T1 = Integer.MAX_VALUE;  
    if(line == 0){      
        T0 = Math.min(carAssemblyRec(a, t, e, x, n-1, 0) + a[0][n],             
                            carAssemblyRec(a, t, e, x, n-1, 1) + t[1][n] + a[0][n]);    
    }else if(line == 1){       
        T1 = Math.min(carAssemblyRec(a, t, e, x, n-1, 1) + a[1][n],             
                             carAssemblyRec(a, t, e, x, n-1, 0) + t[0][n] + a[1][n]);   
    }  

    return Math.min(T0, T1);  
}