<think>好的，我现在需要帮用户分析他提供的
C++代码为什么在洛谷题目P3522上只得了48分。首先，我得仔细阅读题目和代码，理解他的思路。用户的问题是关于他的代码在提交后只有48分，说明部分测试用例没通过。他提到使用了两个单调队列，一个维护最低温度的最大值，另一个维护最高温度的最小值。当窗口内的最低温度最大值大于等于最高温度的最小值时，认为存在非降序列，否则移动左指针。时间复杂度是O(n)。
首先，我需要理解题目要求。题目要求找出最长的连续子序列，使得在这个子序列中存在至少一天，其最低温度不小于当天的最高温度。或者可能题目要求的是整个子序列中存在某个位置i，满足该位置的最低温度≥该位置的最高温度？或者可能是子序列中所有位置的最低温度都不超过某个条件？需要仔细看原题描述。
根据题目链接P3522，我需要先确认题目内容。假设题目大意是：给定n天的温度范围（每天的最低和最高温度），我们需要找到最长的连续天数区间，使得在这个区间内存在至少一天，其最低温度不低于另一天的最高温度？或者可能更具体的条件？
可能用户对题意的理解有误。比如，题目中的条件是，在子序列中，存在至少一个i，使得t[i]
.first >=t[j]
.second，其中j是在i之前的位置？或者可能题目要求在整个子序列中，至少有一个位置的最低温度不小于该位置的最高温度？这会影响算法的正确性。
用户的思路是维护两个单调队列，left队列记录窗口内的最低温度的最大值，right队列记录最高温度的最小值。当left队列的最大值>=right队列的最小值时，说明当前窗口内存在满足条件的区间。但这里可能存在逻辑错误。
比如，当left队列的最大值大于等于right队列的最小值时，可能意味着存在某一天的最低温度大于等于另一天的最高温度，而不是同一位置。而题目可能需要的是存在至少一天的最低温度≥该天的最高温度？如果是这样的话，用户的思路是错误的，因为他的方法可能检测的是不同天之间的比较。
比如，用户的代码中，l队列保存的是窗口内各天的最低温度的最大值，r队列保存的是窗口内各天的最高温度的最小值。当这个最大值>=最小值时，可能窗口中存在某一天的最低温度很大，另一天的最高温度很小，从而满足条件。但题目可能需要的是存在某一天自身的最低温度≥自己的最高温度，也就是t[i]
.first>= t[i]
.second，此时用户的思路是错误的，因为他的条件可能将不同天的低和高组合起来判断。这可能就是问题所在。用户的算法逻辑可能没有正确对应题目要求。例如，当某一天的最低温度>=另一天的最高温度时，可能满足条件，但题目要求的是必须同一天的情况。或者题目可能有不同的条件。
因此，我需要先重新确认题目。假设题目P3522的要求是：在连续的子序列中，必须存在至少一天的最低温度≥该天的最高温度。那么用户的思路是错误的，因为他的算法检测的是窗口内的最低温度的最大值是否大于等于窗口内的最高温度的最小值，这可能对应不同的天。例如，当某一天的最低温度很高（比如最大值是A天的low），而另一天的最高温度很低（比如最小值是B天的high，其中A≠B）。此时用户的条件成立，但题目要求的条件可能并不成立，因为需要存在某一天，其low >= high当天的情况。
所以，这可能就是用户代码错误的原因。也就是说，用户的算法逻辑与题目要求不符。正确的做法应该是，在窗口内是否存在至少一个i使得t[i]
.first >= t[i]
.second。这样，最长子序列的长度应该基于这样的条件。
那用户的问题可能出在这里：他的算法试图寻找的是窗口中的low的最大值和high的最小值之间的关系，而题目需要的是是否存在某一天自己的low和high的关系。
所以，这种情况下，用户的解法是错误，导致部分测试用例失败。
那如何修正呢？正确的思路可能需要找出最长的区间，使得在该区间内至少存在一个i满足t[i]
.first >=t[i]
.second。这种情况下，问题转化为寻找最长的区间，其中包含至少一个有效点（满足条件的i），而这样的区间可能通过滑动窗口或者双指针扩展。
在这种情况下，正确的做法是：当窗口内存在至少一个有效点时，可以扩展右指针；如果没有的话，需要移动左指针。此时，维护两个单调队列可能不是必要的，而是需要记录当前窗口是否有有效的点。例如，可以预处理所有有效点的位置，然后对于每个右端点，找到最左的左端点，使得区间包含至少一个有效点，并且尽可能长。
或者，当存在有效点的时候，整个数组中最大的区间可能包含该点，此时最大长度可能为max(以每个有效点为中心的最大区间长度)。
但可能更简单的做法是，维护一个滑动窗口，其中至少包含一个有效点。此时，当窗口包含至少一个有效点时，记录当前窗口的长度，并尝试扩展右指针。否则，移动左指针。
但如何高效判断窗口内是否存在有效点呢？这可能需要一个数据结构来维护窗口中的有效点的数量。例如，使用一个哈希表或计数器，每当窗口移动时更新有效点的数量。
在这种情况下，使用双指针法，维护一个滑动窗口，其中只要窗口中存在至少一个有效点，就尝试扩展右边界；否则，移动左边界。但是，这可能无法得到最大的窗口长度，因为可能存在多个有效点的情况。或者，正确的滑动窗口策略需要仔细设计。
例如，当窗口中没有有效点时，必须移动左指针；否则，可以扩展右指针。或者，这可能不是正确的策略，需要进一步分析。
回到原题，假设用户误解了题意，导致算法逻辑错误。例如，正确的条件应该是存在某一天的low[i] >= high[i]，而用户的算法检查的是窗口中最大的low和最小的high之间的关系。此时，用户的条件与题目要求无关，导致答案错误。在这种情况下，用户的代码无法正确判断样例情况。例如，假设有一个测试用例：3天的数据：low high
12 →
1<2，无效点
2
1 →有效点（2>=
1）
34 →无效点
此时，最长子序列长度为3，因为包含中间的有效点。但用户的算法中，当窗口为整个数组时，最大的low是3（第三个天的low=3），最小的high是
1（第二个天的high=
1）。此时，3>=
1，条件成立，窗口长度为3，正确。然而，这似乎在这种情况下是正确的？这时候，用户的算法是否正确？此时，他的条件是否满足？
或者，在用户的代码中，当窗口包含有效点时，条件是否成立？
例如，假设窗口中存在某一天的low[i] >=high[i]，那么此时窗口的最大low至少是low[i]，最小high至多是high[i]。此时，max_low>= min_high，因为low[i]>= high[i]。所以，当窗口中存在有效点时，用户的条件成立。反之，如果用户的条件成立，即max_low >= min_high，那么可能存在i,j使得low[i] >= min_high（但min_high是窗口中的最小high，可能high[j]是更小的，而i可能不是同一个）。所以，这可能导致用户的条件比题目要求的更强，或者更宽泛。例如，可能存在max_low >=min_high的情况下，但所有i都有low[i] <high[i]。例如：
假设窗口中有两天的数据：low分别为3和4，high分别为5和2。此时，low的最大值是4，high的最小值是2。4>=2，用户的条件成立。但每个i对应的low[i]和high[i]分别是3<5，4>2。此时，i=
1的天满足条件low>=high。所以此时条件成立，而用户的条件正确。这说明，当用户的条件成立时，可能存在至少一个有效点。或者是否一定存在？
或者，是否存在反例？例如，是否存在窗口中的max_low >=min_high，但所有天的low[i] < high[i]？
假设存在这样的窗口：比如，有两天的数据：
low分别为3和
1，high分别为4和2
.
max_low是3，min_high是2。3>=2。此时用户的条件成立，但是第一天low=3 < high=4；第二天low=
1 <high=2。此时，所有天的low都小于high，所以题目要求的条件不成立。所以用户的条件在这种情况下会错误地认为该窗口满足条件，导致错误。
这说明用户的算法逻辑是错误的，因为存在反例，其中用户的条件成立但题目要求的条件不成立。因此，用户的代码无法正确处理这种情况，导致部分测试用例失败。
所以，用户的核心错误在于将问题转换为两个单调队列的最大最小值之间的关系，而正确的做法是必须确保窗口中存在至少一个i满足low[i] >= high[i]。
因此，用户的算法逻辑需要完全改变。原来的思路无法正确解决问题，因为条件错误。
现在，用户的问题是如何修改代码以正确解决问题。正确的思路应该是：寻找最长的连续子序列，其中至少包含一个i满足low[i]>= high[i]。因此，对于这样的问题，可以维护一个滑动窗口，当窗口中存在至少一个这样的i时，记录窗口长度。否则，移动窗口。
为了高效实现，可以使用双指针法。例如，用右指针不断扩展窗口，当发现有效点时，记录窗口的可能扩展。或者，维护一个窗口，其中包含有效点的情况下尽可能扩展窗口。
但如何高效判断窗口中是否存在有效点？可以使用一个变量来记录当前窗口内有效点的数量。如果存在至少一个有效点，则可以扩展窗口并记录长度。否则，移动左指针。
具体来说，可以遍历数组，同时维护一个左指针，以及一个计数器cnt，记录当前窗口内有效点的数量。当cnt>0时，窗口有效，可以尝试扩展右指针，并记录窗口的最大长度。如果cnt=0，需要移动右指针直到遇到有效点或者窗口为空。
或者，可能需要更灵活的策略。例如，当右指针到达一个有效点时，此时窗口可能扩展到最大。这可能需要更详细的处理。
例如，滑动窗口的正确做法可能是：
初始化左指针为0，最大长度为0。然后遍历每个右指针的位置，如果当前窗口中没有有效点，则移动左指针到右指针的位置+
1，并继续。但这样的逻辑可能需要重新思考。
或者，这可能不是最优的做法。另一种思路是，所有有效点的位置将整个数组分割成若干段，我们需要找到相邻两个有效点之间的最大区间，其中最长子数组至少包含一个有效点。这可能比较复杂。
但更简单的方法可能是，维护一个窗口，其中包含至少一个有效点。此时，窗口的最大长度取决于左右指针的移动。例如，使用双指针法，每次右指针向右移动，如果遇到有效点，则记录当前窗口的可能最大长度。否则，当窗口内没有有效点时，左指针必须移动到当前右指针的位置+
1。
但如何维护窗口内的有效点数量？
可以维护一个cnt变量，统计当前窗口内有效点的个数。初始时左指针为0，cnt=0，最大长度0。对于每个右指针i：
如果当前元素是有效点（low[i] >=high[i]），则cnt +=
1.
然后，当cnt>0时，当前窗口有效，可以计算窗口长度i - left+
1，并更新最大值。此时，可能不需要移动左指针，除非我们想缩小窗口以寻找更长的可能。或者，当cnt>0时，我们可以记录当前窗口的长度，并尝试移动左指针以找到更小的窗口，但这可能不影响最大长度。这可能更适合的情况是，我们需要找到满足条件的最小窗口，但这里需要最大窗口。
正确的做法是，只要窗口中有至少一个有效点，那么窗口的大小可以扩展。因此，正确的策略是：当窗口中没有有效点时，必须移动左指针到右指针的位置+
1。否则，可以继续扩展右指针，并记录最大长度。或者，这可能需要更详细的分析。
例如，每当发现一个有效点，那么此时窗口的长度至少为
1，可以更新最大值。然后，我们可能希望扩展窗口的左右边界，以包含更多的元素，同时保持窗口中至少有一个有效点。例如，当窗口中的左边元素是无效的，可以移除它们，以保持窗口尽可能短，但这可能对求最大长度无益。
正确的做法可能是：遍历数组，当遇到有效点时，立即记录该点作为可能的最长窗口的中心，然后尽可能扩展左右边界直到遇到无效点。这种方法的时间复杂度是O(n)吗？
或者，可以预处理所有有效点的位置，然后对于每个有效点，找到其左右连续可以扩展的范围，使得这些范围内的元素构成的子数组包含该有效点。最长的这样的范围即为答案。这可能可行。例如，最长子数组必须包含至少一个有效点，所以答案等于整个数组的长度（如果存在至少一个有效点），或者当数组中没有有效点时，返回0。这可能不正确，例如，当中间有一个有效点，但整个数组的长度可能正确。比如，如果存在至少一个有效点，则最长可能长度为n。所以，正确的答案是否是：如果有至少一个有效点，那么答案至少是
1。而最长可能的连续子序列就是整个数组，只要其中存在至少一个有效点。否则，答案是0？
这显然不可能，因为题目给出的样例可能更复杂。例如，假设题目中的样例输入可能有多个有效点，而最长子序列可能跨越多个有效点。或者，这可能取决于题意的理解是否正确。但根据之前的反例，如果用户的条件与题目要求不符，那么正确的做法是重新调整思路。
假设题目要求的是连续子序列中存在至少一天的low[i] >= high[i]，那么最长子序列的长度就是整个数组的长度，只要其中存在至少一个这样的i。例如，如果有至少一个这样的i，那么答案就是n，否则0。这显然不对，例如样例中的情况可能不是这样。
这说明我的理解可能仍有错误。因此，必须重新查看题目描述。
题目P3522的原题链接可能无法访问，但根据常见的题目描述，可能原题是POJ或者洛谷的题目。假设题目大意是：给定n天的温度区间（low[i],high[i]），我们需要找出最长的连续天数区间[L, R]，使得在该区间内存在至少一天的某一天（比如第k天，L<=k<=R），使得low[k]>= high[k]。或者，可能题目要求在区间[L, R]中存在某一天k，使得low[k] >= high[j]，其中j在L到R之间？或者题目可能有其他条件？
或者，原题可能是P
OI的题目，可能条件更复杂。例如，题目可能是：要求在序列中找到最长的区间，使得对于该区间存在一个温度序列t，满足t是非递减的，并且每个t[i]在对应的low[i]和high[i]之间（即 low[i]<= t[i]<= high[i]）。这可能才是原题的条件。这可能才是用户代码试图解决的问题。
用户提供的代码注释中提到“当前窗口内存在一段非降序列”，这说明题目可能与构造一个非递减序列有关。例如，题目可能要求找出最长的连续区间，使得在该区间内可以构造一个非递减序列，每个元素t[i]位于对应的[low[i], high[i]]区间内，并且t[i] <= t[i+
1]。在这种情况下，用户的解法可能涉及两个单调队列，分别维护当前窗口下的可能的最高温度的最小值和最低温度的最大值，从而判断是否存在这样的非递减序列。这种情况下，用户代码的逻辑可能正确，但实现存在错误。例如，用户可能在维护单调队列时，或者在移动窗口指针时犯了错误。
此时，我需要重新理解题目。根据用户提供的注释和代码，原题可能要求找出最长的连续天数区间，使得可以从中选出一个非递减的序列t，其中每个t[i]满足low[i] <= t[i] <= high[i]。在这种情况下，判断是否存在这样的非递减序列的条件可能转化为：在某个窗口内，最低温度的最大值不超过最高温度的最小值。或者可能其他条件？
例如，当窗口中的每个位置i，其low[i]<= high[j]对于某些j的条件？或者，根据单调队列的维护方式，用户可能参考了相关的算法题解，例如，正确的条件可能是：在某个窗口内，low的最大值序列的某个递增情况与high的最小值序列的关系。
例如，正确的条件可能是，在窗口中的每个i，low[i] <=high[i]，并且low[i]<= high[i+
1]等条件。这可能比较复杂。
或者，正确的判断条件可能是在某个窗口中，存在一个非递减序列t，使得每个t[i] ∈ [low[i], high[i]]。这可以通过维护两个队列：在窗口内的每个位置i，可能的最小t[i]和最大t[i]，以确保这些范围之间存在可能的非递减序列。
例如，对于每个i，可能的最小t[i]是high的最小值，可能的max是low的最大值？这可能需要更深入的分析。此时，可能用户参考的解法是正确的，但代码实现存在错误。
在这种情况下，需要分析用户的代码是否存在实现错误。例如，单调队列的维护是否正确，指针移动的条件是否正确。
用户代码中的两个队列：
l队列维护的是单调递减的队列，保存的是最低温度的最大值。例如，每个元素是i和t[i]
.first（low[i]），当新元素的low[i]大于等于队列尾部的元素的low值时，弹出尾部元素。这样，队列中保存的元素是递减的，队首是当前窗口中low的最大值。
r队列维护的是单调递增的队列，保存的是最高温度的最小值。每个元素是i和high[i]，当新元素的high[i]小于等于队列尾部元素的high值时，弹出尾部，这样队列递增，队首是最小值。
当窗口的low的最大值大于等于high的最小值时，说明存在i,j，使得low[i] >= high[j]。此时，无法构造非递减序列，因为对于i到j的位置，可能存在无法满足t<=t[j]的情况。或者，这可能与题目条件相关，需要更详细的算法分析。
例如，正确的条件可能是在某个窗口中，low的最大值<= high的最小值。此时，可以构造一个全为high的最小值的序列，这样每个low[i] <= high_min<= high[i]，并且序列是常数，非递减。因此，此时窗口有效。因此，正确的判断条件应为low的最大值 <=high的最小值。此时，用户的代码中的判断条件是while循环条件中的low的最大值> high的最小值，此时窗口无效，需要移动左指针。这可能正确。哦，用户的代码中的while循环条件是：当l和r队列不为空，并且l
.front()
.second> r
.front()
.second。此时，当前窗口的low最大值大于high的最小值，无法满足存在非递减序列的条件，因此需要移动左指针。这可能正确。
所以，用户的算法思路是正确的。此时，为什么会出现错误？
此时，可能用户的代码存在实现错误，比如指针移动的处理方式不正确，或者队列维护错误。在用户的代码中，当条件不满足时，移动左指针到id的位置，其中id被设置为max(左前指针+
1，右前指针+
1）？这部分的处理可能有问题。
具体来说，当窗口的low_max >high_min时，用户执行：
id= max(id,min(l
.front()
.first+
1,r
.front()
.first+
1));
然后，如果队列中的头部元素的索引小于id，就弹出队列。
这部分的逻辑可能不正确。例如，假设l队列的front的索引是a，r队列的front的索引是b。此时，当l的front的low大于r的front的high，说明当前窗口的最大low和最小high无法满足条件，所以需要将窗口的左边界移动到max(id, min(a+
1, b+
1))。这可能意味着，用户需要将窗口左边界移动到a+
1或者b+
1的较大者，以确保当前的两个队列的front元素被移除。
例如，假设l的front的索引是a，r的front的索引是b。此时，当前窗口的low_max（在a位置）和high_min（在b位置）导致low_max > high_min。为了消除这个影响，必须将窗口左边界移动到min(a+
1, b+
1)的较大者。例如，如果a < b，那么移动左边界到a+
1，这样l队列的front就会被弹出。反之，如果b < a，移动到b+
1.
这可能正确。用户的代码中，id变量表示当前窗口的左指针的起始位置。当条件不满足时，id被更新为max(id, min(
...))，然后将队列中索引小于id的元素弹出。
这部分的逻辑是否正确？
例如，假设l和r的front分别为a和b，a <b。此时，low_max是a处的low，high_min是b处的high。此时，low_max> high_min。此时，必须将左边界移动到a+
1，因为只有这样才能排除掉a处的low_max的影响。因为此时，在窗口[a,
...]中，low_max可能无法满足条件。移动左指针到a+
1后，l队列的front会被弹出。此时，用户的代码中的min是取l
.front()+
1和r
.front()+
1的较小者，然后id取max(id, min(
...))。这可能有问题？
例如，假设a=0, b=2。min(a+
1, b+
1)=
1. 此时，移动左指针到
1，这会导致b=2的位置是否还在窗口内？或者，这可能正确，因为此时需要将两个队列中索引小于id的元素都弹出？
用户的代码中，在移动左指针后，是否正确维护了队列中的元素？
比如，在弹出元素时，用户检查是否队列头部元素的索引小于id，并弹出。
这可能正确，因为id是当前窗口的左边界。队列中的元素索引必须>=id才能属于当前窗口。因此，当队列头部元素的索引小于id时，应该被弹出。
这部分的维护是否正确？
是的，这部分的逻辑可能正确。
那用户代码的错误可能出现在哪里？
可能的错误点：
1. 在维护单调队列时，是否将当前元素i的索引正确插入？例如，在代码中，用户将i加入到两个队列中。对于l队列来说，维护的是单调递减的low。用户比较当前元素的low与队列尾部元素的low的大小，如果当前元素更大或等于，则弹出尾部。这部分的判断是否正确？是的，因为l队列维护的是当前窗口的low的最大值，所以当新元素的low更大时，应该弹出旧元素。
同样，r队列维护的是high的最小值，所以当新元素的high更小时弹出。
这部分的逻辑正确。
2
. 当移动左指针时，是否可能遗漏弹出多个元素？例如，当id被更新到较大的值，此时队列头部可能有多个元素的索引小于id。用户的代码中，每次只弹出头部元素一次，是否足够？
例如，在while循环中，当条件不满足时，用户在循环体内弹出头部元素。但可能循环外的处理是否正确？
用户的代码中，在调整id之后，检查两个队列的头部元素的索引是否小于id，并弹出。这可能只弹出一次，而实际上可能有多个元素需要弹出？
例如，当id被设置为较大的值，队列中可能有多个元素的索引小于id。此时，用户的代码只弹出头部元素一次，可能无法完全清除所有无效的元素。
比如，用户的代码中的处理：
if(!l
.empty() && l
.front()
.first <id)
l
.pop_front();
这可能只弹出一个元素。但此时，弹出后的新头部可能仍然小于id，需要继续弹出。这应该由循环外的while循环处理吗？用户的代码中，这部分的处理是if语句，不是while循环。因此，可能只弹出一次，导致队列头部可能仍然存在索引小于id的元素。
这会导致错误吗？
是的，这可能是错误的原因。例如，当id被设置为5，而l队列的front元素索引是3，弹出后下一个元素索引是4，仍小于5。此时，需要再次弹出。否则，下一次循环中，front元素的索引仍然小于id，导致条件判断错误。
因此，用户应该将if改为while循环，确保所有索引小于id的头部元素都被弹出。
例如：
while(!l
.empty()&& l
.front()
.first < id)l
.pop_front();
同样的处理适用于r队列。这是用户代码中的错误所在。原来的代码使用if判断，只能弹出一次，而可能多个元素需要被弹出。因此，这部分的代码错误导致维护的队列中的front元素可能不在当前窗口内，从而导致后续判断错误。
例如，当id被更新到较大的值，而队列头部元素的索引小于id，此时仅弹出一次，剩下的头部元素可能仍然无效。
因此，修改这部分代码，将if改为while循环，可以修复这个问题。
这可能就是用户代码的问题所在。例如，在测试用例中，由于队列维护不正确，导致判断条件错误，从而返回错误的答案。
此外，用户的代码中，在调整id后，是否应该循环弹出队列头部的元素？总结，用户的错误可能在于：
在移动左指针时，只弹出队列头部的元素一次，而不是所有不满足条件的元素。应该将if语句改为while循环。
修改这部分代码后，问题可能得到解决。
因此，用户需要将：
if(!l
.empty() && l
.front()
.first <id)
l
.pop_front();
if(!r
.empty()&& r
.front()
.first < id)r
.pop_front();
改为：
while(!l
.empty()&& l
.front()
.first < id)l
.pop_front();
while(!r
.empty() && r
.front()
.first <id)
r
.pop_front();
或者，可能用户原来的代码中，在调整id后，在if判断中弹出一次，但可能还有多个元素需要弹出。所以，将if改为while循环才能正确维护队列的有效性。
这是可能的错误点。另外，用户的代码中，在调整id后，可能没有正确维护队列。例如，在移动左指针到id之后，两个队列的头部可能已经不在窗口内，需要被弹出。因此，必须循环弹出所有队列头部中索引小于id的元素。
因此，用户的代码中，这部分的处理应该使用while循环，而不是if。
修改这部分代码后，程序可能正确。
另一个可能的错误是，在判断条件的时候，用户使用了while循环中的条件：l
.front()
.second > r
.front()
.second。这可能正确，因为只要当前窗口的最大low大于最小high，就无法满足条件，需要移动左指针。综上所述，用户的代码的主要错误在于在弹出头部元素时使用了if而不是while循环。这导致可能仍有头部元素的索引小于当前的id，从而队列中的front元素可能不属于当前窗口，导致后续判断错误。因此，修改这两个if语句为while循环应该可以解决问题。</think>用户代码中的主要问题在于维护单调队列时，当窗口左边界移动后，未正确弹出所有不在当前窗口内的队列元素。具体来说，在调整左指针时，使用`if`语句仅弹出队列头部的一个元素，可能导致队列头部仍存在过期索引。正确的做法是使用`while`循环，确保所有过期元素都被弹出。
### 修改后的代码关键部分
```cpp
while(!l
.empty() && l
.front()
.first < id)
l
.pop_front();
while(!r
.empty() && r
.front()
.first < id)
r
.pop_front();
```
### 完整修正代码示例
```cpp
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#define int long long
using namespace std;
const int N =
1e6+9;
int n;
pair<int, int> t[N];
inline v
oid Faith(){
cin >> n;
for(int i = 0; i < n; ++i) cin >> t[i]
.first >> t[i]
.second;
deque<pair<int, int>> l,r;
int ans = 0, id = 0;
for(int i = 0; i < n; ++i){
while(!l
.empty() && l
.back()
.second <= t[i]
.first)
l
.pop_back();
l
.push_back({i, t[i]
.first});
while(!r
.empty() && r
.back()
.second >= t[i]
.second)
r
.pop_back();
r
.push_back({i, t[i]
.second});
while(!l
.empty() && !r
.empty() && l
.front()
.second > r
.front()
.second){
id = max(id, min(l
.front()
.first+
1, r
.front()
.first+
1));
while(!l
.empty() && l
.front()
.first < id)
l
.pop_front();
while(!r
.empty() && r
.front()
.first < id)
r
.pop_front();
}
if(!l
.empty() && !r
.empty()){
ans = max(ans, i-id+
1);
}
}
cout << ans << "\n";
}
signed main(v
oid){
ios::sync_with_stdio(false);
cin
.tie(nullptr),cout
.tie(nullptr);
Faith();
return 0;
}
```
###
扫一扫
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
