剑指offer13. 机器人的运动范围、14剪绳子

机器人的运动范围

机器人的运动范围

就是递归（回溯）

参考: 这篇博文里面的回溯讲解

package swordPointingToTheOffer;

public class Thirteen {
    int m,n,k;
    boolean[][]visited;

    public int movingCount(int m,int n,int k){
        this.m = m;
        this.n = n;
        this.k = k;    //不能进入行坐标和列坐标的数位之和大于k的格子
        this.visited = new boolean[m][n];
        return dfs(0,0);
    }

    /**
     *              是否在方格内 或者 是否是障碍物 或者 是否访问过
     * @param i 当前位置的横坐标
     * @param j 当前位置的纵坐标
     * @return
     */
    public int dfs(int i,int j){
        if(i>=m||i<0||j>=n||j<0||k<sums(i)+sums(j)||visited[i][j]){
            return 0;
        }
        //访问当前的坐标
        visited[i][j] = true;
        //回溯（递归）      下          右             上               左
        return 1 + dfs(i+1,j)+dfs(i,j+1)+dfs(i-1,j)+dfs(i,j-1);
    }

    //求出数字的每个位置的和
    int sums(int x){
        int s = 0;
        while (x!=0){
            s = s+ x%10;
            x = x/10;
        }
        return s;
    }

    public static void main(String[] args) {
        Thirteen thirteen = new Thirteen();
        System.out.println(thirteen.movingCount(2,3,1));
    }
}

剪绳子1

剪绳子1

贪婪算法

package swordPointingToTheOffer;

public class Fourteen {

    public int cuttingRope(int n) {
        if(n<=2){
            return 1;
        }
        if(n==3){
            return 2;
        }

        int res = n/3;
        int mod = n%3;

        if(mod ==0){
            return power(3,res);
        }else if(mod==1){
            return power(3,res-1)*4;
        }else {
            return power(3,res)*2;
        }

    }
    public int power(int a,int b){
        int total =1;
        for (int i =0;i<b;i++){
            total = total*a;
        }
        return total;
    }

    public static void main(String[] args) {
        Fourteen fourteen = new Fourteen();
        System.out.println(fourteen.cuttingRope(10));
    }
}

由不等式思想知道，俩个数字相近，乘积越大

长度1，切不了（不能切为1）
长度2，不切
长度3，不切
长度4，不切
长度5，切（2+3）
长度6，切。。。。。

最小单位就是（2，3，4）

由上面公式知道24<33

所以2和4不能同时存在

剪绳子

剪绳子2

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
考察多个数相乘的取余运算

把公式带入到本问题中有：

代码实现连续乘法取模如下：

    // 求a^n % p
    //从最下面开始向上面运算
    long pow(int a,int n){
        long res =1;
        int p = 1000000007;
        for (int i= 1;i<=n;i++){
            res = (res*a)%p;
        }
        return res;
    }

package swordPointingToTheOffer;

public class Fourteen2 {

    int p =1000000007;
    public int cuttingRope(int n) {
        if(n<=2){
            return 1;
        }
        if(n==3){
            return 2;
        }

        int res = n/3;
        int mod = n%3;

        if(mod ==0){
            return (int)pow(3,res);
        }else if(mod==1){
            //这里再次取模是因为pow(3,res-1)的值乘以了4.。。
            return (int)(pow(3,res-1)*4%p);
        }else {
            //这里再次取模是因为pow(3,res)的值乘以了2.。。
            return (int)(pow(3,res)*2%p);
        }

    }
//    //求a的b次方（a^b）
//    public int power(int a,int b){
//        int total =1;
//        for (int i =0;i<b;i++){
//            total = total*a;
//        }
//        return total;
//    }
    // 求a^n % p
    //从最下面开始向上面运算
    long pow(int a,int n){
        long res =1;
        int p = 1000000007;
        for (int i= 1;i<=n;i++){
            res = (res*a)%p;
        }
        return res;
    }

    public static void main(String[] args) {
        Fourteen2 fourteen2 = new Fourteen2();
        System.out.println(fourteen2.cuttingRope(127));
    }
}

注意：

else if(mod==1){
            //这里再次取模是因为pow(3,res-1)的值乘以了4.。。
            return (int)(pow(3,res-1)*4%p);
        }else {
            //这里再次取模是因为pow(3,res)的值乘以了2.。。
            return (int)(pow(3,res)*2%p);
        }