标签：大数 灵活 pre 元素 回溯 数组 val lis 注意
地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
示例 1：
输入：m = 2, n = 3, k = 1
输出：3
示例 2：
输入：m = 3, n = 1, k = 0
输出：1
思路：BFS广度优先搜索。
利用方向数组简易化访问操作。
判断这个点能不能遍历的条件一定要齐全，比如该点坐标[i,j]，i<0||j<0||i>m-1||j>n-1||visted[‘i,j‘]||fun1(i)+fun1(j)>k,这些条件的出现都不能让该点被遍历。
//fun1返回数位和
var fun1 = function(num) {
var res = 0
while (num) {
var a = num % 10
res += a
num = Math.floor(num / 10)
}
return res
}
var movingCount = function(m, n, k) {
//方向数组
var dedicationArray = [
[-1, 0], //向上
[0, 1], //向右
[1, 0], //向下
[0, -1] //向左
]
//已经访问过的坐标集
var visited = {}
visited[‘0,0‘] = true
//目前位置坐标集
var queue = [[0, 0]]
while (queue.length) {
let [x, y] = queue.shift() //在此回溯
//访问过程,随便访问。无所谓顺序
for (var i = 0; i < 4; i++) {
var offSetX = x + dedicationArray[i][0] //将要访问的x坐标
var offSetY = y + dedicationArray[i][1] //将要访问的y坐标
if (
offSetX < 0 ||
offSetX >= m ||
offSetY < 0 ||
offSetY >= n ||
fun1(offSetX) + fun1(offSetY) > k ||
visited[`${offSetX},${offSetY}`]
) {
continue //跳过该次循环
}
//访问成功
visited[`${offSetX},${offSetY}`] = true
queue.push([offSetX, offSetY])
}
}
return Object.keys(visited).length
}
给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m] 。请问 k[0]k[1]...*k[m] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
示例 1：
输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例?2:
输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 ×?3 ×?4 = 36
提示：
2 <= n <= 58
/**
* @param {number} n
* @return {number}
*/
var cuttingRope = function(n) {
//动态规划
//可以看成底数就是dp[1],dp[2],dp[3]，所有大于3的整数都可以由他们三个组合而成
//dp[n]代表传入长度为n时，剪绳子后，最大乘积的那个数
var dp = new Array(n + 1)
dp.fill(1)
//易得 dp[1]=1,dp[2]=1，i从3开始算
for (var i = 3; i <= n; i++) {
for (var j = 1; j < i; j++) {
var res = Math.max(j * (i - j), j * dp[i - j])
dp[i] = Math.max(dp[i], res)
}
}
return dp[n]
}
请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9?表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011?中，共有三位为 ‘1‘。
示例 2：
输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000?中，共有一位为 ‘1‘。
示例 3：
输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1‘。
思路：n & (n - 1) 会把该整数最右边的1变成0，依次循环，直到整数中所有的1变成0循环结束。
则循环执行的次数就是该整数的二进制数中包含的1的个数。
/**
* @param {number} n - a positive integer
* @return {number}
*/
var hammingWeight = function(n) {
var res = 0
while (n !== 0) {
n = n & (n - 1)
res++
console.log(n)
}
return res
}
实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
示例 1:
输入: 2.00000, 10
输出: 1024.00000
示例?2:
输入: 2.10000, 3
输出: 9.26100
示例?3:
输入: 2.00000, -2
输出: 0.25000
解释: 2^-2 = 1/2^2 = 1/4 = 0.25
分治法。
一个整数base的n次方：
①如果n是偶数，则可分为base^1/2 * base^1/2
②如果n是奇数，则可分为base^1/2 * base^1/2 * base
③n为负数，则先用他的绝对值计算最后返回的时候取倒数即可。
/**
* @param {number} x
* @param {number} n
* @return {number}
*/
var myPow = function(x, n) {
var isNagative = n < 0
var result = fun1(x, n)
return isNagative ? 1 / result : result
}
var fun1 = function(base, exponent) {
if (exponent < 0) {
exponent = -exponent
}
if (exponent === 0) {
return 1
}
if (exponent === 1) {
return base
}
var subExponent = Math.floor(exponent / 2)
var subResult = fun1(base, subExponent)
return exponent % 2 == 1
? base * subResult * subResult
: subResult * subResult
}
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:
输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]
/**
* @param {number} n
* @return {number[]}
*/
var printNumbers = function(n) {
var counter = Math.pow(10, n) - 1
var k = []
for (var i = 1; i <= counter; i++) {
k.push(i)
}
return k
}
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。
注意：此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为?5?的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为?1?的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
?
说明：
题目保证链表中节点的值互不相同
若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
思路：利用哨兵节点。哨兵节点是一个附加的链表节点，该节点作为第一个节点，它的值域中并不存储任何东西，只是为了操作的方便而引入的。如果一个链表有哨兵节点的话，那么线性表的第一个元素应该是链表的第二个节点。 它的加入使得链表操作更灵活。
/**
Definition for singly-linked list.
function ListNode(val) {
this.val = val;
this.next = null;
}
/
/*
@param {ListNode} head
@param {number} val
@return {ListNode}
*/
var deleteNode = function(head, val) {
//哨兵节点：
var preNode = new ListNode()
preNode.next = head
var currNode = preNode
while (currNode.next != null) {
if (currNode.next.val == val) {
currNode.next = currNode.next.next
break
}
currNode = currNode.next
}
return preNode.next
}
标签：大数 灵活 pre 元素 回溯 数组 val lis 注意
原文地址：https://www.cnblogs.com/Tulandbla/p/12757703.html
