Leetcode 1006.笨阶乘

1.题目描述

通常，正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。

相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，这些运算仍然使用通常的算术运算顺序：我们在任何加、减步骤之前执行所有的乘法和除法步骤，并且按从左到右处理乘法和除法步骤。

另外，我们使用的除法是地板除法（floor division），所以 10 * 9 / 8 等于 11。这保证结果是一个整数。

实现上面定义的笨函数：给定一个整数 N，它返回 N 的笨阶乘。

示例 1：

输入：4
输出：7
解释：7 = 4 * 3 / 2 + 1
示例 2：

输入：10
输出：12
解释：12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1

提示：

1 <= N <= 10000
-2^31 <= answer <= 2^31 - 1 （答案保证符合 32 位整数。）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/clumsy-factorial
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.思路

2.1模拟计算器

观察示例解释可以发现，当遇到乘号 " * " 或除号 " / " 时，可以立即进行处理，而遇到加号 " + " 或 减号" - " 时，可以将当前结果存入一个列表中，等到之后再处理。
以输入 10 为例：
新建一个空的列表 list = [ ]，用变量tempt维护当前数值结果， 初始化tempt为N，然后开始 while 循环
①遇到乘号，计算 tempt = 10 * 9 = 90；
②遇到除号，计算 tempt = 90 / 8 = 11；
③遇到加号，将上一步的 tempt = 11存入list中，然后令 tempt = 7；
④遇到减号，将上一步的 tempt = 7存入list中，然后令 tempt = 6；
⑤遇到乘号，计算 tempt = 6 * 5 = 30；
⑥遇到除号，计算 tempt = 30 / 4 = 7；
⑦遇到加号，将上一步的 tempt = 7存入list中，然后另 tempt = 3；
⑧遇到减号，将上一步的 tempt = 3存入list中，然后令 tempt = 2；
⑨遇到乘号，计算 tempt = 2*1 = 2，循环结束，将 tempt = 2 存入list中；
此时 list = [11, 7, 7, 3, 2]
最终结果 result = 11+7-7+3-2 = 12

代码如下

class Solution {
    public int clumsy(int N) {
        Queue<String> operationQueue = new LinkedList<>() ;
    	List<Integer> list = new ArrayList<>();
    	operationQueue.offer("*");
    	operationQueue.offer("/");
    	operationQueue.offer("+");
    	operationQueue.offer("-");
    	int tempt = N;
    	while(N-1 > 0) {
    		String operation = operationQueue.poll();
    		switch (operation) {
			case "*": {
				tempt *= (N-1);
				break;
			}
			case "/": {
				tempt = Math.floorDiv(tempt, (N-1));
				break;
			}
			case "+": {
				list.add(tempt);
				tempt = N - 1;
				break;
			}
			case "-": {
				list.add(tempt);
				tempt = N - 1;
				break;
			}
			default:{
				
			}
			}
    		operationQueue.add(operation);
    		N --;
    	}
    	list.add(tempt);
    	int result = list.get(0);
    	for(int i = 1; i < list.size(); i++) {
    		if(i%2 == 0 ) {
    			result -= list.get(i);
    		}else {
    			result += list.get(i);
    		}
    	}
        return result;
    }
}

看了官方的解答后，发现不需要像上面代码一样读取 String 类型的运算符。由于运算符循环周期为4，因此可以维护一个 index ，然后对4取模即可判断当前采用什么运算符。
list也可以采用栈进行替换，优化后的代码如下：

import java.util.*;

class Solution {
	public static void main(String[] args) {
		int N = 10;
		System.out.println(clumsy(N));
	}
    public static int clumsy(int N) {
    	Deque<Integer> stack = new LinkedList<>() ;
    	stack.push(N);
    	N --;
    	int index = 0;
    	while(N > 0) {
    		if(index % 4 == 0) {  
    			stack.push(stack.pop() * N);
    		}else if(index % 4 == 1) {
    			stack.push(stack.pop() / N);
    		}else if(index % 4 == 2) {
    			stack.push(N);
    		}else {
    			stack.push(-N);
    		}
    		index++ ;
    		N--;
    	}
    	System.out.println(stack.toString());
    	int result = 0;
    	while(stack.isEmpty() == false) {
    		result += stack.pop();
    	}
    	return result;
    }
}

2.2数学表达式

将数学表达式展开，分类讨论，可以发现
N <= 4时：
N = 1时，clumsy(N) = 1；
N = 2时，clumsy(N) = 2；
N = 3时，clumsy(N) = 6；
N = 4时，clumsy(N) = 7；

N > 4时：
N % 4 == 0时， clumsy(N) = N+1;
N % 4 == 1时， clumsy(N) = N+2;
N % 4 == 2时， clumsy(N) = N+2;
N % 4 == 3时， clumsy(N) = N-1;

则代码如下：

class Solution {
	public static void main(String[] args) {
		int N = 10;
		System.out.println(clumsy(N));
	}
    public static int clumsy(int N) {
    	if(N == 1) {
    		return 1;
    	}else if(N == 2) {
    		return 2;
    	}else if(N ==3) {
    		return 6;
    	}else if(N ==4) {
    		return 7;
    	}
    	if(N % 4 == 0) {
    		return N + 1;
    	}else if(N % 4 == 1) {
    		return N + 2;
    	}else if(N % 4 == 2) {
    		return N + 2;
    	}else {
    		return N - 1;
    	}
    }
}