5.双指针
双指针理论基础
那么vector< char > 和 string 又有什么区别呢?
其实在基本操作上没有区别,但是 string提供更多的字符串处理的相关接口,例如string 重载了+,而vector却没有。
所以想处理字符串,我们还是会定义一个string类型。
双指针套路总结
数组篇
在数组:就移除个元素很难么? (opens new window)中,原地移除数组上的元素,我们说到了数组上的元素,不能真正的删除,只能覆盖。
一些同学可能会写出如下代码(伪代码):
for (int i = 0; i < array.size(); i++) {
if (array[i] == target) {
array.erase(i);
}
}
这个代码看上去好像是O(n)的时间复杂度,其实是O(n^2)的时间复杂度,因为erase操作也是O(n)的操作。
所以此时使用双指针法才展现出效率的优势:通过两个指针在一个for循环下完成两个for循环的工作。
字符串篇
1 其实很多数组填充类的问题,其做法都是先预先给数组扩容带填充后的大小,然后在从后向前进行操作。
这么做有两个好处:
- 不用申请新数组。
- 从后向前填充元素,避免了从前向后填充元素时,每次添加元素都要将添加元素之后的所有元素向后移动的问题。
链表篇
翻转链表是现场面试,白纸写代码的好题,考察了候选者对链表以及指针的熟悉程度,而且代码也不长,适合在白纸上写。
在链表:听说过两天反转链表又写不出来了? (opens new window)中,讲如何使用双指针法来翻转链表,只需要改变链表的next指针的指向,直接将链表反转 ,而不用重新定义一个新的链表。
思路还是很简单的,代码也不长,但是想在白纸上一次性写出bugfree的代码,并不是容易的事情。
在链表中求环,应该是双指针在链表里最经典的应用,在链表:环找到了,那入口呢? (opens new window)中讲解了如何通过双指针判断是否有环,而且还要找到环的入口。
使用快慢指针(双指针法),分别定义 fast 和 slow指针,从头结点出发,fast指针每次移动两个节点,slow指针每次移动一个节点,如果 fast 和 slow指针在途中相遇 ,说明这个链表有环。
从头结点出发一个指针,从相遇节点 也出发一个指针,这两个指针每次只走一个节点, 那么当这两个指针相遇的时候就是 环形入口的节点。
N数之和篇
在哈希表:解决了两数之和,那么能解决三数之和么? (opens new window)中,讲到使用哈希法可以解决1.两数之和的问题
其实使用双指针也可以解决1.两数之和的问题,只不过1.两数之和求的是两个元素的下标,没法用双指针,如果改成求具体两个元素的数值就可以了,大家可以尝试用双指针做一个leetcode上两数之和的题目,就可以体会到我说的意思了。
使用了哈希法解决了两数之和,但是哈希法并不使用于三数之和!
使用哈希法的过程中要把符合条件的三元组放进vector中,然后在去去重,这样是非常费时的,很容易超时,也是三数之和通过率如此之低的根源所在。
去重的过程不好处理,有很多小细节,如果在面试中很难想到位。
时间复杂度可以做到O(n^2),但还是比较费时的,因为不好做剪枝操作。
所以这道题目使用双指针法才是最为合适的,用双指针做这道题目才能就能真正体会到,通过前后两个指针不算向中间逼近,在一个for循环下完成两个for循环的工作。
只用双指针法时间复杂度为O(n2),但比哈希法的O(n2)效率高得多,哈希法在使用两层for循环的时候,能做的剪枝操作很有限。
在双指针法:一样的道理,能解决四数之和 (opens new window)中,讲到了四数之和,其实思路是一样的,在三数之和的基础上再套一层for循环,依然是使用双指针法。
练习
Hjk最多团队数量
用数组代表每个人的能力,一个比赛活动要求参赛团队的最低能力值为N,每个团队可以由1人或者2人组成,且1个人只能参加1个团队,计算出最多可以派出多少只符合要求的团队。
输入描述
第一行代表总人数,范围1-500000
第二行数组代表每个人的能力
数组大小,范围1-500000
元素取值,范围1-500000
第三行数值为团队要求的最低能力值,范围1-500000
输出描述
最多可以派出的团队数量
用例
输入 5
3 1 5 7 9
8
输出 3
说明 3、5组成一队 1、7一队 9自己一队 输出3
输入 7
3 1 5 7 9 2 6
8
输出 4
说明 3、5组成一队,1、7一队,9自己一队,2、6一队,输出4
输入 3
1 1 9
8
输出 1
说明 9自己一队,输出1
解题思路
对人员能力数组进行升序排序,以便后续处理。
使用两个指针 l 和 r 分别指向数组的开头和结尾。
首先处理单人组队的情况,即能力大于等于最低要求的人数统计出来。
然后进入双人组队的逻辑:当 l 小于 r 时,进行以下循环:
计算当前 l和 r 指向的人的能力之和 sum。
如果 sum 大于等于 minCap,则可以组成一个团队,团队数量加一,同时移动 l 和 r 指针。
如果 sum 小于 minCap,则需要将能力较低的人剔除,移动 l 指针。
最终返回团队数量作为结果。
#include <iostream>
#include <vector>
#include <algorithm>
int getteams(int& N, std::vector<int>& caps, int& target) {
int l = 0, r = N - 1;
std::sort(caps.begin(), caps.end());
int team = 0;
//单人组队
while(l <= r) {
if (caps[r] >= target) {
team ++;
}
else {
break;
}
r--;
}
//双人组队
while(l < r) {
if (caps[l] + caps[r] >= target) {
l++;
r--;
team ++;
}
else {
l++;
}
}
return team;
}
int main() {
int N;
std::cin >> N;
std::vector<int> caps(N, 0);
for (int i = 0; i < N; i++) {
std::cin >> caps[i];
}
int target;
std::cin >> target;
int res = getteams(N, caps, target);
std::cout << res << std::endl;
return 0;
}
Hjk数组连续和
给定一个含有N个正整数的数组, 求出有多少个连续区间(包括单个正整数), 它们的和大于等于x。
输入描述
第一行两个整数N x(0 < N <= 100000, 0 <= x <= 10000000)
第二行有N个正整数(每个正整数小于等于100)。
输出描述
输出一个整数,表示所求的个数。
注意:此题对效率有要求,暴力解法通过率不高,请考虑高效的实现方式。
用例
输入
3 7
3 4 7
输出 4
说明 第一行的3表示第二行数组输入3个数,第一行的7是比较数,用于判断连续数组是否大于该数;组合为 3 + 4; 3 + 4 + 7; 4 + 7; 7; 都大于等于指定的7;所以共四组。
输入
10 10000
1 2 3 4 5 6 7 8 9 10
输出 0
说明 所有元素的和小于10000,所以返回0。、
#include <iostream>
#include <vector>
int getRegionNum(std::vector<int>& nums, int& x) {
int left = 0;
int sum = 0;
int count = 0;
for (int right = 0; right < nums.size(); right ++) {
sum += nums[right];
while (sum >= x) {
count += (nums.size() - right);
sum -= nums[left];
left ++;
}
}
return count;
}
int main() {
int N, x;
std::cin >> N >> x;
std::vector<int> nums(N, 0);
for (int i = 0; i < N; i++) {
std::cin >> nums[i];
}
int res = getRegionNum(nums, x);
std::cout << res << std::endl;
return 0;
}
Hjk五子棋爱好者
题目
张兵和王武喜欢玩五子棋。现在轮到张兵了,他面前的棋盘上有一排棋子。
棋子规则:
-1 表示白子
0 表示没子,是个空位
1 表示黑子
一排棋子中,棋子数量L要满足:1 < L < 40,并且L是奇数。
你要写个程序帮张兵找到最佳的落子位置。怎么判断“最佳”呢?
找个空位(0)落子,使得这种颜色的棋子连在一起的数量最多。
如果有多个这样的空位,选中间的那个。
但是,连在一起的棋子数量不能超过5个。
输入:
第一行:当前要下的棋子颜色(1或-1)
第二行:当前棋盘上的棋子排列
输出:
一个数字,表示落子位置的下标(如果没有好位置,输出-1)
例如:
输入:
1
-1 0 1 1 1 0 1 -1 1
输出:
5
说明 当前为黑子(1),放置在下标为5的位置,黑子的最大连续长度,可以由3到5
示例2
-1
-1 0 1 1 1 0 1 0 1 -1 1
1
当前为白子,唯一可以放置的位置下标为1,白子的最大长度,由1变为2
示例3
1
0 0 0 0 1 0 0 0 0 1 0
5
可行的位置很多,5最接近中间的位置坐标
分析
维护两个指针来遍历棋盘,分别表示连续棋子的起始和结束位置。在遍历过程中,我们寻找可以放置新棋子的位置(即0的位置),并判断放置新棋子后能形成的最长连续同色棋子的长度。
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
int getindex(std::vector<int>& nums, int& color) {
int resindex = -1;
int longgestCommbo = 0;
int centerindex = nums.size() / 2;
for (int i = 0; i < nums.size(); i++) {
if (nums[i] == 0) {
int combo = 1;
int left = i - 1;
while (left >= 0 && nums[left] == color) {
combo += 1;
left --;
}
int right = i + 1;
while (right < nums.size() && nums[right] == color) {
combo += 1;
right ++;
}
//如果连起来大于5跳过
if (combo > 5) continue;
if (combo > longgestCommbo) {
resindex = i;
longgestCommbo = combo;
}
else if(combo == longgestCommbo && (std::abs(i - centerindex) < std::abs(resindex - centerindex))) {
resindex = i;
longgestCommbo = combo;
}
}
}
return resindex;
}
int main() {
int color;
std::cin >> color;
std::cin.ignore();
std::string cheses;
std::getline(std::cin, cheses);
std::stringstream ss(cheses);
std::vector<int> nums;
std::string token;
while (std::getline(ss, token,' ')) {
nums.push_back(std::stoi(token));
}
//测试用
// for (int i : nums) {
// std::cout << i << " ";
// }
int index = getindex(nums, color);
std::cout << index << std::endl;
return 0;
}
Hjk跳房子二
跳房子,也叫跳飞机,是一种世界性的儿童游戏。
游戏参与者需要分多个回合按顺序跳到第1格直到房子的最后一格,然后获得一次选房子的机会,直到所有房子被选完,房子最多的人获胜。
跳房子的过程中,如果有踩线等违规行为,会结束当前回合,甚至可能倒退几步。
假设房子的总格数是count,小红每回合可能连续跳的步数都放在数组steps中,请问数组中是否有一种步数的组合,可以让小红三个回合跳到最后一格?
如果有,请输出索引和最小的步数组合(数据保证索引和最小的步数组合是唯一的)。注意:数组中的步数可以重复,但数组中的元素不能重复使用。
输入描述
第一行输入为房子总格数count,它是int整数类型。
第二行输入为每回合可能连续跳的步数,它是int整数数组类型
输出描述
返回索引和最小的满足要求的步数组合(顺序保持steps中原有顺序)
备注
· count≤10000
· 3≤steps.length≤10000
·-100000≤steps[]≤100000
输入
[1,4,5,2,0,2]
9
输出
[4,5.0]
说明
无
示例2
输入
[1,5,2,0,2.4]
9
输出
[5,2,2]
说明
无
示例3
输入
[-1,2.4,9]
12
输出
[-1.4.9]
说明
无
本题是leetcode三数之和变种