双指针2s总结

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 其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

1. 不用申请新数组。
2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

链表篇

翻转链表是现场面试，白纸写代码的好题，考察了候选者对链表以及指针的熟悉程度，而且代码也不长，适合在白纸上写。

在链表：听说过两天反转链表又写不出来了？ (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(n^{2)，但比哈希法的O(n}2)效率高得多，哈希法在使用两层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三数之和变种