Resize a multi-dimensional vector (tools/resize.hpp)

• View this file on GitHub
• View document part on GitHub
• Last update: 2022-09-03 15:52:01+09:00
• Include: #include "tools/resize.hpp"

template <class T, class Allocator, typename Head>
void resize(std::vector<T, Allocator>& vector, const Head& head);

template <class T, class Allocator, typename Head, typename... Tail>
void resize(std::vector<T, Allocator>& vector, const Head& head, const Tail&... tail);

It resizes each dimension of a multi-dimensional vector at once.

Example

Let us assume that the type of v is std::vector<std::vector<std::vector<int>>>. After calling tools::resize(v, 3, 4, 5);, v[x][y][z] for $0 \leq x < 3$, $0 \leq y < 4$ and $0 \leq z < 5$ will be available.

Constraints

• None

Time Complexity

• $O(N)$ where N is the product of the size of all dimensions

References

• C++ の 再帰template を使ったあまり使えない競プロ用 std::vector 操作テク - koyumeishiのブログ

License

• CC0

Author

• anqooqie

Required by

• Frequency table of digit products (tools/digit_product_frequency.hpp)
• Commonly used utilities for competitive programming (tools/util.hpp)

Verified with

• tests/digit_product_frequency.test.cpp
• tests/resize.test.cpp
• tests/util.test.cpp

Code

#ifndef TOOLS_RESIZE_HPP
#define TOOLS_RESIZE_HPP

#include <vector>
#include <cstddef>
#include <array>
#include <cassert>

namespace tools {
  template <class T, class Allocator, typename Head>
  void resize(::std::vector<T, Allocator>& vector, const Head& head) {
    vector.resize(head);
  }
  template <class T, ::std::size_t N, typename Head>
  void resize([[maybe_unused]] ::std::array<T, N>& array, [[maybe_unused]] const Head& head) {
    assert(array.size() == static_cast<::std::size_t>(head));
  }

  template <class T, class Allocator, typename Head, typename... Tail>
  void resize(::std::vector<T, Allocator>& vector, const Head& head, const Tail&... tail);
  template <class T, ::std::size_t N, typename Head, typename... Tail>
  void resize(::std::array<T, N>& array, const Head& head, const Tail&... tail);

  template <class T, class Allocator, typename Head, typename... Tail>
  void resize(::std::vector<T, Allocator>& vector, const Head& head, const Tail&... tail) {
    vector.resize(head);
    for (auto& child : vector) {
      ::tools::resize(child, tail...);
    }
  }
  template <class T, ::std::size_t N, typename Head, typename... Tail>
  void resize(::std::array<T, N>& array, [[maybe_unused]] const Head& head, const Tail&... tail) {
    assert(array.size() == static_cast<::std::size_t>(head));
    for (auto& child : array) {
      ::tools::resize(child, tail...);
    }
  }
}

#endif

#line 1 "tools/resize.hpp"



#include <vector>
#include <cstddef>
#include <array>
#include <cassert>

namespace tools {
  template <class T, class Allocator, typename Head>
  void resize(::std::vector<T, Allocator>& vector, const Head& head) {
    vector.resize(head);
  }
  template <class T, ::std::size_t N, typename Head>
  void resize([[maybe_unused]] ::std::array<T, N>& array, [[maybe_unused]] const Head& head) {
    assert(array.size() == static_cast<::std::size_t>(head));
  }

  template <class T, class Allocator, typename Head, typename... Tail>
  void resize(::std::vector<T, Allocator>& vector, const Head& head, const Tail&... tail);
  template <class T, ::std::size_t N, typename Head, typename... Tail>
  void resize(::std::array<T, N>& array, const Head& head, const Tail&... tail);

  template <class T, class Allocator, typename Head, typename... Tail>
  void resize(::std::vector<T, Allocator>& vector, const Head& head, const Tail&... tail) {
    vector.resize(head);
    for (auto& child : vector) {
      ::tools::resize(child, tail...);
    }
  }
  template <class T, ::std::size_t N, typename Head, typename... Tail>
  void resize(::std::array<T, N>& array, [[maybe_unused]] const Head& head, const Tail&... tail) {
    assert(array.size() == static_cast<::std::size_t>(head));
    for (auto& child : array) {
      ::tools::resize(child, tail...);
    }
  }
}

Back to top page