【算法】由递归推出动态规划

最新推荐文章于 2024-07-22 15:00:08 发布

萧弈X

最新推荐文章于 2024-07-22 15:00:08 发布

阅读量119

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/qq_43619628/article/details/116093304

版权

算法专栏收录该内容

6 篇文章 0 订阅

订阅专栏

象棋中的马从（0,0）位置跳到（x,y）位置，跳k步，有多少跳的方法？

递归方法：
结束条件，k=0时，结束，如果x=0，y=0;则是一种方法。
边界：x<0||x>9||y<0||y>8
递归：从最后（x，y）点看，有8个点可以一步跳到（x，y）点

代码：

  public static int ways1(int x,int y,int k){
      return f(x,y,k);
    }
    public static int f(int x,int y,int k){
        if (k==0){
            return x==0&&y==0?1:0;
        }
        if (x<0||x>9||y<0||y>8){
            return 0;
        }
        //8个点，8种情况
        return f(x+2,y-1,k-1)+f(x+2, y+1, k-1)+
                f(x-2, y+1, k-1)+f(x-2, y-1, k-1) +
                f(x-1, y-2, k-1) + f(x-1, y+1,k-1)+
                f(x+1, y+2, k-1) + f(x+1, y-2,k-1);
    }

递归转动态规划

    public static int ways2(int x,int y,int k){
        int[][][] dp = new int[10][9][k+1];
        dp[0][0][0]=1;
        for (int level = 1; level <= k; level++) {
            for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 9; j++) {
                    dp[i][j][level]=  getValue(dp,i+2,j-1,level-1)+getValue(dp,i+2, j+1, level-1)+
                            getValue(dp,i-2, j+1, level-1)+getValue(dp,i-2, j-1, level-1) +
                            getValue(dp,i-1, j-2, level-1) + getValue(dp,i-1, j+1,level-1)+
                            getValue(dp,i+1, j+2, level-1) + getValue(dp,i+1, j-2,level-1);

                }
            }
        }
        return dp[x][y][k];
    }
public static int getValue(int[][][] dp,int x,int y,int k){
    if (k==0){
        return x==0&&y==0?1:0;
    }
    if (x<0||x>9||y<0||y>8){
        return 0;
    }
    return dp[x][y][k];
}

斐波拉契数列

1,1,2,3,5,8…

|F(n),F(n-1)|=|f(2),f(1))| * |1,1  |^(n-2)
                             | 1,0 |

为了更快求出结果，我们就要更快的求出矩阵的n次方的解。

知识点：如何快速球整数的n次方的解。
如10^75
第一步，将n化为2进制数 ,75=1001011;
第二步，结果res=1，t=10,遍历2进制数，有1结果res就乘t ，t每次和自己乘t*=t       
即res=1*t*（t*t ）*（t*t*t*t）......
复杂度：log（n）

矩阵类似，res初始为单位矩阵，t=|a|;
代码

    public static int f3(int n){
        if (n < 1){
            return 0;
        }
        if (n==1||n==2){
            return 1;
        }
        int[][] base={
                {1,1},
                {1,0}
        };
        int[][]res=matrixPower(base,n-2);
        return res[0][0]+res[1][0];
    }

    private static int[][] matrixPower(int[][] m, int p) {
        int[][] res = new int[m.length][m[0].length];
        //单位矩阵
        for (int i = 0; i < res.length; i++) {
            res[i][i] = 1;
        }
        //t
        int[][] tmp=m;
//        遍历2进制数
        for (;p!=0;p>>=1){
            //如果最后1位是1，res矩阵乘t
            if ((p&1)!=0){
                res=muliMatrix(res,tmp);
            }
//            t自乘
            tmp=muliMatrix(tmp,tmp);
        }
        return res;
    }
    //两个矩阵乘完后返回
    private static int[][] muliMatrix(int[][] m1, int[][] m2) {
        int[][] res = new int[m1.length][m2[0].length];
        for (int i = 0; i < m1.length; i++) {
            for (int j = 0; j < m2[0].length; j++) {
                for (int k = 0; k < m2.length; k++) {
                    res[i][j] += m1[i][k]+m2[k][j];
                }
            }
        }
        return res;
    }

类似问题
奶牛问题，每只奶牛每年产一只小牛，小牛三年后可以产牛（即第二年出生的牛，在第五年也会产一只牛。），牛不会死，求n年后牛的数量。
F(n)=f(n-1)+f(n-3)

爬楼梯问题，一个一次可以爬一个台阶或两个台阶，求爬到第n个台阶有多少种方法。
f(N）=f(n-1)+f(n-2);

蓄水池算法

入袋问题，有一个流，每次按顺序出来一个数，你可以选择不要这个数，或将这个数放入袋子中，有一个袋子可以装10个数，怎样让每个数字进入袋子的概率相等。
思路：前10个数都装入袋子，之后第n个数，随机产生（1，n）的随机数，如果等于n，就入袋，随机丢掉袋子中的一个数。
概率：前10个数中i 最终存在的概率：1*（1-1/11）(1-1/12)…(1-1/k)=10/k
10后面的数 j 最终存在的概率：（1-1/j）(1-1/j+1)…(1-1/k)=10/k

实际用处：在今天登陆的全球玩家中找出100名送皮肤。
思路：每次用户登录，判断是否是今天第一次登录，，是则判断是全球第几登录的用户，并执行随机入袋方法。