USACO习题：Milking Cows

这道题目，给你一组时间范围，求最大的时间跨度和最大的时间段间隔。题目看似挺简单，但是如果不加考虑却会发现其中对于时间间隔的处理，有多种情况。也就是会所程序里可能会出现出多的判断语句，使得代码变得非常难写而且容易出错。

 

我的第一版解法

我采用了一种比较奇怪的数据结构，就是将链表和线性表结合。线性表用于表示一条时间轴，链表用于表示不同时间的跨度。

以样例数据为例

300 1000
700 1200
1500 2100

 我先不论时间的起点和终点，将他们一并放在一个数轴上，然后排序，得到一个时间轴。

300     700     1000     1200     1500     2100

 这是第一步处理，我的第二部处理是遍历这个时间轴，如果某个数值是一个时间的起点，那么拿到他的终点。从这个起点建立链表到他的终点。

比如时间段300,1000。我的程序会这样处理

300 --> 700 --> 1000

 然后再到700，在从700连到1200，再1500（1000是一个时间段终点）全部做好以后，一个时间段就成了一个链表：

300 --> 700 --> 1000 --> 1200     1500 --> 2100

 时间段跨度最长的链条就是所求的（不一定是链表长度最长的）。

 

这个解法的好处就是对于时间跨度的交叉不需要任何判断，只要把它们串起来，相当于在数轴上不停的涂颜色，最后找到最大的一块颜色。

但是缺点就是，建立链表的步骤，他的最差情况的复杂度是O(n^2)，如下情况出现

100 1000
200 900
300 800
400 700
500 600

 不过，数据大多数情况下比较随机，所以我个人估计平均每个时间段的跨度也在logn左右，所以这个代码实际在测试的时候跑得还是非常快的。

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>


using namespace std;

struct Node {
    int value;
    struct Node *next;
    Node(int value) { this->value = value;this->next=NULL;}
};

void p_axis(vector<Node> &axis){
    for(int i=0;i<axis.size();++i){
        cout<<axis[i].value;
        if(axis[i].next!=NULL)
            cout<<"-->";
        else
            cout<<"";
    }
    cout<<endl;
}

bool node_cmp(Node n1,Node n2) {
    return n1.value < n2.value;
}

int index(vector<Node> &axis, int value){
    for(int i=0;i<axis.size();++i)
        if (axis[i].value==value)
            return i;
    return -1;
}


int main() {
    ofstream fout("milk2.out");
    ifstream fin("milk2.in");

    int len =0;
    fin>>len;

    map<int,int> pairs;
    vector<Node> node_axis;

    int start=0,end=0;
    map<int,int>::iterator iter;
    for(int i=0;i<len;++i){
        fin>>start>>end;
        iter = pairs.find(start);
        if(iter==pairs.end()){
            pairs[start] = end;
        }else{
            pairs[start] = max(pairs[start],end);
        }
        node_axis.push_back(Node(start));
        node_axis.push_back(Node(end));
    }
    
    //printf("len:%d,node_axis:%d,map:%d\n",len,node_axis.size(),pairs.size());
    sort(node_axis.begin(),node_axis.end(),node_cmp);

    //p_axis(node_axis);

  
    for(int i=0;i<node_axis.size();++i){
        Node *cur = &node_axis[i];
        
        int value = cur->value;

        map<int,int>::iterator iter =  pairs.find(value);
        if(iter==pairs.end())
            continue;
        //cout<<i<<":"<<"start:"<<value<<",end:"<<(*iter).second<<endl;
        
        int end = (*iter).second;
        int j=i;
        do{
            ++j;
            cur->next = &node_axis[j];
            cur = &node_axis[j];
        }while(node_axis[j].value!=end);
    }

    //p_axis(node_axis);

    int max_mk=0,max_nomk=0,i=0;
    
    Node *end_node =NULL;
    while (i<node_axis.size()){
        Node *start = &node_axis[i];
        if(end_node){
            int no_interval = start->value - end_node->value;
            max_nomk = no_interval>max_nomk?no_interval:max_nomk;
        }
        
        end_node = start;
        while(end_node->next!=NULL){
            end_node = end_node->next;
            i+=1;
        }
        int interval = end_node->value - start->value;
        max_mk = interval>max_mk?interval:max_mk;
        
        i+=1;
    }

    fout<<max_mk<<" "<<max_nomk<<endl;

    
    fin.close();
    fout.close();
    return 0;
}

 

改进版解法

解决以后看到分析的上面的提示，突然想到，其实在排序以后，已经时合并变得非常容易。思路如下：

1。先将给定的时间段按照【初始时间排序】

2。从最左边开始遍历，每次取相邻的两个时间段A,B。（注意：B的起始时间已经在A的右边）

　　会有以下3种情况

1)我们将A.end更新成为B.end

2)我们另起一个时间段，因为A不需要做合并

3)直接跳过B

 

经过这样的合并遍历，我们就得到了一个已经合并时间段的时间轴，其中每一个时间段都不相交。这样就使我们求值变得非常方便。

代码如下：

#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>


using namespace std;

struct Interval {
    int start;
    int end;
    Interval(int start,int end) { this->start=start;this->end=end;}
    Interval(const Interval& val) { this->start = val.start;this->end = val.end;}
    int span() { return (this->end - this->start);}    
};

bool operator<(const Interval& val1,const Interval& val2) { return val1.start < val2.start;}



int main() {
    ofstream fout("milk2.out");
    ifstream fin("milk2.in");

    int len =0;
    fin>>len;

    vector<Interval> node_axis;

    int start=0,end=0;
    for(int i=0;i<len;++i){
        fin>>start>>end;
        node_axis.push_back(Interval(start,end));
    }
    
    //printf("len:%d,node_axis:%d,map:%d\n",len,node_axis.size(),pairs.size());
    sort(node_axis.begin(),node_axis.end());

    //p_axis(node_axis);
    //add a sentinel
    node_axis.push_back(Interval(655534,655535));
    
    vector<Interval> combined_axis;
    Interval max_interval = node_axis[0];
    for(int i =1 ; i<node_axis.size();++i){
        if(node_axis[i].start > max_interval.end){
            combined_axis.push_back(max_interval);
            max_interval = node_axis[i];
        }else if(node_axis[i].end > max_interval.end){
            max_interval.end = node_axis[i].end;
        }else{
            //filter this interval
            continue;
        }
    }
    
    int max_mk = combined_axis[0].span(),max_nomk=0;
    for(int i =1;i<combined_axis.size();++i){
        max_mk = max(combined_axis[i].span(),max_mk);
        max_nomk = max((combined_axis[i].start - combined_axis[i-1].end),max_nomk);
    }
    
    fout<<max_mk<<" "<<max_nomk<<endl;

    
    fin.close();
    fout.close();
    return 0;
}