【刷题总结与梳理】近期做题补充&二刷&输入输出整理

近期着重回顾已经做得题目，并且跟随笔试完成需要补习的内容。
主要是图、动态规划 和 企业重点题目 —— 二刷主动刷完 并 完成个人框架的形成。

引言

输入输出无论是在牛客网还是赛码中做题，都需要 自己进行处理。
其中，C++的输入 有时候需要吞并 回车。

1、吞回车： cin.get()

cin >> n;
cin.get();   // 吞了回车，因为下面要getline() 相当于用c的
while(n--){
    string inputs;
    // cin >> inputs >> ID >> POPIS;
    // getchar();
    getline(cin, inputs, '\n');
    // getchar();
    // cout << inputs << endl;
    if(inputs == "query"){
    }else{
       // append
        vector<string> appendStr = split(inputs, ' ');
        stringstream ssr1(appendStr[1]), ssr2(appendStr[2]);
        
        ll id, popIs;
        ssr1 >> id;
        ssr2 >> popIs;
        idMap[id] += popIs;
    }
}

2、全部C++，有几个算几个，直接输入。

cin >> n;
    while( n-- ){
        int z;
        char x1 , y;
        cin >> z >> x1 >> y;
       	...
    }

3、注意：cin 的输入原理分析

For(i, 1, n){
        int tmp;
        cin >> tmp;
        a[i] = tmp;
    }
    For(i, 1, n){
        int tmp;
        cin >> tmp;
        b[i] = tmp;
    }

0.0 cin输入原理

程序的输入都建有一个缓冲区，即输入缓冲区。一次输入过程是这样的，当一次键盘输入结束时会将输入的数据存入输入缓冲区，而cin函数直接从输入缓冲区中取数据。正因为cin函数是直接从缓冲区取数据的，所以有时候当缓冲区中有残留数据时，cin函数会直接取得这些残留数据而不会请求键盘输入。

注意：cin>>和cin.get()都残留数据不会出错，但是cin.getline会报错，下面的示例中都有体现。

0.1 cin>>

存储变量类型：char,int,string都可以；

输入结束条件：遇到Enter、Space和Tab键。【所以可以有上述 3、的一个个输入】

对结束符处理：丢弃缓冲区中使得输入结束的结束符（Enter、Space和Tab）。

0.2 cin.get()

2.1读取字符的情况

存储变量类型：char。

输入结束条件：Enter键（因此可接受空格和Tab键）。

对结束符处理：不丢弃缓冲区中的Enter。

使用方法：ch=cin.get() 或 cin.get(ch)。

0.3 cin.getline()

cin.getline(数组名，长度，结束符) 大体与 cin.get(数组名，长度，结束符)类似。
　　区别在于：
　　cin.get()当输入的字符串超长时，不会引起cin函数的错误，后面的cin操作会继续执行，只是直接从缓冲区中取数据。但是cin.getline()当输入超长时，会引起cin函数的错误，后面的cin操作将不再执行。

一、寻找两个正序数组中的中位数

1.1 题目

看似非常简单，却是Hard问题 —— 因为需要我们十分了解 中位数的含义。

1.2 解析

这道题让我们求两个有序数组的中位数，而且限制了时间复杂度为O(log (m+n))，看到这个时间复杂度，自然而然的想到了应该使用二分查找法来求解。

那么回顾一下中位数的定义，如果某个有序数组长度是奇数，那么其中位数就是最中间那个，如果是偶数，那么就是最中间两个数字的平均值。

这里对于两个有序数组也是一样的，假设两个有序数组的长度分别为m和n，由于两个数组长度之和 m+n 的奇偶不确定，因此需要分情况来讨论，对于奇数的情况，直接找到最中间的数即可，偶数的话需要求最中间两个数的平均值。为了简化代码，不分情况讨论，我们使用一个小trick，我们分别找第 (m+n+1) / 2 个，和 (m+n+2) / 2 个，然后求其平均值即可，这对奇偶数均适用。加入 m+n 为奇数的话，那么其实 (m+n+1) / 2 和 (m+n+2) / 2 的值相等，相当于两个相同的数字相加再除以2，还是其本身。

这里我们需要定义一个函数来在两个有序数组中找到第K个元素(即递归 找中位数——分割(cut))，下面重点来看如何实现找到第K个元素。

1. 首先，为了避免产生新的数组从而增加时间复杂度，我们使用两个变量i和j分别来标记数组nums1和nums2的起始位置。然后来处理一些边界问题，比如当某一个数组的起始位置大于等于其数组长度时，说明其所有数字均已经被淘汰了，相当于一个空数组了，那么实际上就变成了在另一个数组中找数字，直接就可以找出来了。
2. 还有就是如果K=1的话，那么我们只要比较nums1和nums2的起始位置i和j上的数字就可以了。
3. 难点就在于 一般的情况怎么处理？ 因为我们需要在两个有序数组中找到第K个元素，为了加快搜索的速度，我们要使用二分法，对K二分，意思是我们需要分别在nums1和nums2中查找第K/2个元素，(注意这里由于两个数组的长度不定，所以有可能某个数组没有第K/2个数字，所以我们需要先检查一下，数组中到底存不存在第K/2个数字，)如果存在就取出来，否则就赋值上一个整型最大值。如果某个数组没有第K/2个数字，那么我们就淘汰另一个数字的前K/2个数字即可。（所以 设置了最大值！）【有没有可能两个数组都不存在第K/2个数字呢，这道题里是不可能的，因为我们的K不是任意给的，而是给的m+n的中间值，所以必定至少会有一个数组是存在第K/2个数字的。】
4. 最后就是二分法的核心啦，比较这两个数组的第K/2对应的数字midVal1和midVal2的大小，如果第一个数组的第K/2个数字小的话，那么说明我们要找的数字肯定不在nums1中的前K/2个数字，所以我们可以将其淘汰，将nums1的起始位置向后移动K/2个，并且此时的K也自减去K/2，调用递归。反之，我们淘汰nums2中的前K/2个数字，并将nums2的起始位置向后移动K/2个，并且此时的K也自减去K/2，调用递归即可。

私以为：关键在于 不断地递归/二分法；拆解掉小的一遍数组——直至当前达到两边 cut的下界（即：k==1）或者一边为空，则 对应base case直接返回。
单支 递归——没有其他支子，所以直接 回到题解。

C++题解：

class Solution {
  public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int left = (m + n + 1) / 2;
        int right = (m + n + 2) / 2;
        return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
    }
    //i: nums1的起始位置 j: nums2的起始位置
    public int findKth(int[] nums1, int i, int[] nums2, int j, int k){
        if( i >= nums1.length) return nums2[j + k - 1];//nums1为空数组
        if( j >= nums2.length) return nums1[i + k - 1];//nums2为空数组
        if(k == 1){
            return Math.min(nums1[i], nums2[j]);
        }
        int midVal1 = (i + k / 2 - 1 < nums1.length) ? nums1[i + k / 2 - 1] : Integer.MAX_VALUE;
        int midVal2 = (j + k / 2 - 1 < nums2.length) ? nums2[j + k / 2 - 1] : Integer.MAX_VALUE;
        if(midVal1 < midVal2){
            return findKth(nums1, i + k / 2, nums2, j , k - k / 2);
        }else{
            return findKth(nums1, i, nums2, j + k / 2 , k - k / 2);
        }        
    }
}

二、图逻辑实现&遍历&应用

参考 dong哥公众号，反思重点笔记如下。

本质上图可以认为是多叉树的延伸。

面试笔试很少出现图相关的问题，就算有，大多也是简单的遍历问题，基本上可以完全照搬多叉树的遍历。

至于最小生成树，Dijkstra，网络流这些算法问题，他们当然很牛逼，但是，就算法笔试来说，学习的成本高但收益低，没什么性价比，不如多刷几道动态规划，真的。

那么，本文依然秉持我们号的风格，只讲「图」最实用的，离我们最近的部分，让你心里对图有个直观的认识。

2.1 图的逻辑结构和具体实现

一幅图是由节点和边构成的，逻辑结构如下：

什么叫「逻辑结构」？就是说为了方便研究，我们把图抽象成这个样子。

根据这个逻辑结构，我们可以认为每个节点的实现如下：

/* 图节点的逻辑结构 */
class Vertex {
    int id;
    Vertex[] neighbors;
}

看到这个实现，你有没有很熟悉？它和我们之前说的多叉树节点几乎完全一样：

/* 基本的 N 叉树节点 */
class TreeNode {
    int val;
    TreeNode[] children;
}

所以说，图真的没啥高深的，就是高级点的多叉树而已。

不过呢，上面的这种实现是「逻辑上的」，实际上我们很少用这个Vertex类实现图，而是用常说的邻接表和邻接矩阵来实现。

比如还是刚才那幅图：

用邻接表和邻接矩阵的存储方式如下：

邻接表很直观，我把每个节点x的邻居都存到一个列表里，然后把x和这个列表关联起来，这样就可以通过一个节点x找到它的所有相邻节点。

typedef struct ArcNode{
    ArcNode(int a, int w) :adjvex(a), weight(w), nextarc(NULL){}
    ArcNode() :nextarc(NULL){}
    int adjvex;               //该弧所指向的顶点的位置
    int weight;               //该弧相关的权值信息
    ArcNode *nextarc;         //指向下一条弧的指针
}ArcNode;

typedef struct VNode{
    VNode() :date(0), firstarc(NULL){}
    int date;                 //顶点信息
    ArcNode *firstarc;        //指向第一条依附该顶点的弧的指针
}VNode,AdjList[MAX_VERTEX_NUM];

邻接矩阵则是一个二维布尔数组，我们权且成为matrix，如果节点x和y是相连的，那么就把matrix[x][y]设为true。如果想找节点x的邻居，去扫一圈matrix[x][…]就行了。

如果连接无向图中的节点x和y，把matrix[x][y]和matrix[y][x]都变成true不就行了；邻接表也是类似的操作。

下面来看看所有数据结构都逃不过的问题：遍历。

2.2 图的遍历

图怎么遍历？还是那句话，参考多叉树，多叉树的遍历框架如下：

/* 多叉树遍历框架 */
void traverse(TreeNode root) {
    if (root == null) return;

    for (TreeNode child : root.children)
        traverse(child);
}

图和多叉树最大的区别是，图是可能包含环的，你从图的某一个节点开始遍历，有可能走了一圈又回到这个节点。

所以，如果图包含环，遍历框架就要一个visited数组进行辅助：

Graph graph;
boolean[] visited;

/* 图遍历框架 */
void traverse(Graph graph, int s) {
    if (visited[s]) return;
    // 经过节点 s
    visited[s] = true;
    for (TreeNode neighbor : graph.neighbors(s))
        traverse(neighbor);
    // 离开节点 s
    visited[s] = false;   
}

好吧，看到这个框架，你是不是又想到了 回溯算法核心套路 中的回溯算法框架？

这个visited数组的操作很像回溯算法做「做选择」和「撤销选择」，区别在于位置，回溯算法的「做选择」和「撤销选择」在 for 循环里面，而对visited数组的操作在 for 循环外面。

在 for 循环里面和外面唯一的区别就是对根节点的处理。

比如下面两种多叉树的遍历：

void traverse(TreeNode root) {
    if (root == null) return;
    System.out.println("enter: " + root.val);
    for (TreeNode child : root.children) {
        traverse(child);
    }
    System.out.println("leave: " + root.val);
}

void traverse(TreeNode root) {
    if (root == null) return;
    for (TreeNode child : root.children) {
        System.out.println("enter: " + child.val);
        traverse(child);
        System.out.println("leave: " + child.val);
    }
}

前者会正确打印所有节点的进入和离开信息，而后者唯独会少打印整棵树根节点的进入和离开信息。

【注意这里】 关键区别之处——开悟.

为什么回溯算法框架会用后者？因为回溯算法关注的不是节点，而是树枝，不信你看 回溯算法核心套路 里面的图，它可以忽略根节点。

显然，对于这里「图」的遍历，我们应该把visited的操作放到 for 循环外面，否则会漏掉起始点的遍历。

当然，当有向图含有环的时候才需要visited数组辅助，如果不含环，连visited数组都省了，基本就是多叉树的遍历。

2.3 题目实践

下面我们来看力扣第 797 题「所有可能路径」，函数签名如下：

List<List<Integer>> allPathsSourceTarget(int[][] graph);

解法很简单，以0为起点遍历图，同时记录遍历过的路径，当遍历到终点时将路径记录下来即可。

既然输入的图是无环的，我们就不需要visited数组辅助了，直接套用图的遍历框架：

// 记录所有路径
List<List<Integer>> res = new LinkedList<>();

public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
    LinkedList<Integer> path = new LinkedList<>();
    traverse(graph, 0, path);
    return res;
}

/* 图的遍历框架 */
void traverse(int[][] graph, int s, LinkedList<Integer> path) {

    // 添加节点 s 到路径
    path.addLast(s);

    int n = graph.length;
    if (s == n - 1) {
        // 到达终点
        res.add(new LinkedList<>(path));
        path.removeLast();
        return;
    }

    // 递归每个相邻节点
    for (int v : graph[s]) {
        traverse(graph, v, path);
    }

    // 从路径移出节点 s
    path.removeLast();
}

这道题就这样解决了。
关键我的题解&感悟 见代码：
使用的 邻接表+查找深搜回溯 寻找单源路径方法.

/**
 * @Description: 注意 不用visited了，因为可以重复访问 —— 就是一个回溯！
 * @param {*}
 * @return {*}
 * @notes: 
 */
class Solution {
public:
    /**
     * @Description: 使用深度优先搜索  查找所能到达的节点。
     * @param {*}
     * @return {*}
     * @notes: 
     */
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        vector<vector<int>> res;
        vector<int> tmp;
        dfs(graph, res, tmp, 0);
        return res;
    }
	 // 图、结果记录、路径、当前节点
    void dfs(vector<vector<int>>& graph, vector<vector<int>>& res, vector<int> &tmp, int s){
        // visited[s] = true;
        tmp.push_back(s);
        if( s== (graph.size()-1)){
            res.push_back(tmp);
            // visited[s] = false;// 离开当前节点
            tmp.pop_back();
            return ;            
        }

        // neighbors visited
        for(int vertex: graph[s]){
            dfs(graph, res, tmp, vertex);
                // visited[vertex] = false;// 返回
                // tmp.pop_back();
            
        }

        // visited[s] = false;// 离开当前节点
        tmp.pop_back();
    }
};

最后总结一下，图的存储方式主要有邻接表和邻接矩阵，无论什么花里胡哨的图，都可以用这两种方式存储。

在笔试中，最常考的算法是图的遍历，和多叉树的遍历框架是非常类似的。

下面关于 图的应用和 DFS/BFS等不再赘述 —— 只需要了解和知道 大体过程；
且 看一看A4纸上的框架。

三、常考算法题

3.1 旋转数组

题目：

题解：

对应三种不同方法 + 原地O(1) 复杂度翻转.
着重注意： 第二种 —— 翻转方法 旋转数组.

import java.util.Arrays;

class Solution {
    /**
     * 双重循环
     * 时间复杂度：O(kn)
     * 空间复杂度：O(1)
     */
    public void rotate_1(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        for (int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for (int j = n - 1; j > 0; j--) {
                nums[j] = nums[j - 1];
            }
            nums[0] = temp;
        }
    }

    /**
     * 翻转
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_2(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        reverse(nums, 0, n - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, n - 1);
    }


    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }

    /**
     * 循环交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(1)
     */
    public void rotate_3(int[] nums, int k) {
        int n = nums.length;
        k %= n;
        // 第一次交换完毕后，前 k 位数字位置正确，后 n-k 位数字中最后 k 位数字顺序错误，继续交换
        for (int start = 0; start < nums.length && k != 0; n -= k, start += k, k %= n) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
        }
    }

    /**
     * 递归交换
     * 时间复杂度：O(n)
     * 空间复杂度：O(n/k)
     */
    public void rotate(int[] nums, int k) {
        // 原理同上
        recursiveSwap(nums, k, 0, nums.length);
    }

    private void recursiveSwap(int[] nums, int k, int start, int length) {
        k %= length;
        if (k != 0) {
            for (int i = 0; i < k; i++) {
                swap(nums, start + i, nums.length - k + i);
            }
            recursiveSwap(nums, k, start + k, length - k);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

3.2 寻旋转数组中最小值

题目

题解

class Solution {
public:
    /**
     * @Description: 注意 二分查找，但又不完全是 —— 不要被框架约束；细节不同的！要针对 题意具体分析!
     * @param {*}
     * @return {*}
     * @notes: 
     */
    int findMin(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = (r - l) / 2 + l;
            if (nums[mid] < nums[r]) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return nums[l];
    }
};

3.3 寻找旋转数组最小值II(可重复)

我的题解：

//方法一：
class Solution {
public:
    /**
     * @Description: 使用二分搜索 左侧边界——有重复但是 可以发现最小值
     * @param {*}
     * @return {*}
     * @notes: 注意  选择左侧边界，且不区分 target而只是寻找
     */
    int findMin(vector<int>& nums) {
        int n = nums.size();
        int left=0, right=n-1;
        while( left < right ){ // 左闭右闭
            int mid = (right-left)/2 + left;
            if(nums[mid] < nums[right]){
                right = mid;
            }else if(nums[mid] == nums[right]){
                // 循环到不重复 看有无数值
                int tmp = mid;
                while(nums[mid] == nums[right] && mid<right){
                    mid++;
                }
                if(nums[mid] < nums[right]){
                    left = mid;
                }else if(nums[mid] > nums[right]){ // ==
                    return nums[right];
                }else{
                    // ==
                    right = tmp;
                }
            }else{
                left = mid+1;
            }
        }
        return nums[left];
    }
};



//方法二：
class Solution {
public:
    /**
     * @Description: 使用二分搜索  相比于没有重复，添加 == 时：right--;
     * @param {*}
     * @return {*}
     * @notes: 注意  选择左侧边界，且不区分 target而只是寻找
     */
    int findMin(vector<int>& nums) {
        int n = nums.size();
        int left=0, right=n-1;
        while( left < right ){ // 左闭右闭
            int mid = (right-left)/2 + left;
            if(nums[mid] < nums[right]){
                right = mid;
            }else if(nums[mid] > nums[right]){
                // 循环到不重复 看有无数值
                left = mid + 1;
            }else{ // ==
                right -= 1;
            }
        }
        return nums[left];
    }
};

精髓在方法二：最后一个判定 ；多了 ‘==’ 时。
方法一：测试用例思考：① [2,2,3,3,3] ② [3,3,3,1,3]

3.4 搜索旋转数组（二分搜索 细节的神！）

解析：
思路和算法

对于有序数组，可以使用二分查找的方法查找元素。

但是这道题中，数组本身不是有序的，进行旋转后只保证了数组的局部是有序的，这还能进行二分查找吗？答案是可以的。

可以发现的是，我们将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的。拿示例来看，我们从 6 这个位置分开以后数组变成了 [4, 5, 6] 和 [7, 0, 1, 2] 两个部分，其中左边 [4, 5, 6] 这个部分的数组是有序的，其他也是如此。

这启示我们可以在常规二分查找的时候查看当前 mid 为分割位置分割出来的两个部分 [l, mid] 和 [mid + 1, r] 哪个部分是有序的，并根据有序的那个部分确定我们该如何改变二分查找的上下界，因为我们能够根据有序的那部分判断出 target 在不在这个部分：

• 如果 [l, mid - 1] 是有序数组，且 target 的大小满足【[nums[l],nums[mid]） 一定注意这里等号加不加的细节！，则我们应该将搜索范围缩小至 [l, mid - 1]，否则在 [mid + 1, r] 中寻找。
• 如果 [mid, r] 是有序数组，且 target 的大小满足（nums[mid+1],nums[r]】 一定注意这里等号加不加的细节！，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在 [l, mid - 1] 中寻找。

我的题解：

class Solution {
public:
    /**
     * @Description: 不是寻找最小而是对应  target了！还好不重复 —— 这样也可以像是有序似的进行做题。
     * @param {int} target
     * @return {*}
     * @notes: 关键：因为旋转数组只在一侧有序。查找 target看在有序的那一侧——缩小距离
     *              【怎样判断有序一侧 —— 因为旋转数组 只在一个位置开始前后断层，所以二分就好了。必定有一侧有序。】
     *              太细节了！！！注意千万 别死循环了！！！ 等号加不加注意看！！！
     */
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int l = 0, r=n-1;
        while(l<=r){  // 
            int m = (r-l)/2 + l;
            if(nums[m] == target){
                return m;
            }
            if(nums[m] >= nums[l]){   //等号
                // 左边有序
                if(target >= nums[l] && target < nums[m]) {
                    r=m-1;   // 注意上面必须 无等号，才能使这里 -1;才能不无限循环。
                }else{
                    l=m+1;
                }

            }else{ // 右边有序
                if(target > nums[m] && target <= nums[r]) {
                    l=m+1;   // 注意上面必须 无等号，才能使这里 -1;才能不无限循环。
                }else{
                    r=m-1;
                }
            }
        }
        return -1;
    }   
};