华为OD_最小调整次数_C++版本

题目描述
【特异性双端队列 | 最小调整顺序次数】

给定一个队列，但是这个队列比较特殊，可以从头部添加数据，也可以从尾部添加数据，但是只能从头部删除数据。
输入一个数字n，会依次添加数字1~n（也就是添加n次）。
但是在添加数据的过程中，也会删除数据，要求删除必须按照1~n按照顺序进行删除，所以在删除时，可以根据需要调整队列中数字的顺序以满足删除条件。

输入描述

第一行一个数据n，表示数据的范围。
接下来的2n行，其中有n行为添加数据，指令为：
“​head add x” 表示从头部添加数据 x，
“​tail add x” 表示从尾部添加数据x，
另外 n 行为移出数据指令，指令为：“remove” 的形式，表示移出1个数据；
1 ≤ n ≤ 3 * 10^5。
所有的数据均合法。

输出描述

输出一个数字，表示最小的调整顺序次数。

补充说明

输入会保证按照1到n的顺序加入队列。确保输出时对应的数据已经在队列中

测试样例1

5
head add 1
tail add 2
remove
head add 3
tail add 4
head add 5
remove
remove
remove
remove

输出：

1

🧠 题目理解与思路
题目关键点总结：
有一个双端队列，但只能从头部移除（remove）。
插入操作可以是：
head add x：从头插入（影响 remove 顺序）；
tail add x：从尾插入（不影响 remove 顺序）。
所有加入的数字是 1~n，按顺序来；
所有 remove 的目标顺序是 1~n。

🚩 什么情况下需要调整？
如果我们当前队列本来是可以顺序 1, 2, 3… 地从头部移除，但突然你从“头部”又插进来一个元素（比如 head add 5），那原来的顺序就乱了。

所以我们需要：
用一个变量 isSorted 来判断队列当前是否是“有序的”；
初始为 true；
一旦出现 head add 并且队列不为空，就乱了 → isSorted = false；
当我们执行 remove：
如果是乱序状态，就需要 调整一次（count++）；
并把 isSorted 重置为 true；
最后输出最少的调整次数。

✅ C++ 函数封装版（含调试和注释）

#include <iostream>
#include <vector>
#include <string>

// 核心函数：接收操作列表和 n，返回最小调整次数
int minAdjustments(int n, const std::vector<std::string>& cmds, bool debug = false) {
    int size = 0;         // 当前队列中元素个数
    int count = 0;        // 最小调整次数
    bool isSorted = true; // 队列当前是否是有序的状态

    for (int i = 0; i < 2 * n; ++i) {
        const std::string& cmd = cmds[i];

        if (cmd.substr(0, 8) == "head add") {
            if (size > 0 && isSorted) {
                isSorted = false;
                if (debug) std::cout << "[Debug] head add 时打乱顺序\n";
            }
            ++size;
            if (debug) std::cout << "[Add Head] 当前 size: " << size << "\n";
        } else if (cmd.substr(0, 8) == "tail add") {
            ++size;
            if (debug) std::cout << "[Add Tail] 当前 size: " << size << "\n";
        } else if (cmd == "remove") {
            if (size > 0 && !isSorted) {
                ++count;
                isSorted = true;
                if (debug) std::cout << "[Remove 调整] 非顺序状态，调整 count = " << count << "\n";
            } else {
                if (debug) std::cout << "[Remove 正常] 当前 size: " << size << "\n";
            }
            --size;
        }
    }

    return count;
}
int main() {
    int n = 5;
    std::vector<std::string> cmds = {
        "head add 1",
        "tail add 2",
        "remove",
        "head add 3",
        "tail add 4",
        "head add 5",
        "remove",
        "remove",
        "remove",
        "remove"
    };

    int result = minAdjustments(n, cmds, true); // 开启 debug
    std::cout << "最小调整次数: " << result << std::endl;

    return 0;
}

🧾 输出解释

[Add Head] 当前 size: 1
[Add Tail] 当前 size: 2
[Remove 正常] 当前 size: 2
[Add Head] 当前 size: 2
[Add Tail] 当前 size: 3
[Debug] head add 时打乱顺序
[Add Head] 当前 size: 4
[Remove 调整] 非顺序状态，调整 count = 1
[Remove 正常] 当前 size: 3
[Remove 正常] 当前 size: 2
[Remove 正常] 当前 size: 1
最小调整次数: 1

OJ版：

#include <iostream>
#include <string>

int main() {
    int n;
    std::cin >> n;
    std::cin.ignore(); // 清除换行符

    int size = 0;         // 当前队列中元素个数
    int count = 0;        // 最小调整次数
    bool isSorted = true; // 队列是否是顺序状态

    std::string cmd;

    for (int i = 0; i < 2 * n; ++i) {
        std::getline(std::cin, cmd);
        
        if (cmd.substr(0, 8) == "head add") {
            if (size > 0 && isSorted) {
                isSorted = false;
            }
            ++size;
        } else if (cmd.substr(0, 8) == "tail add") {
            ++size;
        } else if (cmd == "remove") {
            if (size > 0 && !isSorted) {
                ++count;
                isSorted = true;
            }
            --size;
        }
    }

    std::cout << count << std::endl;
    return 0;
}

OJ封装版

#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::string;

// 高效处理函数：仅统计最少调整次数
int handleDeque(int n) {
    int count = 0;        // 需要的调整次数
    int size = 0;         // 当前队列中元素个数
    bool isSorted = true; // 队列是否保持从1到n的顺序状态

    for (int i = 0; i < 2 * n; ++i) {
        string line;
        std::getline(cin, line);
        if (line.empty()) { // 防止多余换行
            --i;
            continue;
        }

        if (line.substr(0, 8) == "head add") {
            if (size > 0 && isSorted) {
                isSorted = false; // 头插破坏顺序
            }
            ++size;
        }
        else if (line.substr(0, 8) == "tail add") {
            ++size; // 尾插不影响顺序
        }
        else if (line == "remove") {
            if (size > 0 && !isSorted) {
                ++count;       // 调整一次
                isSorted = true;
            }
            --size;
        }
    }

    return count;
}

int main() {
    int n;
    cin >> n;
    cin.ignore(); // 忽略第一行后的换行
    int result = handleDeque(n);
    cout << result << "\n";
    return 0;
}