提出 #75294900

---

ソースコード 拡げる

#pragma GCC optimize("O3")
#include <bits/stdc++.h>

// clang-format off
using namespace std;
using ll = long long int;

#define all(v) (v).begin(),(v).end()
#define repeat(cnt,l) for(typename remove_const<typename remove_reference<decltype(l)>::type>::type cnt={};(cnt)<(l);++(cnt))
#define rrepeat(cnt,l) for(auto cnt=(l)-1;0<=(cnt);--(cnt))
#define iterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);++(cnt))
#define upto(cnt,b,e,step) for(auto cnt=(b);(cnt)<=(e);(cnt)+=(step))
#define downto(cnt,b,e,step) for(auto cnt=(b);(e)<=(cnt);(cnt)-=(step))
const long long MD = 998244353; const long double PI = 3.1415926535897932384626433832795L;
template<typename T1, typename T2> inline ostream& operator <<(ostream &o, const pair<T1, T2> p) { o << '(' << p.first << ':' << p.second << ')'; return o; }
template<typename T> inline T& chmax(T& to, const T& val) { return to = max(to, val); }
template<typename T> inline T& chmin(T& to, const T& val) { return to = min(to, val); }
void bye(string s, int code = 0) { cout << s << endl; exit(code); }
mt19937_64 randdev(8901016);
template<typename T, typename Random = decltype(randdev), typename enable_if<is_integral<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random& rand = randdev) { return uniform_int_distribution<T>(l, h)(rand); }
template<typename T, typename Random = decltype(randdev), typename enable_if<is_floating_point<T>::value>::type* = nullptr>
inline T rand(T l, T h, Random& rand = randdev) { return uniform_real_distribution<T>(l, h)(rand); }template<typename T>
static ostream& operator<<(ostream& o, const std::vector<T>& v) {
  o << "[ "; for(const auto& e : v) o<<e<<' '; return o << ']';
}

template <typename I> struct MyRangeFormat{ I b,e; MyRangeFormat(I _b, I _e):b(_b),e(_e){} };
template<typename I> static ostream& operator<<(ostream& o, const MyRangeFormat<I>& f) {
  o << "[ "; iterate(i,f.b,f.e) o<<*i<<' '; return o << ']';
}
template <typename I> struct MyMatrixFormat{
  const I& p; long long n, m;
  MyMatrixFormat(const I& _p, long long _n, long long _m):p(_p),n(_n),m(_m){}
};
template<typename I> static ostream& operator<<(ostream& o, const MyMatrixFormat<I>& f) {
  o<<'\n'; repeat(i,(f.n)) { repeat(j,f.m) o<<f.p[i][j]<<' '; o<<'\n'; }
  return o;
}
struct LOG_t { ~LOG_t() { clog << endl; } };
#define LOG (LOG_t(),clog<<'L'<<__LINE__<<": ")
#define FMTA(m,w) (MyRangeFormat<decltype(m+0)>(m,m+w))
#define FMTR(b,e) (MyRangeFormat<decltype(e)>(b,e))
#define FMTV(v) FMTR(v.begin(),v.end())
#define FMTM(m,h,w) (MyMatrixFormat<decltype(m+0)>(m,h,w))

#if defined(_WIN32) || defined(_WIN64)
#define getc_x _getc_nolock
#define putc_x _putc_nolock
#elif defined(__GNUC__)
#define getc_x getc_unlocked
#define putc_x putc_unlocked
#else
#define getc_x getc
#define putc_x putc
#endif
class MaiScanner {
  FILE* fp_;
  constexpr bool isvisiblechar(char c) noexcept { return (0x21<=(c)&&(c)<=0x7E); }
public:
  inline MaiScanner(FILE* fp):fp_(fp){}
  template<typename T> void input_integer(T& var) noexcept {
    var = 0; T sign = 1;
    int cc = getc_x(fp_);
    for (; cc < '0' || '9' < cc; cc = getc_x(fp_))
      if (cc == '-') sign = -1;
    for (; '0' <= cc && cc <= '9'; cc = getc_x(fp_))
      var = (var << 3) + (var << 1) + cc - '0';
    var = var * sign;
  }
  inline int c() noexcept { return getc_x(fp_); }
  template<typename T, typename enable_if<is_integral<T>::value, nullptr_t>::type = nullptr>
  inline MaiScanner& operator>>(T& var) noexcept { input_integer<T>(var); return *this; }
  inline MaiScanner& operator>>(string& var) {
    int cc = getc_x(fp_);
    for (; !isvisiblechar(cc); cc = getc_x(fp_));
    for (; isvisiblechar(cc); cc = getc_x(fp_))
      var.push_back(cc);
    return *this;
  }
  template<typename IT> inline void in(IT begin, IT end) { for (auto it = begin; it != end; ++it) *this >> *it; }
};
class MaiPrinter {
  FILE* fp_;
public:
  inline MaiPrinter(FILE* fp):fp_(fp){}
  template<typename T>
  void output_integer(T var) noexcept {
    if (var == 0) { putc_x('0', fp_); return; }
    if (var < 0)
      putc_x('-', fp_),
      var = -var;
    char stack[32]; int stack_p = 0;
    while (var)
      stack[stack_p++] = '0' + (var % 10),
      var /= 10;
    while (stack_p)
      putc_x(stack[--stack_p], fp_);
  }
  inline MaiPrinter& operator<<(char c) noexcept { putc_x(c, fp_); return *this; }
  template<typename T, typename enable_if<is_integral<T>::value, nullptr_t>::type = nullptr>
  inline MaiPrinter& operator<<(T var) noexcept { output_integer<T>(var); return *this; }
  inline MaiPrinter& operator<<(const char* str_p) noexcept { while (*str_p) putc_x(*(str_p++), fp_); return *this; }
  inline MaiPrinter& operator<<(const string& str) {
    const char* p = str.c_str();
    const char* l = p + str.size();
    while (p < l) putc_x(*p++, fp_);
    return *this;
  }
  template<typename IT> void join(IT begin, IT end, char sep = ' ') { for (bool b = 0; begin != end; ++begin, b = 1) b ? *this << sep << *begin : *this << *begin; }
};
MaiScanner scanner(stdin);
MaiPrinter printer(stdout);
// clang-format on

template <typename C = std::chrono::milliseconds> class Timer {
  std::chrono::system_clock::time_point tp_;

public:
  static inline auto now() { return std::chrono::system_clock::now(); }
  inline void tic() { tp_ = now(); }
  inline auto toc() const {
    return std::chrono::duration_cast<C>(now() - tp_).count();
  }
  inline Timer() : tp_(now()) {}
};
inline std::ostream &operator<<(std::ostream &o, const Timer<> &t) {
  return o << (long long)t.toc();
}

struct P {
  using T = int;
  T y, x;

  constexpr inline explicit P(T _y, T _x) : y(_y), x(_x) {}
  constexpr inline P() : y(0), x(0) {}

  constexpr inline bool operator==(P p) const { return y == p.y && x == p.x; }
  constexpr inline bool operator!=(P p) const { return y != p.y || x != p.x; }
  constexpr inline bool operator<(P p) const { return y == p.y ? x < p.x : y < p.y; }
  constexpr inline P operator+(P p) const { return P(y + p.y, x + p.x); }
  constexpr inline P operator-(P p) const { return P(y - p.y, x - p.x); }
  inline P &operator+=(P p) {
    y += p.y;
    x += p.x;
    return *this;
  }
  inline P &operator-=(P p) {
    y -= p.y;
    x -= p.x;
    return *this;
  }
  inline P &operator*=(T m) {
    y *= m;
    x *= m;
    return *this;
  }
  inline T distM(P p) const { return abs(y - p.y) + abs(x - p.x); }
  inline T distC(P p) const { return max(abs(y - p.y), abs(x - p.x)); }
  template <typename ITR> ITR nearestM(ITR begin, ITR end) const {
    if (begin == end)
      return end;
    T best = distM(*begin);
    ITR besti = begin;
    for (ITR it = begin; ++it, it != end;) {
      T m = distM(*it);
      if (best < m) {
        best = m;
        besti = it;
      }
    }
    return besti;
  }
};
inline ostream &operator<<(ostream &os, P p) {
  os << '(' << p.y << ',' << p.x << ')';
  return os;
}

enum DIR4 { UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3 };
enum DIR5 { UP5 = 0, RIGHT5 = 1, DOWN5 = 2, LEFT5 = 3, CENTER5 = 4 };
enum DIR8 { UP8 = 0, RIGHT8 = 1, DOWN8 = 2, LEFT8 = 3, UPLEFT8 = 4, UPRIGHT8 = 5, DOWNLEFT8 = 6, DOWNRIGHT8 = 7 };

const P kDir4[] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1)};
const P kDir5[] = {P(-1, 0), P(0, 1), P(1, 0), P(0, -1), P(0, 0)};
const P kDir8[] = {P(-1, 0),  P(0, 1),  P(1, 0),  P(0, -1),
                    P(-1, -1), P(-1, 1), P(1, -1), P(1, 1)};

inline P operator*(P::T m, P p) noexcept { return P(m * p.y, m * p.x); }

template <typename T>
// using T = int;
struct F {
  int height, width;
  vector<T> data;

  explicit F(int h, int w) : height(h), width(w), data(h * w) {}
  F() : F(1, 1) {}

  inline bool safe(int y, int x) const {
    return 0 <= y && y < height && 0 <= x && x < width;
  }
  inline bool safe(P p) const {
    return 0 <= p.y && p.y < height && 0 <= p.x && p.x < width;
  }

#if 1
  void assert_safe(int y, int x) const {
    if (!safe(y, x)) {
      clog << "assertion failed: field=" << height << "x" << width
           << ": try=" << y << "," << x << endl;
      assert(safe(y, x));
    }
  }
  inline T &operator()(int y, int x) {
    assert_safe(y, x);
    return data[x + y * width];
  }
  inline T &operator()(P p) {
    assert_safe(p.y, p. x);
    return data[p.x + p.y * width];
  }
  inline T operator()(int y, int x) const {
    assert_safe(y, x);
    return data[x + y * width];
  }
  inline T operator()(P p) const {
    assert_safe(p.y, p.x);
    return data[p.x + p.y * width];
  }
#else
  inline T &operator()(int y, int x) { return data[x + y * width]; }
  inline T &operator()(P p) { return data[p.x + p.y * width]; }
  inline T operator()(int y, int x) const { return data[x + y * width]; }
  inline T operator()(P p) const { return data[p.x + p.y * width]; }
#endif
  inline T getA(int i) const { return data[i]; }
  inline T &getAmut(int i) { return data[i]; }

  inline void fill(T e) { std::fill(data.begin(), data.end(), e); }
  inline void resize(int h, int w) {
    height = h;
    width = w;
    data.resize(h * w);
  }

  void print(ostream &os, int setw_arg = 4) {
    for (int y = 0; y < height; ++y) {
      for (int x = 0; x < width; ++x)
        os << setw(setw_arg) << operator()(y, x) << ' ';
      os << '\n';
    }
  }
};


class CommandLine {
  map<string, string> params;

  void initializeInternal(int argc, char **argv) {
    for (int i = 1; i < argc; ++i) {
      if (argv[i][0] == '-') { // TODO: `=` 区切りにしたい
        if (i + 1 < argc) {
          params.emplace(argv[i], argv[i + 1]);
          i += 1;
        }
      }
    }
  }

  CommandLine() = default;

public:
  static CommandLine &get() {
    static CommandLine g;
    return g;
  }
  static void initialize(int argc, char **argv) {
    get().initializeInternal(argc, argv);
  }
  const string &str(const string &key) {
    static const string empty_str;
    auto it = params.find(key);
    if (it == params.end()) {
      return empty_str;
    }
    return it->second;
  }
  long long number(const string &key, long long default_value = 0) {
    auto it = params.find(key);
    if (it == params.end()) {
      return default_value;
    }
    return atoi(it->second.c_str());
  }
};
//

namespace appenv {
// 起動引数
int g_k_parameter = 4;
} // namespace appenv

// ----------------------------------------------------------------------------

// レールの数
constexpr int R = 10;

// オンラインクエリなら不要
// オフラインクエリなら実装する
struct PInput {
  // init_pattern[r][i] = r番線のi番目の車両の番号
  array<vector<int>, R> init_pattern;
};

struct Command {
  // 0: 出発線 dep_id の末尾から連続する count 両を待避線 hold_id の先頭へ
  // 1: 待避線 hold_id の先頭から連続する count 両を出発線 dep_id の末尾へ
  int type;
  int dep_id;   // i: 出発線番号
  int hold_id;  // j: 待避線番号
  int count;    // k: 移動両数
};

struct PAnswer {
  vector<vector<Command>> roundToCommands;
};

// ------------------------------------

class Judge {
public:
  // オフラインクエリなら実装をそのまま使う
  virtual const PInput& input() = 0;
  virtual void output(const PAnswer &ans) = 0;
  virtual int score() = 0;
};

//

class JudgeStdio : public Judge {
  bool loaded_ = false;
  PInput pi_;
  int score_ = 0;

public:
  const PInput& input() override{
    if (loaded_)
      return pi_;
    loaded_ = true;
    int r;
    scanner >> r;
    // assert(r == R);
    repeat(i, R) {
      constexpr int n = 10;
      pi_.init_pattern[i].resize(n);
      scanner.in(all(pi_.init_pattern[i]));
    }
    return pi_;
  }

  void output(const PAnswer &ans) override{
    printer << ans.roundToCommands.size() << '\n';
    for (const auto &commands : ans.roundToCommands) {
      printer << commands.size() << '\n';
      for (const auto &cmd : commands) {
        printer << cmd.type << ' ' << cmd.dep_id << ' ' << cmd.hold_id << ' ' << cmd.count << '\n';
      }
    }
  }

  int score() override {
    return score_;
  }

  static int calcScore(const PInput& input, const PAnswer& answer) {
    // スコア計算のロジックをここに実装
    return 0;
  }
};

// ----------------------------------------------------------------------------

class Emulator {
public:
  array<deque<int>, R> dep_;   // 出発線: front=先頭, back=末尾(操作端)
  array<deque<int>, R> hold_;  // 待避線: front=先頭(操作端), back=末尾

  void init(const PInput& input) {
    for (int r = 0; r < R; r++) {
      dep_[r].clear();
      hold_[r].clear();
      for (int v : input.init_pattern[r]) {
        dep_[r].push_back(v);
      }
    }
  }

  void apply_turn(const vector<Command>& cmds) {
    for (const auto& cmd : cmds) {
      auto& d = dep_[cmd.dep_id];
      auto& h = hold_[cmd.hold_id];
      int k = cmd.count;
      if (cmd.type == 0) {
        // dep tail → hold front (k 両)
        int start = (int)d.size() - k;
        for (int i = k - 1; i >= 0; i--) {
          h.push_front(d[start + i]);
        }
        for (int i = 0; i < k; i++) d.pop_back();
      } else {
        // hold front → dep tail (k 両)
        for (int i = 0; i < k; i++) {
          d.push_back(h.front());
          h.pop_front();
        }
      }
    }
  }

  // 車両 v の待避線上の位置を返す: {hold_id, depth}
  pair<int,int> find_vehicle(int v) const {
    for (int r = 0; r < R; r++) {
      for (int i = 0; i < (int)hold_[r].size(); i++) {
        if (hold_[r][i] == v) return {r, i};
      }
    }
    return {-1, -1};
  }

  bool is_solved() const {
    for (int r = 0; r < R; r++) {
      if ((int)dep_[r].size() != 10) return false;
      for (int p = 0; p < 10; p++) {
        if (dep_[r][p] != 10 * r + p) return false;
      }
    }
    return true;
  }
};

// ----------------------------------------------------------------------------

// オフラインクエリ用（使うのはPInput）
class Solver {
  const PInput& input_;
  Emulator emu_;

  Solver(const PInput& input) : input_(input) {
    emu_.init(input);
  }

  // Phase 1: 全出発線を対応待避線へ退避 (1 ターン)
  void phase1(vector<vector<Command>>& turns) {
    vector<Command> cmds;
    for (int r = 0; r < R; r++) {
      cmds.push_back({0, r, r, 10});
    }
    turns.push_back(cmds);
    emu_.apply_turn(cmds);
  }

  // スクラッチ出発線の選択: r=0..8 なら dep[9]、r=9 なら dep[0]/dep[1]
  // d 両が収まるスクラッチを使ってターンを積む
  //   r < 9: 1 ターン (dep[9] に d 両)
  //   r = 9, d <= 5: 1 ターン (dep[0] に d 両)
  //   r = 9, d > 5:  2 ターン (dep[0] に 5 両 + dep[1] に d-5 両)
  void move_to_scratch(int r, int j, int d, vector<vector<Command>>& turns) {
    if (r < 9) {
      turns.push_back({{1, 9, j, d}});
      emu_.apply_turn(turns.back());
    } else if (d <= 5) {
      turns.push_back({{1, 0, j, d}});
      emu_.apply_turn(turns.back());
    } else {
      turns.push_back({{1, 0, j, 5}});
      emu_.apply_turn(turns.back());
      turns.push_back({{1, 1, j, d - 5}});
      emu_.apply_turn(turns.back());
    }
  }

  // スクラッチから待避線 j へ d 両を復元
  void restore_from_scratch(int r, int j, int d, vector<vector<Command>>& turns) {
    if (r < 9) {
      for (int i = 0; i < d; i++) {
        turns.push_back({{0, 9, j, 1}});
        emu_.apply_turn(turns.back());
      }
    } else if (d <= 5) {
      for (int i = 0; i < d; i++) {
        turns.push_back({{0, 0, j, 1}});
        emu_.apply_turn(turns.back());
      }
    } else {
      // dep[1] 側 (d-5 両) を先に戻す
      for (int i = 0; i < d - 5; i++) {
        turns.push_back({{0, 1, j, 1}});
        emu_.apply_turn(turns.back());
      }
      // dep[0] 側 (5 両) を戻す
      for (int i = 0; i < 5; i++) {
        turns.push_back({{0, 0, j, 1}});
        emu_.apply_turn(turns.back());
      }
    }
  }

  // Phase 2: 出発線 r を v=10r+p の順に 1 両ずつ構築
  void phase2(vector<vector<Command>>& turns) {
    for (int r = 0; r < R; r++) {
      for (int p = 0; p < 10; p++) {
        int v = 10 * r + p;
        auto [j, d] = emu_.find_vehicle(v);

        // Step A: v 手前の d 両をスクラッチへ退避
        if (d > 0) {
          move_to_scratch(r, j, d, turns);
        }

        // Step B: v を出発線 r の末尾へ
        turns.push_back({{1, r, j, 1}});
        emu_.apply_turn(turns.back());

        // Step C: d 両をスクラッチから待避線 j へ復元
        if (d > 0) {
          restore_from_scratch(r, j, d, turns);
        }
      }
    }
  }

  PAnswer solve() {
    vector<vector<Command>> turns;
    phase1(turns);
    phase2(turns);
    return PAnswer{turns};
  }

public:
  static void solve(Judge& judge) {
    const PInput& input = judge.input();
    Solver solver(input);
    judge.output(solver.solve());
  }
};

//

void appMain() {
  JudgeStdio judge;

  Solver::solve(judge);

  clog << "score = " << judge.score() << endl;
}

//

#define LOAD_CONSTANT_FROM_ARGS(konst, arg)                                    \
  {                                                                            \
    const string &v = CommandLine::get().str(arg);                             \
    if (!v.empty())                                                            \
      konst = atoi(v.c_str());                                                 \
  }

int main(int argc, char **argv) {
  using namespace appenv;
  CommandLine::initialize(argc, argv);
  LOAD_CONSTANT_FROM_ARGS(g_k_parameter,
                          "--a-parater");
  appMain();
  return 0;
}

提出情報

コンパイルエラー

./Main.cpp: In static member function 'static int JudgeStdio::calcScore(const PInput&, const PAnswer&)':
./Main.cpp:376:38: warning: unused parameter 'input' [-Wunused-parameter]
  376 |   static int calcScore(const PInput& input, const PAnswer& answer) {
      |                        ~~~~~~~~~~~~~~^~~~~
./Main.cpp:376:60: warning: unused parameter 'answer' [-Wunused-parameter]
  376 |   static int calcScore(const PInput& input, const PAnswer& answer) {
      |                                             ~~~~~~~~~~~~~~~^~~~~~

ジャッジ結果