結果

問題 No.2947 Sing a Song
ユーザー ooaiuooaiu
提出日時 2024-11-18 21:58:35
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 4 ms / 2,000 ms
コード長 7,601 bytes
コンパイル時間 2,934 ms
コンパイル使用メモリ 252,696 KB
実行使用メモリ 6,820 KB
最終ジャッジ日時 2024-11-18 21:58:43
合計ジャッジ時間 6,357 ms
ジャッジサーバーID
(参考情報)
judge1 / judge5
このコードへのチャレンジ
(要ログイン)

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,820 KB
testcase_01 AC 2 ms
6,820 KB
testcase_02 AC 2 ms
6,820 KB
testcase_03 AC 2 ms
6,816 KB
testcase_04 AC 2 ms
6,816 KB
testcase_05 AC 2 ms
6,816 KB
testcase_06 AC 2 ms
6,816 KB
testcase_07 AC 2 ms
6,816 KB
testcase_08 AC 2 ms
6,820 KB
testcase_09 AC 2 ms
6,820 KB
testcase_10 AC 2 ms
6,816 KB
testcase_11 AC 2 ms
6,820 KB
testcase_12 AC 3 ms
6,816 KB
testcase_13 AC 3 ms
6,820 KB
testcase_14 AC 2 ms
6,820 KB
testcase_15 AC 2 ms
6,820 KB
testcase_16 AC 3 ms
6,816 KB
testcase_17 AC 3 ms
6,816 KB
testcase_18 AC 3 ms
6,820 KB
testcase_19 AC 2 ms
6,820 KB
testcase_20 AC 3 ms
6,816 KB
testcase_21 AC 3 ms
6,816 KB
testcase_22 AC 2 ms
6,820 KB
testcase_23 AC 3 ms
6,816 KB
testcase_24 AC 3 ms
6,820 KB
testcase_25 AC 4 ms
6,816 KB
testcase_26 AC 3 ms
6,816 KB
testcase_27 AC 4 ms
6,816 KB
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#ifndef LOCAL
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128_t;
using u128 = __uint128_t;
namespace fastio {
static constexpr int BUF_SIZE = 1 << 20;
struct Pre {
char num[10000][4];
constexpr Pre() : num() {
for (int i = 0; i < 10000; i++) {
int n = i;
for (int j = 3; j >= 0; j--) {
num[i][j] = n % 10 | '0';
n /= 10;
}
}
}
} constexpr pre;
static struct FastOutput {
private:
static constexpr int TMP_SIZE = 1 << 10;
char tmp[TMP_SIZE];
char buf[BUF_SIZE];
size_t buf_pos = 0;
template <class T>
inline char* wt_integer(T x) {
char* p = tmp + TMP_SIZE - 1;
if (x == 0) {
*--p = '0';
} else {
bool is_negative = false;
if (x < 0) {
is_negative = true;
x = -x;
}
while (x >= 10000) {
memcpy(p -= 4, pre.num[x % 10000], 4);
x /= 10000;
}
if (x >= 1000) {
memcpy(p -= 4, pre.num[x], 4);
} else if (x >= 100) {
memcpy(p -= 3, pre.num[x] + 1, 3);
} else if (x >= 10) {
memcpy(p -= 2, pre.num[x] + 2, 2);
} else {
*--p = pre.num[x][3];
}
if (is_negative) *--p = '-';
}
return p;
}
template <class T, size_t N = 0>
inline void wt_tuple(const T& t) {
if constexpr (N < std::tuple_size<T>::value) {
if constexpr (N > 0) wt(' ');
const auto x = std::get<N>(t);
wt(x);
wt_tuple<T, N + 1>(t);
}
}
public:
inline void wt(char c) {
buf[buf_pos++] = c;
if (buf_pos == BUF_SIZE) flush();
}
inline void wt(const char* s) {
for (; *s != '\0'; s++) {
wt(*s);
}
}
inline void wt(const std::string& s) {
for (char c : s) wt(c);
}
template <class Tp>
inline std::enable_if_t<std::is_floating_point_v<Tp>>
wt(const Tp& x) {
std::ostringstream oss;
oss << std::fixed << std::setprecision(16) << x;
wt(oss.str());
}
template <class Tp>
inline std::enable_if_t<std::is_integral_v<Tp>>
wt(const Tp& x) { wt(wt_integer(x)); }
inline void wt(const __int128_t& x) { wt(wt_integer(x)); }
inline void wt(const __uint128_t& x) { wt(wt_integer(x)); }
template <class T, class U>
inline void wt(const std::pair<T, U>& p) {
wt(p.first);
wt(' ');
wt(p.second);
}
template <class... Args>
inline void wt(const std::tuple<Args...>& t) {
wt_tuple(t);
}
template <class T, size_t N = 0>
inline void wt(const std::array<T, N>& a) {
for (size_t i = 0; i < N; i++) {
if (i) wt(' ');
wt(a[i]);
}
}
template <class T>
inline void wt(const std::vector<T>& x) {
for (size_t i = 0; i < x.size(); i++) {
if (i) wt(' ');
wt(x[i]);
}
}
inline void flush() {
fwrite(buf, 1, buf_pos, stdout);
buf_pos = 0;
}
~FastOutput() { flush(); }
} fastout;
static struct FastInput {
private:
char buf[BUF_SIZE];
size_t buf_pos = 0;
size_t size = 0;
char cur = 0;
inline char rd_char() {
if (buf_pos >= size) {
size = fread(buf, 1, BUF_SIZE, stdin);
buf_pos = 0;
buf[0] = (size == 0 ? -1 : buf[0]);
}
return cur = buf[buf_pos++];
}
template <class Tp>
inline void rd_integer(Tp& x) {
x = Tp{};
if (skip_blanks()) {
int sign = +1;
if (cur == '-') {
sign = -1;
rd_char();
}
do {
x += x + (x << 3) + (cur & 15);
} while (!is_blank(rd_char()));
x *= sign;
}
}
inline bool is_blank(char c) { return c <= ' '; }
inline bool skip_blanks() {
while (is_blank(cur) && cur != -1) {
rd_char();
}
return cur != -1;
}
template <class T, size_t N = 0>
void rd_tuple(T& t) {
if constexpr (N < std::tuple_size<T>::value) {
auto& x = std::get<N>(t);
rd(x);
rd_tuple<T, N + 1>(t);
}
}
public:
inline void rd(char& c) {
skip_blanks();
c = cur;
}
inline void rd(std::string& s) {
if (skip_blanks()) {
s.clear();
do {
s += cur;
} while (!is_blank(rd_char()));
}
}
template <class T>
inline auto rd(T& x) -> std::void_t<std::enable_if_t<std::is_integral<T>::value>> { rd_integer(x); }
inline auto rd(__int128_t& x) { rd_integer(x); }
inline auto rd(__uint128_t& x) { rd_integer(x); }
inline void rd(double& x) {
std::string s;
rd(s);
x = std::stod(s);
}
inline void rd(long double& x) {
std::string s;
rd(s);
x = std::stold(s);
}
template <class T, class U>
void rd(std::pair<T, U>& p) {
rd(p.first);
rd(p.second);
}
template <class... Args>
void rd(std::tuple<Args...>& t) {
rd_tuple(t);
}
template <class T, size_t N>
void rd(std::array<T, N>& x) {
for (auto& d : x) rd(d);
}
template <class T>
void rd(std::vector<T>& x) {
for (auto& d : x) rd(d);
}
} fastin;
inline void flush() { fastout.flush(); }
void IN() {}
template <class Head, class... Tails>
void IN(Head& head, Tails&... tails) {
fastin.rd(head);
IN(tails...);
}
template <class Last>
void print(const Last& last) { fastout.wt(last); }
template <class Head, class... Tails>
void print(const Head& head, const Tails&... tails) {
fastout.wt(head);
fastout.wt(' ');
print(tails...);
}
template <class... Args>
void println(const Args&... args) {
print(args...);
fastout.wt('\n');
}
} // namespace fastio
using fastio::flush;
using fastio::IN;
using fastio::print;
using fastio::println;
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
long long __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHAR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
IN(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
IN(name)
#define VV(type, name, h, w) \
vector<vector<type>> name(h, vector<type>(w)); \
IN(name)
#define debug(...) (void(0))
#else
#include "algo/debug.h"
#endif
void solve() {
INT(N);
STR(S, T);
VEC(int, A, N);
for (int i = 0; i < N; i++) {
int mx = 0;
for (unsigned j = 0; j <= A[i] / S.size(); j++) {
int k = A[i] - j * (int)S.size();
if (k % (int)T.size() == 0) {
mx = j;
}
}
for (int j = 0; j < mx; j++) {
print(S);
print(' ');
}
for (unsigned j = 0; j < (A[i] - mx * S.size())/T.size(); j++) {
if (j) print(' ');
print(T);
}
print('\n');
}
}
int main() {
int T = 1;
// std::cin >> T;
while (T--) {
solve();
}
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0