如何在动态编程中链接数组中的元素(java)

时间:2016-07-19 05:42:40

标签: java arrays algorithm

我有一个动态算法问题,我几乎解决了它。问题是我有一个原始计算器,它只能执行加1,乘2和乘3的操作。我必须找到达到任何数所需的最小步数。我已经正确地实现了问题,但我还必须输出导致n的数字数组。这意味着,例如,对于n = 5,步骤是1,2,4,5并且我必须输出3,因为它花了3个步骤。我的算法用于查找最少量的步骤,但我无法找到该数组。我认为从最终开始的分而治之算法可能有效,但我并不善于分而治之。这是我的代码。它输出整个数组(所有元素,而不是通向n的元素)。

public static int min(int a, int b){if(a>b){return b;}else{return a;}}
public static int min(int a, int b, int c){return min(min(a, b), c);}
public static int[] primitiveCalc(int n){
    int[] solution=new int[n];
    solution[0]=0;
    solution[1]=0;
    for(int i=2;i<n;i++){
        if(i%3==0){
            if(i%2==0){solution[i]=min(solution[i-1]+1, solution[i/3]+1, solution[i/2]+1);}
            else{solution[i]=min(solution[i-1]+1, solution[i/3]+1);}
        }else if(i%2==0){solution[i]=min(solution[i-1]+1, solution[i/2]+1);}
        else{solution[i]=solution[i-1]+1;}
    }
    System.out.println(solution[n-1]);
    return solution;
}
public static void main(String[] args){
    Scanner in=new Scanner(System.in);
    int n=in.nextInt();
    int[] solution=primitiveCalc(n+1);
    for(int i=1;i<solution.length;i++){
        System.out.print(solution[i]+" ");
    }
}

任何帮助表示赞赏。

我得到了解决方案,如果有人有兴趣,这是实施:

public static int[] findChainArray(int[] array, int n){
    int[] chainedArr=new int[array.length];
    for(int i=array.length-1, j=0;i>0;j++){
        if(i%3==0) {
            if (i % 2 == 0) {
                if (min(array[i - 1], array[i / 2], array[i / 3]) == array[i - 1]) {
                    i = i - 1;
                } else if (min(array[i - 1], array[i / 2], array[i / 3]) == array[i / 2]) {
                    i = i / 2;
                } else {
                    i = i / 3;
                }
            }else{
                if (min(array[i - 1], array[i / 3]) == array[i - 1]) {
                    i = i - 1;
                } else {
                    i = i / 3;
                }
            }
        }else if(i%2==0){
            if (min(array[i - 1], array[i / 2]) == array[i - 1]) {
                i = i - 1;
            } else if (min(array[i - 1], array[i / 2]) == array[i / 2]) {
                i = i / 2;
            }
        }else{
            i=i-1;
        }
        chainedArr[j]=i;
    }
    return chainedArr;
}

我知道如果有别的话会有太多的东西而且我试图减少那个

1 个答案:

答案 0 :(得分:0)

现在你有了一个有效的路径,你可以尝试倒退。

您可以从answer = solution[n]递归地工作,并查看是否solution[n-1] = answer-1solution[n/2] = answer-1solution[n/3] = answer-1。当然,您需要进行正确的检查,看看n是否可以被23整除,就像您已经做过的那样。

或者,您可以创建一个名为last的数组,而不是仅保存i中每个solution的最小值,您也可以保存last中路径中的最后一个元素。 {1}}。

由于这似乎是一个家庭作业问题或您自己试图解决的问题,我将把实施细节留给您:)