Problem p02573 (C++) — buggy submission, verdict: Runtime Error


#include <algorithm>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>

// priority is lesser.
class union_find {

public:
  using value_type = std::int32_t;
  using size_type = decltype(std::declval<std::vector<value_type>>().size());

private:
  std::vector<int> parent_;
  // std::vector<int> size_;

public:
  // uf_[0,n_-1]
  union_find(size_type n_)
      : parent_{} //, size_{}
  {
    parent_.resize(n_, -1);
    //			std::iota( std::begin( parent_ ), std::end( parent_ ), 0
    //);
  }

  auto root(value_type x) -> value_type {
    // std::cout << "root->" << x << "\\n";

    auto &p_ = parent_[x];

    return p_ < 0 ? x : p_ = root(p_);
  }

  // auto root( value_type x )const->value_type{
  //	return
  //		x == parent_[x]
  //		? x
  //		: root( parent_[x] );
  // }

  // auto croot( value_type x )const{
  //	return root( x );
  // }

  auto size() const { return parent_.size(); }

  auto size(value_type x) -> size_type { return -parent_[root(x)]; }

  // auto size( value_type x )const{
  //	return size_[croot( x )];
  // }

  // auto csize( value_type x )const{
  //	return size( x );
  // }

  auto unite(value_type a_, value_type b_) {

    // std::cout <<"unite-"<< a_ <<" "<< b_ << "\\n";

    if (a_ == b_)
      return;

    // mut : to swap;
    auto ra_ = root(a_);
    auto rb_ = root(b_);

    if (ra_ == rb_)
      return;

    const auto sa_ = size(a_);
    const auto sb_ = size(b_);

    // should be ra_ < rb_
    if (sa_ > sb_)
      std::swap(ra_, rb_);

    // if( sa_ == sb_ )
    //	++size_[ra_];
    parent_[ra_] += parent_[rb_];

    parent_[rb_] = ra_;
  }

  auto same(value_type a_, value_type b_) { return root(a_) == root(b_); }

  auto dump() {
    for (int i{}; i < parent_.size(); ++i) {
      std::cout << (i + 1) << "<-" << parent_[i] << " |" << size(i) << "|\\n";
    }
  }

  // auto answer(){
  //	return -*std::min_element( std::begin( parent_ ), std::end( parent_ ) );
  // }
};

int main() {

  std::uint32_t N, M;
  std::cin >> N >> M;

  union_find uf_{N};

  for (int i{}; i < M; ++i) {
    int A, B;
    std::cin >> A >> B;
    --A;
    --B;

    uf_.unite(A, B);

    // std::cout <<"sa_sb_:"<< uf_.size(A) << " " << uf_.size( B ) << "\\n";
  }

  //	uf_.dump();

  // if( ans_ != uf_.answer() )
  //	throw std::exception{};

  auto ans_ = decltype(uf_.size(std::declval<int>())){};

  for (int i{}; i < N; ++i)
    ans_ = std::max(ans_, uf_.size(i));

  std::cout << ans_ << "\\n";

  return 0;
}

Error: 0

Fixed submission:


#include <algorithm>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>

// priority is lesser.
class union_find {

public:
  using value_type = std::int32_t;
  using size_type = decltype(std::declval<std::vector<value_type>>().size());

private:
  std::vector<int> parent_;
  // std::vector<int> size_;

public:
  // uf_[0,n_-1]
  union_find(size_type n_)
      : parent_{} //, size_{}
  {
    parent_.resize(n_, -1);
    //			std::iota( std::begin( parent_ ), std::end( parent_ ), 0
    //);
  }

  auto root(value_type x) -> value_type {
    // std::cout << "root->" << x << "\\n";

    auto &p_ = parent_[x];

    return p_ < 0 ? x : p_ = root(p_);
  }

  // auto root( value_type x )const->value_type{
  //	return
  //		x == parent_[x]
  //		? x
  //		: root( parent_[x] );
  // }

  // auto croot( value_type x )const{
  //	return root( x );
  // }

  auto size() const { return parent_.size(); }

  auto size(value_type x) -> size_type { return -parent_[root(x)]; }

  // auto size( value_type x )const{
  //	return size_[croot( x )];
  // }

  // auto csize( value_type x )const{
  //	return size( x );
  // }

  auto unite(value_type a_, value_type b_) {

    // std::cout <<"unite-"<< a_ <<" "<< b_ << "\\n";

    if (a_ == b_)
      return;

    // mut : to swap;
    auto ra_ = root(a_);
    auto rb_ = root(b_);

    if (ra_ == rb_)
      return;

    const auto sa_ = size(a_);
    const auto sb_ = size(b_);

    // should be ra_ < rb_
    if (sa_ > sb_)
      std::swap(ra_, rb_);

    // if( sa_ == sb_ )
    //	++size_[ra_];
    parent_[ra_] += parent_[rb_];

    parent_[rb_] = ra_;
  }

  auto same(value_type a_, value_type b_) { return root(a_) == root(b_); }

  auto dump() {
    for (int i{}; i < parent_.size(); ++i) {
      std::cout << (i + 1) << "<-" << parent_[i] << " |" << size(i) << "|\\n";
    }
  }

  auto answer() {
    return -*std::min_element(std::begin(parent_), std::end(parent_));
  }
};

int main() {

  std::uint32_t N, M;
  std::cin >> N >> M;

  union_find uf_{N};

  int ans_{};
  for (int i{}; i < M; ++i) {
    int A, B;
    std::cin >> A >> B;
    --A;
    --B;

    uf_.unite(A, B);

    // std::cout <<"sa_sb_:"<< uf_.size(A) << " " << uf_.size( B ) << "\\n";

    const int t_ = uf_.size(A);

    ans_ = std::max(t_, ans_);
  }

  //	uf_.dump();

  if (ans_ != uf_.answer())
    throw std::exception{};
  std::cout << ans_ << "\\n";

  return 0;
}