Как ускорить логику цикла? [for experts]

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <chrono>
 
class Line
{
    public:
        bool operator<(const Line&line)const
        {
            return x<line.x;
        }
 
        int x,y;
};
 
int main()
{
    auto begin = std::chrono::steady_clock::now();
    
    std::ifstream file("fnc_extended");
    std::size_t lenght,lineListSize;
    //std::cin>>lenght>>lineListSize;
    file >> lenght>>lineListSize;
    std::vector<Line> lineList;
    for(std::size_t i=0; i<lineListSize; ++i)
    {
        int x,y;
    //  std::cin>>x>>y;
        file >> x >> y;
        lineList.push_back({x,y});
    }
    std::sort(lineList.begin(),lineList.end());
    auto writePos=lineList.begin();
    for(auto readPos=lineList.begin()+1; readPos<lineList.end(); ++readPos)
    {
        if(writePos->x<=readPos->x && readPos->x<=writePos->y)
            writePos->y=std::max(writePos->y,readPos->y);
        else
            *++writePos=*readPos;
    }
    lineList.erase(++writePos,lineList.end());
    std::cout<<"{0,"<<lineList.front().x<<"} ";
    for(auto line=lineList.begin(); line+1<lineList.end(); ++line)
        std::cout<<"{"<<line[0].y<<" "<<line[1].x<<"} ";
    std::cout<<"{"<<lineList.back().y<<","<<lenght<<"}";
    
    file.close();
    
    auto end = std::chrono::steady_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
        
    std::cout << "\n\nTime = " << elapsed_ms.count() ;
    
    system("pause");
    return 0;
}

#include <vector>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <chrono>
 
int main()
{
    auto begin = std::chrono::steady_clock::now();
    std::ifstream file("fnc_extended");
 
    int length = 0;
//  std::cin >> length;
    file >> length;
 
    unsigned n_segments = 0;
//  std::cin >> n_segments;
    file >> n_segments;
 
    std::vector<std::pair<int, int>> points;
 
    for (unsigned i = 0; i < n_segments; ++i)
    {
        int xl = 0, xr = 0;
    //  std::cin >> xl >> xr;
        file >> xl >> xr;
        points.emplace_back(xl, +1);
        points.emplace_back(xr, -1);
    }
 
    points.emplace_back(length, +1);
 
    std::sort(points.begin(), points.end());
 
    int n_coverage = 0;
    int prev_x = 0;
 
    for (const auto &point : points)
    {
        if (n_coverage == 0 && prev_x != point.first)
            std::cout << prev_x << " " << point.first << std::endl;
 
        prev_x = point.first;
        n_coverage += point.second;
    }
 
 
    file.close();
 
    auto end = std::chrono::steady_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
 
    std::cout << "\n\nTime = " << elapsed_ms.count() ;
    system("pause");
 
}

#include <iostream>
#include <map>
#include <fstream>
#include <chrono>
 
typedef int T;
 
///----------------------------------------------------------------------------|
/// ?????.
///----------------------------------------------------------------------------:
int main()
{
    auto begin = std::chrono::steady_clock::now();
 
    std::ifstream file("fnc_extended");
 
    T n, l;
//  std::cin >> l >> n;
    file >> l >> n;
    std::map<T, T> fence;
 
    for(T i = 0; i < n; ++i)
    {
        T s;
//      std::cin >> s;
        file >> s;
        fence[s]++;
///     std::cin >> s;
        file >> s;
        fence[s]--;
    }
 
    T    cnt   = 1;
    bool intro = true,
         all   = true;
    fence[l]++;
    fence[0]--;
 
/*тут и ниже прально подменил? у меня  [i, val] не фурычит*/
    //for(auto& [i, val] : fence) // 
    for(auto& i : fence)
    {
        cnt += i.second;
 
        if(0 == cnt &&  intro)
        {
            intro = false;
            std::cout << i.first << ' ' ;
            all = false;
        }
        else if(0 <  cnt && !intro)
        {
            intro = true ;
            std::cout << i.first << '\n';
        }
    }
    if(all) std::cout << "All painted";
 
    file.close();
 
    auto end = std::chrono::steady_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
 
    std::cout << "\n\nTime = " << elapsed_ms.count() ;
    system("pause");
}

#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <chrono>
 
 
using namespace std;
 
void scanSeq(istream & is, ostream & os)
{
    typedef  unsigned long long s_t;
    map<s_t , s_t> intervs;
    s_t L, N;
    is>>L;
    is>>N;
    pair<s_t, s_t> p;
    for (s_t i = 0; i<N; ++i)
    {
        is>>p.first>>p.second;
        intervs[p.first]=p.second;
    }
 
    s_t pos_b = 0, pos_e;
    for (auto & i : intervs)
    {
        pos_e = i.first;
        if (pos_e > pos_b)
            os<<pos_b<<" "<<pos_e<<endl;  // ????? "?????????????" "??????"
        if (i.second > pos_b) // ?????????? ??? ???????? ? ??????????????? ?????????
            pos_b = i.second;  // ??????? ????, ?????????, ???? ????
    }
    if (pos_b < L) // ?????, ???? ????
        os<<pos_b<<" "<<L<<endl;
}
int main()
{
    auto begin = std::chrono::steady_clock::now();
    // ??? ?????
    //ifstream ifs("input.txt");
    ifstream ifs("fnc_extended");
    scanSeq(ifs, cout);
 
    // ?????? ????
    // stringstream ss;
    // ss<<100<<endl<<5<<endl<<" 5 11 "<<" 4 9 "<<" 1 3 "<<" 40 70 "<<" 50 60 ";
    // scanSeq(ss, cout);
    ifs.close();
 
    auto end = std::chrono::steady_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
 
    std::cout << "\n\nTime = " << elapsed_ms.count() ;
    system("pause");
}

#include <iostream>
#include <vector>
#include <fstream>
#include <chrono>
 
enum { BEGIN, END };
 
struct Node
{
    bool kind;
    int pos;
    Node* next;
};
 
struct MyList
{
    Node* head;
    Node* it;
 
    void add_segment(Node* A, Node* B)
    {
        it = head;
        Node* temp = nullptr;
 
        while(it->next && it->next->pos < A->pos) it = it->next;
 
        temp = it->next;
        it->next = ((it->next->kind) ? B : A );
 
        if(it->next->kind)
        {
            it->next = B;
        }
        else
        {
            it->next = A;
            it = it->next;
        }
 
        while(temp->next && temp->pos < B->pos) temp = temp->next;
        if(temp->kind)
        {
            it->next = temp;
        }
        else
        {
            if(B->pos == temp->pos)
            {
                it->next = temp->next;
            }
            else
            {
                it->next->next = temp;
            }
        }
    }
 
    void show()
    {
        it = head->next;
        while(it->next)
        {
            if(it->kind) std::cout << "\n";
            std::cout << it->pos << " ";
            it = it->next;
        }
    }
};
 
int main()
{
    auto begin = std::chrono::steady_clock::now();
 
    int len;
    int n;
 
    std::ifstream file("fnc_extended");
 
    if(file.is_open())
    {
        //  std::cin >> len >> n;
        file >> len >> n;
 
        std::vector<std::pair<Node, Node>> node_list(n);
 
        Node B_end = { END, len + 1, nullptr };
        Node B_beg = { BEGIN, len, &B_end };
        Node A_end = { END, 0, &B_beg };
        Node A_beg = { BEGIN, -1, &A_end };
 
        MyList Fence;
        Fence.head = &A_beg;
 
        for(int i=0; i<n; ++i)
        {
            node_list[i].first.kind = BEGIN;
            node_list[i].second.kind = END;
            node_list[i].first.next = &node_list[i].second;
            node_list[i].second.next = nullptr;
 
            //  std::cin >> node_list[i].first.pos >> node_list[i].second.pos;
            file >> node_list[i].first.pos >> node_list[i].second.pos;
 
//          std::cout << "\n" << node_list[i].first.pos << " : " << node_list[i].second.pos;
 
            Fence.add_segment(&node_list[i].first, &node_list[i].second);
        }
 
        std::cout << "\n\n";
        Fence.show();
 
        file.close();
    }
 
    auto end = std::chrono::steady_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);
 
    std::cout << "\n\nTime = " << elapsed_ms.count() ;
    system("pause");
 
    return 0;
}