Hacker Rank: Gridland Metro解题报告

原题链接：Gridland Metro

思路：

由于1 <= n, m <= 10^9，第一，使用一个n×m的二位数组表示城市空间复杂度太大；第二，遍历这样一个二位数组时间复杂度太大。

又由于0<=k<=1000，我换了一个思路，借鉴表示稀疏矩阵的方法，以一个三元组表示一条铁轨(r, c1, c2)。先按行r对(c1, c2)进行合并，然后计算每一行铁轨占据的格子数量，最后总格数减去铁轨占据的格子数就等于空格数，即可以放置路灯的格子数。

时间复杂度：O(k^2)，空间复杂度：O(k)。

数据结构：

我用

struct track{

long long c1, c2

};

表示铁轨。

我采用map<long long, vector<track>>各行铁轨，map的秩表示铁轨所在的行，vector<track>表示该行铁轨起点和终点。

计算某行区间算法：

1. 输入某行铁轨向量train_tracks。
2. 初始化区间集合v为空。
3. for i = 0 to train_tracks.size - 1:
   1. for j = 0 to v.size - 1:
      1. 如果train_tracks[i]与v[j]有交集，就合并v[j]到train_tracks[i]，然后抹除v[j]。
   2. 把train_tracks[i]插入v。
4. 遍历v，计算区间长度。

参考代码：

#include <cmath>
#include <cstdio>
#include <cassert>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;

struct track{
    long long c1, c2;
    track(long long c1 = 0, long long c2 = 0): c1(c1), c2(c2){}
};

int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    long long n, m, k; assert(3 == scanf("%lld %lld %lld", &n, &m, &k));
    map<long long, vector<track>> train_tracks;
    for(int i = 0; i < k; i++){
        long long r, c1, c2; assert(3 == scanf("%lld %lld %lld", &r, &c1, &c2));
        train_tracks[r].push_back(track(c1, c2));
    }
    long long occupied = 0;
    for(auto mit = train_tracks.begin(); mit != train_tracks.end(); mit++){
        vector<track> v;
        for(int i = 0; i < mit->second.size(); i++){
            auto tmp = mit->second[i];
            bool flag = true;
            for(int j = 0; flag && j < v.size(); j++){
                // 后者包括前者
                if(v[j].c1 <= tmp.c1 && v[j].c2 >= tmp.c2){
                    flag = false;
                }
                // 前者包括后者
                else if(tmp.c1 <= v[j].c1 && tmp.c2 >= v[j].c2){
                    v.erase(v.begin() + j);
                }
                // 两者有交集
                else if(tmp.c1 < v[j].c1 && tmp.c2 >= v[j].c1 && tmp.c2 <= v[j].c2){
                    v.erase(v.begin() + j);
                    tmp.c2 = v[j].c2;
                }
                else if(tmp.c1 >= v[j].c1 && tmp.c1 <= v[j].c2 && tmp.c2 > v[j].c2){
                    v.erase(v.begin() + j);
                    tmp.c1 = v[j].c1;
                }
            }
            if(flag){
                v.push_back(tmp);
            }
        }
        for(auto vit: v){
            occupied += (vit.c2 - vit.c1 + 1);
        }
    }
    
    long long empty = n * m - occupied;
    printf("%lld\n", empty);
    return 0;
}