【算法百题之四十七】三数之和

【算法百题之四十七】三数之和

 

   大家好，我是Lampard~~

   很高兴又能和大家见面了，接下来准备系列更新的是算法题，一日一练，早日升仙！

   今天的问题是：三数之和

  

  示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

 思路：这道题的难点有两个，其一是如何控制时间复杂度？对于暴力法来说直接来个三重循环nums【a】 + nums【b】 +nums【c】 = 0，试都不用试肯定会超时的。下面我会利用键值对，以及双指针法两种方式把时间复杂度控制在o(n2)。第二个难点是如何排除重复的三元组？每次去遍历结果进行判断也是不合理的。这是我们根据不同解法利用到一些不同的方式。 

 

（1）巧用键值对

【算法百题之两数之和】

  早在我们做两数之和的时候就曾巧用过键值对来进行解题，当时的思路是这样的：在一次的循环中我们能拿到向量【i】的值以及最终想要的和值，那么我们可以通过最终的值减去向量【i】来求出我们另外的减数（设为target），然后我们利用map，若map【target】存在则证明我们已经找到想要的两个下标（i和map【target】），直接输出即可，否则则把本身向量【i】作为键，i作为值，既map【向量【i】】 = i，然后继续循环。

那么做三数之和的时候，这种思路还行不行得通呢？答案是可以的，只不过target值从0 - 向量【i】，变成了0-向量【i】-向量【j】而已。

下面是算法的解题步骤：

1.通过一次遍历，把向量中的值存在map<int, int> numMap中，若出现一次，则值为1（例如numMap【-1】 = 1），若出现n次，则值为n（numMap【-1】 = n）

map<int, int> numMap;
for (int i = 0; i < nums.size(); i++) {
	if (numMap.count(nums[i]) != 0) {
		numMap[nums[i]] = numMap[nums[i]] + 1;
		continue;
	}

	numMap[nums[i]] = 1;
}

for (map<int, int>::iterator i = numMap.begin(); i != numMap.end(); i++) {
	cout << i->first << " " << i->second << endl;
}

2.此时若把map中的数据用迭代器循环输出，你可以看到键是从小到大输出的，就这上面的例子来说他会输出这样的结果。为什么key值会从小到大的输出呢？是因为map的底层是红黑树，默认会把key值给排序。这一点很重要使我们最后排重的关键。

3.然后我们就来个双重循环寻找向量【i】和向量【j】，这里我犯过一个错误，直接把j = i++，但是其实这个++是被重载过的，如果直接j = i++，那么其实i也已经自增，所以要一个tmp来过渡一下。

for (map<int, int>::iterator i = numMap.begin(); i != numMap.end(); i++) {
		map<int, int>::iterator tmp = i;
		for (map<int, int>::iterator j = tmp++; j != numMap.end(); j++) {
			if (j == numMap.end()) {
				break;
			}
	}

4.紧接着就是判断我们target是否在map中了，若不在（if (numMap.count(target) == 0) continue;），ok寻找下一个。若找到了是不是就可以加入到答案中呢？不不不，我们要判断它的个数是否足够，比如说现在向量【i】等于2，向量【j】等于-1，那么我们还差一个-1。若直接判断map中找不找得到键-1，那很明显是找得到的，但是若整个向量中，-1只有一个，已经被向量【j】拿了，那么肯定就凑不出（2，-1，-1）这个组合了。说那么多就是想说，我们除了要判断map中是否存在这个键之外，还要判断数量是否足够。ok，现在存在这个键，而且数量也足够，是不是就可以加到答案中呢？我们还有一个要求，就是不能够有重复元组，我们可以利用本身map的键是有序的原理，判断if (j->first > target) ？ 若target小于向量【j】则证明是在j前面找的，我们排除即可。

最终代码如下：

vector<vector<int>> threeSum(vector<int>& nums) {
	vector<vector<int>> res;
	map<int, int> numMap;
	for (int i = 0; i < nums.size(); i++) {
		if (numMap.count(nums[i]) != 0) {
			numMap[nums[i]] = numMap[nums[i]] + 1;
			continue;
		}

		numMap[nums[i]] = 1;
	}

	for (map<int, int>::iterator i = numMap.begin(); i != numMap.end(); i++) {
		map<int, int>::iterator tmp = i;
		for (map<int, int>::iterator j = tmp++; j != numMap.end(); j++) {
			if (j == numMap.end()) {
				break;
			}

			int target = 0 - i->first - j->first;
			if (numMap.count(target) == 0) continue;
			numMap[target] -= 1;
			numMap[i->first] -= 1;
			numMap[j->first] -= 1;
			if (numMap[target] < 0 || numMap[i->first] < 0 || numMap[j->first] < 0) {
				numMap[target] += 1;
				numMap[i->first] += 1;
				numMap[j->first] += 1;
				continue;
			}

			numMap[target] += 1;
			numMap[i->first] += 1;
			numMap[j->first] += 1;
			if (j->first > target) continue;
			vector<int> curVec = { i->first ,j->first, target };
			res.push_back(curVec);
		}
	}

	return res;
}

测试结果：

这个是我自己做的答案，在LeeCode也是一遍过，但是时空复杂度控制得并不好，于是我便去看看别人的思路。好家伙，也是老朋友了：双指针法。下面我们就看看双指针的思路。

 

（2）双指针法

  算法思路：

  首先将向量的值给从小到大排序了一遍，要求nums【i】 + nums【left】 + nums【right】 = 0 (i < left < right)。那因为本身向量的大小是有序的，若nums【i】都大于0那就不用玩了，直接返回。若nums【i】 + nums【left】 + nums【right】现在大于0则证明大了，我们就缩小right，反之则增大left。若right == left的时候就跳出循环i自增。好像有点意思，是吧。那看看他们是如何进行去重的。 

// 去重逻辑应该放在找到一个三元组之后
 while (right > left && nums[right] == nums[right - 1]) right--;
  while (right > left && nums[left] == nums[left + 1]) left++;

当找到nums【i】 + nums【left】 + nums【right】= 0的时候我们还不能直接存入答案，为了去重还要直接往内回收，若nums[right] == nums[right - 1])则right --，力求下一次遍历不会遇到这个元素。这个算法的还是比我的高效一些。

下面是完整的代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return result;
            }

            // 正确去重方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                } else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                } else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

 

OK，今天的博客就到这里，谢谢大家！！！