LeetCode-1073 负二进制数相加（思维题）

给出基数为 -2 的两个数 arr1 和 arr2，返回两数相加的结果。

数字以 数组形式 给出：数组由若干 0 和 1 组成，按最高有效位到最低有效位的顺序排列。例如，arr = [1,1,0,1] 表示数字 (-2)^3 + (-2)^2 + (-2)^0 = -3。数组形式 的数字也同样不含前导零：以 arr 为例，这意味着要么 arr == [0]，要么 arr[0] == 1。

返回相同表示形式的 arr1 和 arr2 相加的结果。两数的表示形式为：不含前导零、由若干 0 和 1 组成的数组。

示例：

输入：arr1 = [1,1,1,1,1], arr2 = [1,0,1]
输出：[1,0,0,0,0]
解释：arr1 表示 11，arr2 表示 5，输出表示 16 。

提示：

1. 1 <= arr1.length <= 1000
2. 1 <= arr2.length <= 1000
3. arr1 和 arr2 都不含前导零
4. arr1[i] 为 0 或 1
5. arr2[i] 为 0 或 1

思路：

-2的偶数次放是正数，奇数次方才是负数。负二进制数从高位到地位标记为n，...，3，2，1，0。每一位对应相加，如果产生进位，其高位对应相加的时候就要相应的减去1，也就是加上-1，即产生了进位；如果当前位进行加法运算的时候出现0+0+(-1)，-1就是上一位产生的进位，就将当前位置为1，其高位对应相加的时候也要加上1，可以理解为，由于负二进制数每一位对于该负二进制数的十进制数的贡献正负交叠，既然加的时候出现了-1，就需要该位的高位和高位的高位都加上1来弥补。例如1+1，结果的十进制数为2，第0位对应相加的结果为0，需要4+(-2)来凑出这个2，即将第0位的高位（第1位）和第0位的高位的高位（第2位）加上1（置为1），即结果负二进制数为110。为了使加上1、加上-1这种操作更加方便，就用next这个整型变量来表示当前位对应相加的时候加上的额外的数（进位）。当前位的加法还有可能出现1+1+(1)的情况，此种情况将当前位的运算结果记为1，并将next置为-1即可，也可以理解为产生了进位。

上AC代码：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* addNegabinary(int* arr1, int arr1Size, int* arr2, int arr2Size, int* returnSize){
    int retsize=arr1Size>arr2Size?arr1Size:arr2Size;
    int *ret=(int *)malloc((retsize+2)*sizeof(int));
    int i=arr1Size-1,j=arr2Size-1,p=retsize+1;
    int next=0;
    int temp;
    int cnt=0;
    while(i>=0&&j>=0)
    {
        temp=arr1[i]+arr2[j]+next;
        if(temp==2)
        {
            next=-1;
            ret[p]=0;
        }
        else if(temp==-1)
        {
            next=1;
            ret[p]=1;
        }
        else if(temp==3)
        {
            next=-1;
            ret[p]=1;
        }
        else
        {
            next=0;
            ret[p]=temp;
        }
        cnt++;
        p--;
        i--;
        j--;
    }
    int k;
    if(i!=-1)
    {
        k=i;
        while(k>=0)
        {
            temp=arr1[k]+next;
            if(temp==2)
            {
                next=-1;
                ret[p]=0;
            }
            else if(temp==-1)
            {
                next=1;
                ret[p]=1;
            }
            else if(temp==3)
            {
                next=-1;
                ret[p]=1;
            }
            else
            {
                next=0;
                ret[p]=temp;
            }
            cnt++;
            p--;
            k--;
        }
    }
    else
    {
        k=j;
        while(k>=0)
        {
            temp=arr2[k]+next;
            if(temp==2)
            {
                next=-1;
                ret[p]=0;
            }
            else if(temp==-1)
            {
                next=1;
                ret[p]=1;
            }
            else if(temp==3)
            {
                next=-1;
                ret[p]=1;
            }
            else
            {
                next=0;
                ret[p]=temp;
            }
            cnt++;
            p--;
            k--;
        }
    }
    while(p>=0&&next!=0)
    {
        if(next==-1)
        {
            ret[p]=1;
            next=1;
        }
        else if(next==1)
        {
            ret[p]=1;
            next=0;
        }
        cnt++;
        p--;
    }
    while(ret[p+1]==0&&p+1<retsize+1)
    {
        p++;
        cnt--;
    }
    *returnSize=cnt;
    return ret+p+1;
}