（1，1）最少几次运算可以出现n

[zprimy]

运算规则为：（a,b）可以变为（a,a+b）和（a+b,a）
举例：
（1，1）出现5需要3次
-->(1,2)
-->(3,2)
-->(5,2)

测试用例：
（1，1）出现50需要8次
（1，1）出现6需要5次
（1，1）出现3435需要18次

[qjkobe]

复杂度偏高。不过木的办法。还没想好更好的解决方法，可以先试着优化一下。

static int appearNumber2(int num) {
        //动态规划
        //dp[i]表示到达i这个数字需要的最小次数,j表示两个加数。这是完成后括号另一个数字的可能值。
        //dp2[i]表示到达i这个数字以后，括号里另一个数字的可能值。
        //dp3[i]同上
        //if(i+dp2[i]或者dp3[i] == num) (temp)dp[num] = dp[i][j]+1
        //满足上面条件，次数最小的就是dp[num][][]。
        //思路不正确。因为前面的最小，可能会加不到最后的结果。所以不能保存最小次数。有时候要大次数。
        //保存每个的可能次数，和对应的括号另一个数字可能的值。
        //dp[i][j]表示i这个数字需要的次数。总共j个。

        int[][] dp = new int[num + 1][num + 1];
        int[][] dp2 = new int[num + 1][num + 1];
        int[][] dp3 = new int[num + 1][num + 1];



        dp[1][0] = 0;
        dp2[1][0] = 1;
        dp3[1][0] = 1;
        dp[2][0] = 1;
        dp2[2][0] = 1;
        dp3[2][0] = 1;

        for (int i = 3; i <= num; i++) {
            int tempMin = Integer.MAX_VALUE;
            int j = 0;
            for (int x = 1; x < i; x++) {
                for(int k = 0;dp2[x][k]!=0;k++) {
                    if (x + dp2[x][k] == i) {
                        dp[i][j] = dp[x][k] + 1;
                        dp2[i][j] = dp2[x][k];
                        dp3[i][j] = x;
                        j += 1;
                    } else if (x + dp3[x][k] == i) {
                        dp[i][j] = dp[x][k] + 1;
                        dp2[i][j] = dp3[x][k];
                        dp3[i][j] = x;
                        j += 1;
                    }
                }
            }

        }
        //最后dp[num]最小值。
        int min = Integer.MAX_VALUE;
        for(int j = 0;j<dp[num].length;j++) {
            if (dp[num][j] == 0) {
                continue;
            } else {
                if (dp[num][j] < min) {
                    min = dp[num][j];
                }
            }
        }
        return min;
    }