剑指 Offer 64. 求1+2+…+n

剑指 Offer 64. 求1+2+…+n

1.题目描述

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

示例 1：

输入: n = 3
输出: 6

示例 2：

输入: n = 9
输出: 45

限制：

1 <= n <= 10000

2.方法一：递归

1)思路和算法

试想一下如果不加限制地使用递归的方法来实现这道题，相信大家都能很容易地给出下面的实现（以 C++ 为例）：

class Solution{
public:
	int sumNums(int n)
	{
		return n==0 ? 0 : sumNums(n-1);
	}
};

通常实现递归的时候我们都会利用条件判断语句来决定递归的出口，但由于题目的限制我们不能使用条件判断语句，那么我们是否能使用别的办法来确定递归出口呢？答案就是逻辑运算符的短路性质。

以逻辑运算符 && 为例，对于 A && B 这个表达式，如果 A 表达式返回 False ，那么 A && B 已经确定为 False ，此时不会去执行表达式 B。同理，对于逻辑运算符 ||， 对于 A || B 这个表达式，如果 A 表达式返回 True ，那么 A || B 已经确定为 True ，此时不会去执行表达式 B。

利用这一特性，我们可以将判断是否为递归的出口看作 A && B 表达式中的 A 部分，递归的主体函数看作 B 部分。如果不是递归出口，则返回 True，并继续执行表达式 B 的部分，否则递归结束。当然，你也可以用逻辑运算符 || 给出类似的实现，这里我们只提供结合逻辑运算符 && 的递归实现。

2)正确代码

class Solution{
public:
	int sumNums(int n)
	{
		n && (n+=sum(n-1));
		return n;
	}
};

复杂度分析

时间复杂度：O(n)。递归函数递归 n 次，每次递归中计算时间复杂度为 O(1)，因此总时间复杂度为 O(n)。
空间复杂度：O(n)。递归函数的空间复杂度取决于递归调用栈的深度，这里递归函数调用栈深度为 O(n)，因此空间复杂度为 O(n)。

3.方法二：快速乘

考虑 A 和 B 两数相乘的时候我们如何利用加法和位运算来模拟，其实就是将 B 二进制展开，如果 B 的二进制表示下第 i 位为 1，那么这一位对最后结果的贡献就是 A∗(1<<i) ，即 A<<i。我们遍历 B 二进制展开下的每一位，将所有贡献累加起来就是最后的答案，这个方法也被称作「俄罗斯农民乘法。这个方法经常被用于两数相乘取模的场景，如果两数相乘已经超过数据范围，但取模后不会超过，我们就可以利用这个方法来拆位取模计算贡献，保证每次运算都在数据范围内。

快速乘法C++代码

int quickMulti(int A,int B)
{
	int ans=0;
	for(;B;B>>=1)
	{
		if(B&1) ans+=A;
		A<<=1;
	}
	return ans;
}

回到本题，由等差数列求和公式我们可以知道 1+2+⋯+n 等价于$\frac{n(n+1)}{2}$，对于除以 2 我们可以用右移操作符来模拟，那么等式变成了 n(n+1)>>1，剩下不符合题目要求的部分即为 n(n+1)，根据上文提及的快速乘，我们可以将两个数相乘用加法和位运算来模拟，但是可以看到上面的 C++ 实现里我们还是需要循环语句，有没有办法去掉这个循环语句呢？答案是有的，那就是自己手动展开循环，因为题目数据范围 nn 为 [1,10000]，所以 n 二进制展开最多不会超过 14 位，我们手动展开 14 层代替循环即可，至此满足了题目的要求，具体实现可以参考下面给出的代码。

1)快速乘循环展开法

//快速乘之循环展开法
class Solution{
public:
    int sumNums(int n)
    {
        int ans=0,A=n,B=n+1;
        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        (A&1)&&(ans+=B);
        A>>=1;
        B<<=1;

        return ans>>1;
    }
};

2)快速乘递归法

(a & -(b & 1)) 中的-(b & 1) 这个只有两个值可取， [0 , -1] ，-1 参加位与运算的时候有个特点，a & -1 == a

//快速乘之递归
class Solution{
public:
    int sumNums(int n)
    {
        return quickMulti(n,n+1)>>1;
    }
    int quickMulti(int a,int b)
    {
        int ans=0;  
        (a!=0) && (ans=(b&-(a&1))+quickMulti(a>>1,b<<1));
        return ans;
    }
};

方法三：利用sizeof与数组长度

C++

class Solution{
public:
	int sumNums(int n)
	{
		bool arr[n][n+1];// bool 变量占用了 1 个字节的内存
		return sizeof(arr)>>1;
	}
};