一道简单的 c++编程题求解答

输入那里是
5
1 2 3 1 2
7
1 1 1 2 2 2 2
输出是
2 3
2 1

惊了.直接一个 map 就解决了的事情.

map[ element ]++;

```
int main()
{
int N = 0;
int hash[1000] = {0};
int l = 0;

cin >> N;
for (int i = 0; i < N; i++) {
cin >> l;
hash[l]++;
}

int count = 0, single = 0;
for (int i = 0; i < 1000; i++) {
if (hash[i] >= 2)
count++;
if (hash[i] % 2 != 0)
single = i;
}

cout << count << " " << single << endl;
return 0;
}
```

所有筷子长度异或到一起, 结果就是落单筷子的长度

落单筷子长度=0;
map count;
筷子种类数;
for each 筷子
{
落单筷子长度 ^= 这个筷子长度;
if (count[这个筷子长度]++ == 0): 筷子种类数++;
}
if (--count[落单筷子长度] == 0): 筷子种类数--;
return (落单筷子长度, 筷子种类数);

我觉得和编程珠玑第一章那个问题挺像的。你的代码我就看不懂了

建一个 map 长度为键：该长度个数为值 如果为奇数就是落单的。

排序后遍历一遍，奇数个就是落单的。

@vegito2002 厉害！

@skadi 主要是想熟悉下 set

@Yourshell 是某个 oj 里面的

@x86vk 主要是想熟悉下 set

楼主你要的用 set 的方法

#include <iostream>
#include <unordered_set>
using namespace std;

int main() {
unordered_set<int> singles;
unordered_set<int> pairs;
int N = 0;
cin >> N;
for (int i = 0; i < N; i++) {
int l;
cin >> l;
if (singles.find(l) == singles.end()) {
singles.insert(l);
}
else {
singles.erase(l);
pairs.insert(l);
}
}
cout << pairs.size() << " " << *singles.begin() << endl;
return 0;
}

@vegito2002 正解，时间 O(n)空间 O(1)

等，不一定，如果要算种类那还不如直接 hashmap

@SuperFashi set 我记得查找是 logn 啊，如果套哈希的话数据可以把你卡成 n2 的复杂度

@SuperFashi 我 6L 的代码是 O(N)时间而且是 1-pass. 这题 O(1)空间是做不到的, 只能抢一个常数因子的时间差距; 只用 count 来做的话, 我觉得可能要两个 pass? 筷子本身过一个 pass, 然后 count 要过一个 pass;

筷子的长度取值空间这么小，一个位图表示，空间和 N 没有关系，可以看成 O(1)的空间，O(n)的时间，类似 6L 的方法

@vegito2002 不用 map，直接数组就行

@SuperFashi 数组是在你知道筷子长度值域的情况下才行吧, 否则对于空间的浪费完全不可控

@SuperFashi 哦没注意看, 还真的给了值域. 大概扫了题目一眼就写了, 没仔细看

@vegito2002 筷子长度范围给了的，小得很。其实严谨来说空间是 O(L)

@kiwi95
@vegito2002
@SuperFashi

可是长度范围比筷子个数大不少呀。当然这个问题用计数法可能很快，然而在这些数具体给定的情况下还是要用实践看看哪个方法更适合 AC。

另，这样做是 L 的时间而不是 N 的时间，实践中可能更快 /很快是因为 L 前面的因数比较小的缘故吧。

@geelaw 我回头想想, 楼主这里是不是复制的时候丢了指数? 他这里复制的是筷子长度最长 109, 如果真的是这个完全是可以当成 O(1)空间的 counting 的. 但是我觉得很有可能楼主这里这两个数字实际上是 10^9 和 10^6, 只是他自己复制的时候忘记修正一下. 如果真的是指数级别, 那肯定就必须用 Map 了, 要合理利用 sparsity, bucket counting 会浪费太多的空间;

当然, 具体情况还是要看这个东西用在什么场合了; 从做题的角度反正是我就一个 Map 搞定算了, 面试官不让我用 bucket 我就先不走这个优化;

@geelaw 如果是他们的 2pass 的做法, 那么确实如果 N=O(L), 那么 bucket 的 count 做法会导致最后的时间是 O(L). 但是如果采用我 6L 的代码, 还是一个 O(N)的时间, 因为不需要重新分析一次 count;

@vegito2002 弱弱的问一句 map 插入查找不是 logn 嘛

@x86vk 我不是百分百清楚, 不过 LeetCode 讨论区看到过有人说好像跟语言有关系;

http://www.cplusplus.com/forum/general/31927/

如果是 c++, 你说的是对的; java 的话, 好像 Map 操作都能当 O(1)来玩;

上面那个帖子我没仔细读完, 主要是我也没有正经学过 c++, 一些语言特性不太清楚;

@vegito2002 #25 显然是 10^6 和 10^9。但无论如何这是一个常数，只能说是很大的常数吧。

@vegito2002 #26 初始化 count 已经需要 Omega(L) 的时间。

@vegito2002 #28 C++ 的 std::map 需要 O(logn) 的时间查找； Java 的 Map 是 **期望** O(1)。

@geelaw 初始化确实是, 只要用 bucket 方法就少不了 O(L), 同意

@vegito2002 java 如果您指的是 hashmap 的话，精心构造的数据理论上是不是可以把它搞成 on 的查找和插入

@x86vk 当然是可以的, hash 从来都不是万无一失的

leetcode 上有这道题目
https://leetcode.com/problems/single-number-ii/description/
时间复杂度 O(n)
空间复杂度 O(1)

using namespace std;
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
int tmp=0,tmp1=1,numA=0,numB=0;
for (auto it = nums.begin(); it != nums.end(); it++) {
tmp ^= (*it);
}
while (tmp % 2 == 0) {
tmp1 *= 2;
tmp /= 2;
}

for (auto it = nums.begin(); it != nums.end(); it++) {
if ((tmp1 ^ (*it)) == ((*it)-tmp1)) {
numA ^= (*it);
}
else {
numB ^= (*it);
}
}
auto res = new vector<int>;
(*res).push_back(numA);
(*res).push_back(numB);
return *res;
}
};

@zjuturtle 日贴错了，应该是这个

#include<iostream>
#include<vector>
using namespace std;
class Solution {
public:
int singleNumber(vector<int>& nums) {
vector<int> positiveCounts(32, 0);
vector<int> negtiveCounts(32, 0);
for (auto it = nums.begin(); it != nums.end(); it++) {
auto tmp = *it;
int index = 0;
if (tmp > 0) {
while (tmp!=0) {
positiveCounts[index] += (tmp % 2);
tmp /= 2;
index++;
}
}
else {
tmp = -tmp;
while (tmp != 0) {
negtiveCounts[index] += (tmp % 2);
tmp /= 2;
index++;
}
}
}
int pos = 0,neg=0,p=1,n=1;
for (int i = 0; i < 32; i++) {
auto pbit = positiveCounts[i] %= 3;
auto nbit = negtiveCounts[i] %= 3;
pos += (pbit*p);
neg += (nbit*n);
p *= 2;
n *= 2;
}
if(pos>0)
return pos;
return -neg;
}
};

@zjuturtle 日原题有很多变种我特么又贴错了，给跪。
原题
https://leetcode.com/problems/single-number/description/
解答
#include<iostream>
#include<vector>

using namespace std;
class Solution {
public:
int singleNumber(vector<int>& nums) {
int res = 0;
for (auto it = nums.begin(); it != nums.end(); it++) {
res ^= *it;
}
return res;
}
};

第一问是 (N-1)/2
第二问是 所有数字 xor 一下，成对的数字 xor 两次等于零。

@starqoq 1112222 (N - 1) / 2 = 3, 但是要求的是种类数量, 应该是 2;

@vegito2002
7
[1 1] 1 [2 2] [2 2]
这样不是能凑三双？

@starqoq 看楼主 1L 的帖子, 这个例子应该返回 2, 因为只有两**种**.