剑指offer - 13.机器人的运动范围|14.1剪绳子

面试题13.机器人的运动范围

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

解题思路:
这个方格可以看成m*n的矩阵。除矩阵边界上的格子外,其它格子都有4个相邻的格子。利用回溯法,机器人从坐标(0,0)开始移动,当它进入坐标为(i,j)的格子时,通过检查坐标的位数和来判断机器人是否能够进入。如果机器人能够进入坐标为(i,j)的格子,count首先加1,再判断它能否进入四个相邻的格子(i,j-1),(i-1,j),(i,j+1),(i+1,j)。重复这个过程,直到坐标位数之和不大于k的格子被遍历完为止,最终返回count

class Solution {
public:
	int movingCount(int threshold, int rows, int cols)
	{
		bool* visited = new bool[rows*cols];
		memset(visited, 0, rows*cols);
		int count = movingCountCore(threshold, rows, cols, 0, 0, visited);
		delete[]visited;
		return count;
	}
	int movingCountCore(int threshold, int rows, int cols, int row, int col, bool* visited)
	{
		int count = 0;
		if (check(threshold, rows, cols, row, col, visited))
		{
			visited[row*cols + col] = true;
			count = 1 + movingCountCore(threshold, rows, cols, row, col - 1, visited) +
				movingCountCore(threshold, rows, cols, row - 1, col, visited) +
				movingCountCore(threshold, rows, cols, row, col + 1, visited) +
				movingCountCore(threshold, rows, cols, row + 1, col, visited);
		}
		return count;
	}
 
	/*该函数检查坐标为(row,col)的方格能够进入*/
	bool check(int threshold, int rows, int cols, int row, int col, bool*visited)
	{
		if (row >= 0 && row < rows&&col >= 0 && col < cols
			&&getDigitSum(row) + getDigitSum(col) <= threshold 
			&& !visited[row*cols + col])
			return true;
		return false;
	}
 
	/*计算一个数的所有位数之和*/
	int getDigitSum(int number)
	{
		int sum = 0;
		while (number > 0)
		{
			sum += number % 10;
			number = number / 10;
		}
		return sum;
	}
};

面试题14.剪绳子

题目描述:
给你一根长度为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。

解题思路:这类问题有2种不同的方式来解决, 一个是动态规划, 还有一个是贪婪算法。
动态规划首先定义函数f(n)为把长度为n的绳子剪成若干段后各段长度乘积的最大值。在剪第一刀时,我们有n-1种选择,也就是说第一段绳子的可能长度分别为1,2,3…,n-1。因此f(n)=max(f(i)*f(n-i)),其中0<i<n。这是一个自上而下的递归公式。由于递归会有大量的不必要的重复计算。一个更好的办法是按照从下而上的顺序计算,也就是说我们先得到f(2),f(3),再得到f(4),f(5),直到得到f(n)。
贪婪算法:当n大于等于5时,我们尽可能多的剪长度为3的绳子;当剩下的绳子长度为4时,把绳子剪成两段长度为2的绳子。 为什么选2,3为最小的子问题?因为2,3包含于各个问题中,如果再往下剪得话,乘积就会变小。 为什么选长度为3?因为当n≥5时,3(n−3)≥2(n−2)
method:贪婪算法C++实现

class Solution {
public:
    int cutRope(int number) {
        if(number == 2)
            return 1*1;
        if(number == 3)
            return 1*2;
        int res = 0;
        int x = number / 3;
        int y = number % 3;
        if(y == 0){
            res += pow(3, x);
        }
        else if(y == 1){
            res += pow(3, x-1) * 2 * 2;
        }
        else{
            res += pow(3, x) * 2;
        }
        return res;
    }
}

参考博客:
https://blog.csdn.net/Xqing_2016/article/details/87901262?utm_source=distribute.pc_relevant.none-task
https://blog.csdn.net/modabaichi/article/details/89042551
https://blog.csdn.net/SCS199411/article/details/91839012

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值