区间合并算法与既约真分数生成详解

爱过河的小马锅

1. 算法题解：挤奶时间区间合并问题

1.1 问题分析与建模

这道题目描述的是多个农民挤奶时间段的统计问题。我们需要处理N个时间段区间，计算两个关键指标：

最长至少有一个农民在挤奶的连续时间段
最长的无人挤奶的连续时间段

这本质上是一个经典的区间合并问题。在算法领域，区间合并通常用于处理重叠或相邻的时间段、数值范围等场景。这类问题的核心在于如何高效地识别和处理区间之间的关系。

提示：区间合并问题的关键在于正确识别区间之间的重叠或相邻关系，并设计合理的合并策略。

1.2 解题思路详解

解决这个问题的标准步骤如下：

排序预处理：首先将所有区间按照开始时间进行排序。这是区间合并问题的标准预处理步骤，可以确保我们能够按时间顺序处理各个区间。
初始化当前区间：将第一个区间设为当前合并区间。
遍历处理后续区间：
- 如果当前区间与下一个区间重叠或相邻（即当前区间的结束时间 >= 下一个区间的开始时间），则合并这两个区间
- 如果不重叠，则计算当前连续挤奶时间段和接下来的空闲时间段
特殊处理最后一个区间：由于循环中只在遇到不重叠区间时才计算长度，因此需要单独处理最后一个连续区间。

1.3 代码实现与关键点解析

cpp复制#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Time{
    int start_time;
    int end_time;
};

// 排序比较函数：先按开始时间，再按结束时间
bool compareTime(const Time& a,const Time& b){
    if(a.start_time!=b.start_time){
        return a.start_time<b.start_time;
    }
    return a.end_time<b.end_time;
}

int main()
{
    int N;
    cin>>N;
    vector<Time> farmers(N);
    for(int i=0;i<N;i++){
        cin>>farmers[i].start_time>>farmers[i].end_time;
    }
    
    // 关键步骤1：排序
    sort(farmers.begin(),farmers.end(),compareTime);
    
    int max_milk_time=0;
    int max_empty_time=0;

    int current_start=farmers[0].start_time;
    int current_end=farmers[0].end_time;

    // 关键步骤2：区间合并遍历
    for(int i=1;i<N;i++){
        if(current_end>=farmers[i].start_time){ // 重叠或相邻
            current_end=max(current_end,farmers[i].end_time);
        }else{ // 不重叠
           int milk_time=current_end-current_start;
           if(milk_time>max_milk_time){
            max_milk_time=milk_time;
           }
           
           int empty_time=farmers[i].start_time-current_end;
           if(empty_time>max_empty_time){
            max_empty_time=empty_time;
           }

           current_start=farmers[i].start_time;
           current_end=farmers[i].end_time;
        }
    }
    
    // 关键步骤3：处理最后一个区间
    int last_milk_time=current_end-current_start;
    if(last_milk_time>max_milk_time){
        max_milk_time=last_milk_time;
    }

    cout<<max_milk_time<<" "<<max_empty_time<<endl;
    
    return 0;
}

1.4 常见错误与调试技巧

忘记排序：这是最常见的错误。如果不先排序，合并逻辑将无法正确工作。
最后一个区间处理遗漏：循环中只在遇到不重叠区间时才计算长度，因此必须单独处理最后一个连续区间。
边界条件处理：
- 当N=1时，最大挤奶时间就是该区间长度，最大空闲时间为0
- 注意区间是左闭右开还是闭区间，题目中明确是闭区间
时间复杂度分析：
- 排序步骤：O(N log N)
- 合并步骤：O(N)
- 总体复杂度：O(N log N)

2. 算法题解：既约真分数生成与排序

2.1 问题理解与数学基础

题目要求生成所有分母不超过N的既约真分数，并按增序输出。既约真分数需要满足：

分子小于分母（真分数）
分子和分母互质（既约分数）

这涉及到数论中的最大公约数（GCD）概念。两个数互质意味着它们的最大公约数为1。

2.2 解题思路分解

解决这个问题的步骤可以分为：

双重循环生成所有可能分数：
- 外层循环遍历分母（1到N）
- 内层循环遍历分子（1到分母-1）
筛选既约分数：
- 对每个分数，计算分子分母的最大公约数
- 只有GCD为1的分数才保留
分数排序：
- 自定义比较函数，实现分数的正确比较
- 使用标准库的sort函数进行排序
特殊处理边界情况：
- 分母为1时，只有0/1这个分数
- 避免重复输出相同的分数

2.3 代码实现与关键点

cpp复制#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

typedef struct fraction{
    int denominator; // 分母
    int numerator;   // 分子
}Fraction;

// 分数比较函数
bool compareFraction(const Fraction& a,const Fraction& b){
    return a.numerator*b.denominator<b.numerator*a.denominator;
}

// 欧几里得算法求最大公约数
int gcd(int a,int b){
    while(b!=0){
        int temp=b;
        b=a%b;
        a=temp;
    }
    return a;
}

int main()
{
    int N;
    cin>>N;
    vector<Fraction> fractions;
    
    for(int denom=1;denom<=N;denom++){ // 分母
        for(int numer=0;numer<denom;numer++){ // 分子
            if(numer==0){
                if(denom==1){ // 处理0/1的情况
                    fractions.push_back({1,0});
                }
                continue;
            }
            if(gcd(denom,numer)==1){ // 既约分数
                fractions.push_back({denom,numer});
            }
        }
    }
    
    // 关键步骤：分数排序
    sort(fractions.begin(),fractions.end(),compareFraction);
    
    // 输出结果
    for(const auto& frac:fractions){
        cout<<frac.numerator<<"/"<<frac.denominator<<endl;
    }
    
    return 0;
}