LeetCode954二倍数对数组

问题：二倍数对数组

给定一个长度为偶数的整数数组 A，只有对 A 进行重组后可以满足 “对于每个 0 <= i < len(A) / 2，都有 A[2 * i + 1] = 2 * A[2 * i]” 时，返回 true；否则，返回 false。

示例 1：

输入：[3,1,3,6]
输出：false

示例 2：

输入：[2,1,2,6]
输出：false

示例 3：

输入：[4,-2,2,-4]
输出：true
解释：我们可以用 [-2,-4] 和 [2,4] 这两组组成 [-2,-4,2,4] 或是 [2,4,-2,-4]

示例 4：

输入：[1,2,4,16,8,4]
输出：false

提示：

1. 0 <= A.length <= 30000
2. A.length 为偶数
3. -100000 <= A[i] <= 100000

链接：https://leetcode-cn.com/contest/weekly-contest-114/problems/array-of-doubled-pairs/

分析：

题目要求看给出的数组能否通过重新排序，使的所有的偶数位置值是前一个的奇数值的二倍。

那么可以通过将数据分为负数和非负数两组，分组的原因是方便处理，对于非负数，直接递增排序正向处理，对于负数，排序后需要反向处理。关键看绝对值，处理逻辑是一样的。

以非负数为例：

排序后最小的值肯定是放在奇数位，那么在后面查找他的2倍是否存在，如果不存在可以直接结束返回false

如果存在，则需要将该数字移除，因为每个数字只能用到一次。

比如给出的例子中第一组排序后是 1 3 3 6 ，1 的2倍2不存在，false

第二组： 1 2 2 6，1的二倍2存在，移除2，得到1 2 6，处理下一个数据2,2的2倍4不存在，false

第三组分为-4 -2和2 4 两组，都对应存在，true

第四组，排序后 1 2 4 4 8 16

1-> 2 存在，移除2数组变为1 4 4 8 16

处理下一个4，4->8 存在，移除8得到 1 4 4 16

处理下一个4,8不存在，false

AC Code：

 class Solution {
 public:
 bool canReorderDoubled(vector<int>& A) {
         bool ret = true;
         //首先正负分开
         vector<int> Pvec;
         vector<int> Nvec;
         for (unsigned int i = ; i < A.size(); i++)
         {
             if (A[i] < )
             {
                 Nvec.emplace_back(-*A[i]);
                 //Pvec.emplace_back(-1*A[i]);
             }
             else
             {
                 Pvec.emplace_back(A[i]);
             }
         }
         if (Pvec.size() %  != )
         {
             return false;
         }
         sort(Pvec.begin(), Pvec.end());
         int limit = Pvec.size() / ;
         for (unsigned int i = ; i < limit;i++)
         {
             if (find(Pvec.begin() + i + , Pvec.end(),  * Pvec[i]) != Pvec.end())
             {
                 Pvec.erase(find(Pvec.begin() + i + , Pvec.end(),  * Pvec[i]));
             }
             else
             {
                 return false;
             }
         }
         sort(Nvec.begin(), Nvec.end());
         limit = Nvec.size() / ;
         for (unsigned int i = ; i < limit;i ++)
         {
             if (find(Nvec.begin() + i + , Nvec.end(),  * Nvec[i]) != Nvec.end())
             {
                 Nvec.erase(find(Nvec.begin() + i + , Nvec.end(),  * Nvec[i]));
             }
             else
             {
                 return false;
             }
         }
         return true;
     }
 };

其他：

1.sort 默认升序，对于负数可以通过乘以-1转换为整数，之前看别人的一个解答学到的，可以省去编写自定义排序函数。

2.vector中查看某个元素是否存在，通过find(.begin(),.end(),value)，如果没找到，返回end()，如果找到了，返回对应的迭代器值（iterator）

3,vector 中删除元素通过索引，如果本身就是iterator，可以直接删除erase(iterator)，如果是个index 数字，可以通过erase（.begin()+index）

4，第一code：

 #pragma GCC optimize("O3", "unroll-loops")
 // God Help me !!
 #include <bits/stdc++.h>
 using namespace std;
 // #define watch(x) cout << (#x) << " is " << (x) << endl

 #define FILES freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout)
 #define FAST ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
 #define FIXED cout << fixed << setprecision(20)
 #define RANDOM srand(time(nullptr))
 // #define int long long
 #define MOD 1000000007
 #define sz(a) (ll)a.size()
 #define pll pair<ll,ll>
 #define rep(i,a,b) for(int i=(int)a;i<(int)b;i++)
 #define sep(i,a,b) for(int i=(int)a;i>=(int)b;i--)
 #define mll map<int,int>
 #define vl vector<int>
 #define pb push_back
 #define lb lower_bound
 #define ub upper_bound
 #define all(a) a.begin(),a.end()
 #define F first
 #define S second
 #define endl "\n"
 #define MAXN6 3000005
 #define MAXN3 3005
 #define MAXN5 300005

 #define watch(...) ZZ(#__VA_ARGS__, __VA_ARGS__)
 template <typename Arg1> void ZZ(const char* name, Arg1&& arg1){std::cerr << name << " = " << arg1 << endl;}
 template <typename Arg1, typename... Args>void ZZ(const char* names, Arg1&& arg1, Args&&... args)
 {
     const char* comma = strchr(names + , ',');
     std::cerr.write(names, comma - names) << " = " << arg1;
     ZZ(comma, args...);
 }

 class Solution {
 public:
     bool canReorderDoubled(vector<int>& A) {
         int positive[], negative[];
         memset(positive, , sizeof(positive));
         memset(negative, , sizeof(negative));
         for (int x: A) {
             if (x >= ) positive[x]++;
             else negative[-x]++;
         }
         if (positive[] %  != ) return false;
         for (int i = ; i <= ; i++) {
             if (positive[i] != ) {
                 if (positive[i*] < positive[i]) return false;
                 positive[i*] -= positive[i];
             }
         }
         for (int i = ; i <= ; i++) {
             if (negative[i] != ) {
                 if (negative[i*] < negative[i]) return false;
                 negative[i*] -= negative[i];
             }
         }
         return true;
     }
 };

看到第一code 用来桶的那种方式 ，通过申请足够大的数组，下标就是值，删除通过--实现，而vector中删除需要移动大量数据，随意AC虽然过了，时间800+

完赛后QQ群里面有提到这个题 其实核心思路就是分组，排序， 查找元素是否存在以及删除。

那么可以通过map来做，map存储出现的数字以及个数 ，key是数字，value是数字个数，如果数字被用过了，value--,通过这种方式模拟删除。

这样也能AC，而且时间从800+降到96，虽然时间和很多因素有关， 比如服务器状态、测试数据等，但是下降一个数量级还是很能说明问题的。

map实现：

 class Solution {
 public:
     bool canReorderDoubled(vector<int>& A) {
         bool ret = true;
         map<int, int> Ndata;
         map<int, int> Pdata;
         int Nnum = ;
         for (int i : A)
         {
             if (i >= )
             {
                 if (Pdata.find(i) != Pdata.end())
                 {
                     Pdata[i]++;
                 }
                 else
                 {
                     Pdata[i] = ;
                 }
             }
             else
             {
                 Nnum++;
                 if (Ndata.find(-*i) != Ndata.end())
                 {
                     Ndata[- * i]++;
                 }
                 else
                 {
                     Ndata[- * i] = ;
                 }
             }
         }

         if (Nnum % != )
         {
             return false;
         }
         //处理非负数
         map<int, int>::iterator it = Pdata.begin();
         int Limit = (A.size()-Nnum) / ;
         for (unsigned int i = ; i < Limit; )
         {
             if ((*it).second == )
             {
                 it++;
                 continue;
             }
             int tmpdata = (*it).first;
             (*it).second--;
             map<int, int>::iterator tmpit;
             tmpit = Pdata.find( * (*it).first);
             if (tmpit == Pdata.end() || (*tmpit).second==)
             {
                 return false;
             }
             else
             {
                 (*tmpit).second--;
             }
             if ((*it).second == )
             {
                 it++;
             }
             i++;
         }

         it = Ndata.begin();
         Limit = Nnum / ;
         for (unsigned int i = ; i < Limit;)
         {
             if ((*it).second == )
             {
                 it++;
                 continue;
             }
             int tmpdata = (*it).first;
             (*it).second--;
             map<int, int>::iterator tmpit;
             tmpit = Ndata.find( * (*it).first);
             if (tmpit == Ndata.end() || (*tmpit).second == )
             {
                 return false;
             }
             else
             {
                 (*tmpit).second--;
             }
             if ((*it).second == )
             {
                 it++;
             }
             i++;
         }

         return ret;
     }
 };

一段时间不用map，手生了。

a.1 map个数是值的个数，这一个题中直接用map的size得不到正负数个数，需要value累加或者通过额外的一个变量记录

a.2 如果因为个数为零跳过，那么index i不应增加，所以i的改变时机要放到后面合适的地方，而不是for内

a.3 如果数据涉及到底层的移动变换等，最好能够避免，是在避免不了也尽量集中处理 ，记得之前看到一本书提到C++的一些高级特性的时候有提到这个，一时想不起来的，书读百遍，有时间还是得在读一遍。

a.4使用的C++，感觉自己用的这套测试测试函数挺不错的，再也不用通过OJ debug了，而且能够回归测试，避免修改过后顾头不顾尾，记下来，有需要的可以拿去。

比如对于954的测试：

 void test954()
 {
     Solution954 S;
     vector<int> A;
     bool ans;
     bool tans;

     A = vector<int>{ ,,,,, };
     tans = false;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;

     A = vector<int>{ ,,, };
     tans = false;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;

     A = vector<int>{ ,,,,,,,};
     tans = true;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;

     A = vector<int>{ ,,, };
     tans = false;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;

     A = vector<int>{ ,-,,- };
     tans = true;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;

     A = vector<int>{ ,,,,, };
     tans = false;
     ans = S.canReorderDoubled(A);
     cout << "ans:" << ans << "  tans:" << tans << "  ### " << (ans == tans) << endl;
 }

如果有新的测试数据只需要加进去就行。如果用来测试新的类，只需要根据需要设定数据类型，返回值类型，然后在具体的测试用例里面设置就可以了。如果输出目标答案tans和时机答案ans一致，则测试通过。如果是一些符合数据，需要自己编写判断是否相等的函数。