剑指offer----JavaScript

按照考点进行分类整理

动态规划与贪婪

1.给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]xk[1]x...xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

输入描述：

输入一个数n，意义见题面。（2 <= n <= 60）

输出描述：

输出答案。

题解：

function cutRope(number){
    //递归法
    if(number < 2){
        return 0;
    }else if(number == 2){
        return 1;
    }else if(number == 3){
        return 2;
    }
    return cutRopeS(number);
    var cutRopeS = function (number){
    if(number <= 4){return number}
    let max = 0;
    for(let i = 1; i < number / 2 + 1; i++){
        max = Math.max(cutRopeS(i)*cutRopeS(number - i), max);
    }
    return max;
}

function cutRope(number)
{
//用数组记录代替递归
    if(number < 2){
        return 0;
    }else if(number == 2){
        return 1;
    }else if(number == 3){
        return 2;
    }
    let products = [];
    products[0] = 0;
    products[1] = 1;
    products[2] = 2;
    products[3] = 3;
    
    for(let i = 4; i < number + 1; i++){
        let _max = 0;
        for(let j = 1; j < i / 2 + 1; j++){
            _max = Math.max(products[j] * products[i - j], _max);
        }
        products[i] = _max;
    }
    return products[number];
}

function cutRope(number){
    //number=2，1； 3，2； 4，4；5：6
    if(number == 2){
        return 1;
    } else if (number == 3) {
        return 2;
    }

    //分解因子为3时积最大
    let div = Math.floor(number / 3);
    let remain = number % 3;
    //需要判断余数的情况
    if (remain == 0){
        return Math.pow(3, div);
    } else if (remain == 1) {
        return Math.pow(3, div - 1) * 4;
    } else if (remain == 2) {
        return Math.pow(3, div) * 2;
    }
}

回溯法

1.请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e[4*3] 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

题解：

function hasPath(matrix, rows, cols, path)
{
    // write code here
    // 回溯法
    var visited = [];
    for(var i = 0; i < rows * cols; i++){
        visited[i] = false;
    }
    let pathLen = 0;
    for(var i = 0; i < rows; i++){
        for(var j = 0; j < cols; j++){
            if(core(i,j)){
                return true;
            }
        }
    }
    return false;
    function core(i, j){
        if(path.length === pathLen){
            return true;
        }
        var hasPath = false;
        if(i >= 0 && i < rows && j >= 0 && j < cols && matrix[i * cols + j] === path[pathLen] && !visited[i * cols + j]){
            pathLen++;
            visited[i * cols + j] = true;
            hasPath = core(i - 1, j)+ core(i, j - 1)
                    + core(i + 1, j) + core(i, j + 1);
            if(!hasPath){
                pathLen--;
                visited[i * cols + j] = false;
            }
        }
        return hasPath;
    }
}

2. 地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

输入： threshold, rows, cols

输出：可到达的格子数

题解：

function movingCount(threshold, rows, cols){
    let visited = new Array(rows*cols).fill(false);
    let count = getres(0,0);
    return count;

    function getres(i,j){
        let res = 0;
        if(check(i,j)){
            visited[i*cols+j] = true;
            res++;
            res += getres(i-1,j) + getres(i+1, j) + getres(i, j-1) + getres(i, j+1);
        }
        return res;
    }   
    function check(i, j){
        if(i>=0 && i<cols && j>=0 && j<rows && !visited[i*cols+j] && getsum(i)+getsum(j) <= threshold){
            return true;
        }
        return false;
    }
    function getsum(i){
        let sum = 0;
        while(i > 0){
            sum += i % 10;
            i = Math.floor(i/10);
        }
        return sum;
    }
}

综合

1.将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0

输入描述：输入一个字符串，包括数字字母符号，可以为空

输出描述：如果是合法的数值表达则返回该数字，否则返回0

题解：

function strToInt(str){
    if(str.length === 0){
        return 0;
    }

    var format = str.match(/^(\+?|-?)(\d+)$/);
    if(!format){
        return 0;
    }
    let num = 0;
    let temp = format[2];
    let flag = format[1];

    let base = 1;
    for(let i = temp.length - 1; i >= 0; i--){
        num += parseInt(temp[i]) * base;
        base *= 10;
    }
    num = (flag === '-') ? num * (-1) : num;
    if( num <= -2147483649 || num >= 2147483648){
        return 0;
    }
    return num;
}

发散思维能力

1.求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

题解：采用递归，判断终止条件（位运算）

function sum_solution(n){
    let sum = 0;
    plus(n);
    return sum;
    
    function plus(n){
        sum += n;
        sum > 0 && plus(--n);
    }
}

2.写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

题解：记录进位和相加和

function add(num1, numw2){
    let sum, carry;
    do{
        sum = num1 ^ num2;
        carry = (num1 & num2) << 1;
        num1 = sum;
        num2 = carry;
    }while(carry != 0)
    return num1;
}