Leetcode5078. 负二进制数相加

问题：

5078. 负二进制数相加

给出基数为 -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

链接：https://leetcode-cn.com/contest/weekly-contest-139/problems/adding-two-negabinary-numbers/

分析：

两种做法

1 计算出两个值，相加得到结果，然后还原成-2 的幂的和的形式

2 找到进位规则，然后按照加法进行处理。

由于底数是-2，所以会正负交替，且无论正负，前一个等于后面两个和的-2倍，对应的进位应该是-1，

如果前一位是0，则需要向更前一位借1，相对于2进-1，对应的应该是+1，然后下一位+2

比如：

　　　　1 0 1

+        　　   1

--------------------

1  1  0 1 0

解释：

最低位1+1，得0，进位-1

第二位0+（-1），需要向是上一位进位1，2+0-1=1 得1

第三位1+1，得0，进位-1

高位省略0,0-1，借位上一位进1，2-1=1

高位1

最终结果1 1 0 1 0，

检验一下，101对应4-0+1=5,1对应1,5+1=6

对应结果11010=16-8+0-2+0=6。

例子中涉及到了进位 0 1 -1这三种情况

AC Code：

 class Solution {
 public:

     vector<int> addNegabinary(vector<int>& arr1, vector<int>& arr2) {

         //算出值结果逆向回来
         //或者从低位算，两个上面退一
         vector<int>  ret;
          if (arr1.size() ==  && arr2.size() ==  && arr1[]== && arr2[]==)
         {
             ret.emplace_back();
             return ret;
         }
         int len;
         vector<int> larray;
         reverse(arr1.begin(), arr1.end());
         reverse(arr2.begin(), arr2.end());
         if (arr1.size() < arr2.size())
         {
             arr2.emplace_back();
             arr2.emplace_back();
             len = arr1.size();

             larray = arr2;
         }
         else
         {
             arr1.emplace_back();
             arr1.emplace_back();
             len = arr2.size();
             larray = arr1;
         }

         int carry=;
         for (int i = ; i < len; i++)
         {
             int val = arr1[i] + arr2[i]+carry;
             //-1 0 1 2 3
             if (val >= )
             {
                 carry = -;
                 ret.emplace_back(val-);
             }
             else if (val == -)
             {
                 carry = ;
                 ret.emplace_back();
             }
             else
             {
                 carry = ;
                 ret.emplace_back(val);
             }
         }
         for (int i = len; i < larray.size(); i++)
         {
             int val = larray[i] + carry;
             //-1 0 1 2 3
             if (val >= )
             {
                 carry = -;
                 ret.emplace_back(val - );
             }
             else if (val == -)
             {
                 carry = ;
                 ret.emplace_back();
             }
             else
             {
                 carry = ;
                 ret.emplace_back(val);
             }
         }
         vector<int> tmp;
         reverse(ret.begin(), ret.end());
         int zero = ;
         for (int i = ; i < ret.size(); i++)
         {
             if (ret[i] == )
             {
                 zero++;
             }
             else
             {
                 break;
             }
         }
         for (int i = zero; i < ret.size(); i++)
         {
             tmp.emplace_back(ret[i]);
         }
       if (tmp.size() == )
         {
             tmp.emplace_back();
             return tmp;
         }
         return tmp;
     }
 };

其他：

虽然只是个中等，感觉很有意思，底数为负，需要构建新的进位规则，一旦进位规则确定，也就是普通的加减法了