剑指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