Problem p02243 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <algorithm>
#include <cassert>
#include <climits>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <string>
#include <vector>

/*
?§????????????¢0??§???????¢????
??????????¢????????????????????????¶????????????????????§???????°????????????§??°?????????????????£???????????????????¢????
while(????????????????????????????????§)
    list = ???????????????.Get????°?????????????????????????
    for(list)
        ?????????????????????
*/

class TVertex;
struct TPath {
  int Cost;
  TVertex *Target;
  TPath(TVertex *ATarget, int ACost) : Target(ATarget), Cost(ACost) {}
  bool operator<(const TPath &Right) const {
    if (this->Cost < 0)
      return false;
    if (Right.Cost < 0)
      return true;
    return this->Cost < Right.Cost;
  }
  bool operator>(const TPath &Right) const { return !((*this) < Right); }
};
class TVertex {
  int FIndex;
  std::priority_queue<TPath, std::vector<TPath>, std::greater<TPath>> FList;
  int FDistance;

public:
  TVertex(int Index) : FIndex(Index), FDistance(INT_MAX) {}
  void Reserve(int Size) {
    // FList.reserve(Size);
  }
  void AddPath(const TPath &Path) { FList.push(Path); }
  void SortPath() {
    // std::sort(FList.begin(), FList.end(), Compare);
  }
  void PrintDistance(std::ostream &out) const {
    out << FIndex << " " << FDistance << std::endl;
  }
  int GetMinCostPath() const {
    if (FList.empty())
      return INT_MAX;
    return FList.top().Cost + FDistance;
  }
  void PickupMinCostPath(int MinCost, std::list<TPath> &List) {
    while (FList.empty() == false && FList.top().Cost + FDistance == MinCost) {
      List.push_back(TPath(FList.top().Target, FList.top().Cost + FDistance));
      FList.pop();
    }
  }
  bool SetDistance(int Distance) {
    if (FDistance < Distance)
      return false;
    FDistance = Distance;
    return true;
  }
};
class TGraph {
  std::vector<TVertex *> FTable;
  std::set<TVertex *> FShortest;
  void Init(int n) {
    assert(n > 0);
    FTable.resize(n);
    for (int i = 0; i < n; ++i) {
      FTable[i] = new TVertex(i);
    }
  }
  static bool CompareMinCost(const TVertex *Left, const TVertex *Right) {
    return Left->GetMinCostPath() < Right->GetMinCostPath();
  }
  void AddShortest(TVertex *Vertex, int Distance) {
    if (Vertex->SetDistance(Distance)) {
      FShortest.insert(Vertex);
    }
  }
  std::list<TPath> PickupMinCostPath(int MinCost) {
    std::list<TPath> Result;
    for (std::set<TVertex *>::const_iterator It = FShortest.begin();
         It != FShortest.end(); ++It) {
      (*It)->PickupMinCostPath(MinCost, Result);
    }
    return Result;
  }
  void SetShortest(const std::list<TPath> &MinCostPathList) {
    for (std::list<TPath>::const_iterator It = MinCostPathList.begin();
         It != MinCostPathList.end(); ++It) {
      AddShortest(It->Target, It->Cost);
    }
  }

public:
  TGraph(int n) { Init(n); }
  void SetupVertex(std::istream &in) {
    int Index;
    in >> Index;
    assert(Index >= 0);
    assert(Index < FTable.size());
    int k;
    in >> k;
    FTable[Index]->Reserve(k);
    for (int i = 0; i < k; ++i) {
      int v, c;
      in >> v >> c;
      FTable[Index]->AddPath(TPath(FTable[v], c));
    }
    FTable[Index]->SortPath();
  }
  void SearchShortest() {
    FTable[0]->SetDistance(0);
    FShortest.insert(FTable[0]);
    while (FShortest.size() != FTable.size()) {
      int MinCost = (*std::min_element(FShortest.begin(), FShortest.end(),
                                       CompareMinCost))
                        ->GetMinCostPath();
      std::list<TPath> PathList = PickupMinCostPath(MinCost);
      SetShortest(PathList);
    }
  }
  void PrintDistance(std::ostream &out) {
    for (int i = 0; i < FTable.size(); ++i) {
      FTable[i]->PrintDistance(out);
    }
  }
};

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  int n;
  std::cin >> n;
  TGraph Graph(n);
  for (int i = 0; i < n; ++i) {
    Graph.SetupVertex(std::cin);
  }
  Graph.SearchShortest();
  Graph.PrintDistance(std::cout);
  return 0;
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <cassert>
#include <climits>
#include <iostream>
#include <list>
#include <string>
#include <vector>

class TVertex;
struct TPath {
  int Cost;
  TVertex *Target;
  TPath(TVertex *ATarget, int ACost) : Target(ATarget), Cost(ACost) {}
};
bool Compare(const TPath &Left, const TPath &Right) {
  if (Left.Cost < 0)
    return false;
  if (Right.Cost < 0)
    return true;
  return Left.Cost < Right.Cost;
}
class TVertex {
  int FIndex;
  std::vector<TPath> FList;
  int FDistance;

public:
  TVertex(int Index) : FIndex(Index), FDistance(INT_MAX) {}
  void Reserve(int Size) { FList.reserve(Size); }
  void AddPath(const TPath &Path) { FList.push_back(Path); }
  void SortPath() { std::sort(FList.begin(), FList.end(), Compare); }
  void PrintDistance(std::ostream &out) const {
    out << FIndex << " " << FDistance << std::endl;
  }
  void BreadthFirstSearch(int Distance) {
    if (FDistance <= Distance)
      return;
    FDistance = Distance;
    for (std::vector<TPath>::iterator It = FList.begin(); It != FList.end();
         ++It) {
      It->Target->BreadthFirstSearch(Distance + It->Cost);
    }
  }
};
class TGraph {
  std::vector<TVertex *> FTable;
  void Init(int n) {
    assert(n > 0);
    FTable.resize(n);
    for (int i = 0; i < n; ++i) {
      FTable[i] = new TVertex(i);
    }
  }

public:
  TGraph(int n) { Init(n); }

  void SetupVertex(std::istream &in) {
    int Index;
    in >> Index;
    assert(Index >= 0);
    assert(Index < FTable.size());
    int k;
    in >> k;
    FTable[Index]->Reserve(k);
    for (int i = 0; i < k; ++i) {
      int v, c;
      in >> v >> c;
      FTable[Index]->AddPath(TPath(FTable[v], c));
    }
    FTable[Index]->SortPath();
  }
  void BreadthFirstSearch() { FTable[0]->BreadthFirstSearch(0); }
  void PrintDistance(std::ostream &out) {
    for (int i = 0; i < FTable.size(); ++i) {
      FTable[i]->PrintDistance(out);
    }
  }
};

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  int n;
  std::cin >> n;
  TGraph Graph(n);
  for (int i = 0; i < n; ++i) {
    Graph.SetupVertex(std::cin);
  }
  Graph.BreadthFirstSearch();
  Graph.PrintDistance(std::cout);
  return 0;
}