結果
| 問題 |
No.1545 [Cherry 2nd Tune N] Anthem
|
| コンテスト | |
| ユーザー |
 Kanten4205
|
| 提出日時 | 2021-06-01 00:02:58 |
| 言語 | C++14 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 297 ms / 3,000 ms |
| コード長 | 23,423 bytes |
| コンパイル時間 | 3,065 ms |
| コンパイル使用メモリ | 209,044 KB |
| 実行使用メモリ | 43,496 KB |
| 最終ジャッジ日時 | 2024-12-14 21:45:15 |
| 合計ジャッジ時間 | 14,954 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| other | AC * 67 |
ソースコード
#include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
#define logn long
#define lnog long
#define lgon long
#define itn int
typedef long long ll;
typedef pair<long long, long long> P;
const long logn INF = 1e18;
//vector
//rep : A を N 回繰り返してくっつける
template <typename T>
vector<T> rep(vector<T>& A, long long N) {
vector<T> B;
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < A.size(); j++) {
B.push_back(A[j]);
}
}
return B;
}
//count_arr : A の中に key がいくつ含まれているか
template <typename T>
long long count_arr(vector<T>& A, T key) {
long long ans = 0;
for (long long i = 0; i < A.size(); i++) {
ans += (A.at(i) == key);
}
return ans;
}
//join : A の各要素を ch で結合した文字列
template <typename Q>
string join(vector<Q>& A, char ch) {
string S;
for (long long i = 0; i < A.size(); i++) {
string T = to_string(A.at(i));
long long j = 0;
while (j < T.size()) {
S.push_back(T[j]);
j++;
}
if (i != A.size() - 1) S.push_back(ch);
}
return S;
}
//sorted : A をソートした配列を返す
template<typename T>
vector<T> sorted(vector<T>& A) {
vector<T>B = A;
sort(B.begin(), B.end());
return B;
}
//reversed : A を反転させた配列を返す
template<typename T>
vector<T> reversed(vector<T>& A) {
vector<T>B = A;
reverse(B.begin(), B.end());
return B;
}
//max_arr : A の中の最大値を返す
template<typename T>
T max_arr(vector<T>& A) {
long long num = -10000000000000007;
for (long long i = 0; i < A.size(); i++) {
if (A[i] > num) num = A[i];
}
return num;
}
//min_arr : A の中の最小値を返す
template<typename T>
T min_arr(vector<T>& A) {
long long num = 10000000000000007;
for (long long i = 0; i < A.size(); i++) {
if (A[i] < num) num = A[i];
}
return num;
}
//Data stracture
//UnionFind
struct UnionFind {
vector<long long> par, siz;
//初期化
UnionFind(long long N) : par(N, -1), siz(N, 1) {}
//根を求める
long long root(long long x) {
if (par[x] == -1) return x; //x自身が根である
else return par[x] = root(par[x]);
}
//x と y が同じグループに属するかどうか
bool same(long long x, long long y) {
return root(x) == root(y);
}
//x を含むグループと y を含むグループを併合
bool unite(long long x, long long y) {
//x, y をそれぞれ根まで移動
x = root(x); y = root(y);
//既に x と y が同グループに属するなら false
if (x == y) return false;
//union by size
if (siz[x] < siz[y]) swap(x, y);
//y を x の子にする
par[y] = x;
siz[x] += siz[y];
return true;
}
//x を含むグループのサイズ
long long size(long long x) {
return siz[root(x)];
}
//連結成分の個数をカウント
long long count() {
long long ans = 0;
for (long long i = 0; i < (long long)par.size(); i++) {
ans += (root(i) == i);
}
return ans;
}
};
//区間最小値を求めるセグ木
template <typename T>
struct RMQ {
const T INF = 2147483647;
int N; //number of leaves
vector<T> dat; //perfect binary tree
RMQ(int n_) : N(), dat(n_ * 4, INF) { //The number of leaves can be displayed by the formula, 2 ^ x.
int x = 1;
while (n_ > x) {
x *= 2;
}
N = x;
}
void update(long long i, T x) {
i += N - 1;
dat.at(i) = x;
while (i > 0) {
i = (i - 1) / 2; //parent
dat.at(i) = min(dat.at(i * 2 + 1), dat.at(i * 2 + 2));
}
}
//the minimum element of [a, b)
T query(long long a, long long b) {
return query_sub(a, b, 0, 0, N);
}
T query_sub(long long a, long long b, long long k, long long l, long long r) {
if (r <= a || b <= l) {
return INF;
}
else if (a <= l && r <= b) {
return dat.at(k);
}
else {
T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
};
//関数
//input_arr : 配列 A を入力
template <typename T>
void input_arr(vector<T>& A, long long N) {
for (long long i = 0; i < N; i++) {
cin >> A[i];
}
}
//output_arr : 配列 A を出力
template <typename T>
void output_arr(vector<T>& A, long long N) {
for (long long i = 0; i < N; i++) {
cout << A[i];
if (i != N - 1) cout << ' ';
}
cout << endl;
}
//GCD : GCD
long long GCD(long long A, long long B) { return(B == 0 ? A : GCD(B, A % B)); }
//LCM : LCM
long long LCM(long long A, long long B) { return A / GCD(A, B) * B; }
//elements : Aに含まれる要素は何種類か
template <typename T>
long long elements(vector<T>& A) {
sort(A.begin(), A.end());
long long ans = 1;
for (long long i = 1; i < A.size(); i++) {
if (A[i] != A[i - 1]) ans++;
}
return ans;
}
//prime_factorization : 素因数分解
vector<P> prime_factorization(long long N) {
vector<P>A;
long long tmp = N;
for (long long i = 2; i * i <= N; i++) {
if (tmp % i == 0) {
A.push_back({ i, 0 });
while (tmp % i == 0) {
A.back().second++;
tmp /= i;
}
}
}
if (tmp != 1) A.push_back({ tmp, 1 });
return A;
}
//power : M^N(mod MOD)
long long power(long long N, long long M, long long MOD) {
long long ans = 1;
while (M > 0) {
if (M & 1) {
ans = ans * N % MOD;
}
N = N * N % MOD;
M >>= 1;
}
return ans;
}
//Euler_phi : オイラー関数
long long Euler_phi(long long N) {
vector<P>A = prime_factorization(N);
for (long long i = 0; i < A.size(); i++) {
N /= A[i].first;
}
for (long long i = 0; i < A.size(); i++) {
N *= (A[i].first - 1);
}
return N;
}
//extgcd : 拡張ユークリッド互除法（返すのは gcd(A,B),AX + BY = GCD(A,B)）
long long extgcd(long long A, long long B, long long& X, long long& Y) {
long long D = A;
if (B != 0) {
D = extgcd(B, A % B, Y, X);
Y -= (A / B) * X;
}
else {
X = 1; Y = 0;
}
return D;
}
//計算幾何
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
//Point : 点(x, y)(点の座標(x,y)、ベクトル演算(+,-,*,/)、ベクトルのノルム(norm)、大きさ(abs)、大小比較(<)、合同を保存(==))
class Point {
public:
double x;
double y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point& p) const {
return x != p.x ? x < p.x : y < p.y;
}
bool operator==(const Point& p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
//Vector : ベクトル（配列のvectorと間違えぬように）
typedef Point Vector;
//Segment : 線分AB(点A, Bの座標を保存)
struct Segment {
Point A;
Point B;
};
//Line : 直線AB
typedef Segment Line;
//Circle : 円(中心点C、半径r を保存)
class Circle {
public:
Point C;
double r;
Circle(Point C = Point(), double r = 0.0) : C(C), r(r) {}
};
//Polygon : 多角形（各頂点の点列で表す）
typedef vector<Point> Polygon;
//dot : ベクトルA, B の内積
double dot(Vector A, Vector B) {
return A.x * B.x + A.y * B.y;
}
//cross : ベクトルA, B の外積
double cross(Vector A, Vector B) {
return A.x * B.y - A.y * B.x;
}
//Projection : 射影(点pを通る、直線Sへの垂線の足の座標)
Point Projection(Segment S, Point p) {
Vector base = S.B - S.A;
double r = dot(p - S.A, base) / base.norm();
return S.A + base * r;
}
//Reflection : 反射(直線Sに関して、点pと対称な点の座標)
Point Reflection(Segment S, Point p) {
return p + (Projection(S, p) - p) * 2.0;
}
//isOrthogonal : 直交しているか？ <==> ベクトルA, B の内積は0か？
bool isOrthogonal(Vector A, Vector B) {
return equals(dot(A, B), 0.0);
}
bool isOrthogonal(Point A1, Point A2, Point B1, Point B2) {
return isOrthogonal(A1 - A2, B1 - B2);
}
bool isOrthogonal(Segment S1, Segment S2) {
return equals(dot(S1.B - S1.A, S2.B - S2.A), 0.0);
}
//isParallel : 平行か？ <==> ベクトルA, B の外積は0か？
bool isParallel(Vector A, Vector B) {
return equals(cross(A, B), 0.0);
}
bool isParallel(Point A1, Point A2, Point B1, Point B2) {
return isParallel(A1 - A2, B1 - B2);
}
bool isParallel(Segment S1, Segment S2) {
return equals(cross(S1.B - S1.A, S2.B - S2.A), 0.0);
}
//getDistance : 2点A,Bの距離
double getDistance(Point A, Point B) {
return (A - B).abs();
}
//getDistanceLP : 直線Lと点Pの距離
double getDistanceLP(Line L, Point P) {
return abs((cross(L.B - L.A, P - L.A))) / (L.B - L.A).abs();
}
//getDistanceSP : 線分Sと点Pの距離
double getDistanceSP(Segment S, Point P) {
if (dot(S.B - S.A, P - S.A) < 0.0) return (P - S.A).abs();
if (dot(S.A - S.B, P - S.B) < 0.0) return (P - S.B).abs();
return getDistanceLP(S, P);
}
//定数定義
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
//ccw : 3点A,B,Cがこの順に反時計回りか？
int ccw(Point A, Point B, Point C) {
Vector S = B - A, T = C - A;
if (cross(S, T) > EPS) return COUNTER_CLOCKWISE; //反時計回り
if (cross(S, T) < -EPS) return CLOCKWISE; //時計回り
if (dot(S, T) < -EPS) return ONLINE_BACK; //C,A,Bの順で同一直線上にある
if (S.norm() < T.norm()) return ONLINE_FRONT; //A,B,Cの順で同一直線上にある
return ON_SEGMENT; //Cが線分AB上にある
}
//intersect : 線分AB, CDは交差するか？
bool intersect(Point A, Point B, Point C, Point D) {
return (ccw(A, B, C) * ccw(A, B, D) <= 0 && ccw(C, D, A) * ccw(C, D, B) <= 0);
}
bool intersect(Segment S1, Segment S2) {
return intersect(S1.A, S1.B, S2.A, S2.B);
}
//別のintersect : 円Cと直線Lが交差するかどうか
bool intersect(Circle C, Line L) {
return (getDistanceLP(L, C.C) <= C.r);
}
//getDistance : 線分S1, S2 の距離もこの関数で導入
double getDistance(Segment S1, Segment S2) {
if (intersect(S1, S2)) return 0.0;
return min(min(getDistanceSP(S1, S2.A), getDistanceSP(S1, S2.B)), min(getDistanceSP(S2, S1.A), getDistanceSP(S2, S1.B)));
}//getCrossPoint : 線分S1, S2 の交点(線分AB, 線分CD の交点)
Point getCrossPoint(Segment S1, Segment S2) {
Vector base = S2.B - S2.A;
double d1 = abs(cross(base, S1.A - S2.A));
double d2 = abs(cross(base, S1.B - S2.A));
double T = d1 / (d1 + d2);
return S1.A + (S1.B - S1.A) * T;
}
Point getCrossPoint(Point A, Point B, Point C, Point D) {
Vector base = D - C;
double d1 = abs(cross(base, A - C));
double d2 = abs(cross(base, B - C));
double T = d1 / (d1 + d2);
return A + (B - A) * T;
}
//getCrossPoints : 円Cと直線Lの交点（2つ以下のため、pairで管理）
pair<Point, Point> getCrossPoints(Circle C, Line L) {
assert(intersect(C, L));
Vector pr = Projection(L, C.C);
Vector e = (L.B - L.A) / (L.B - L.A).abs();
double base = sqrt(C.r * C.r - (pr - C.C).norm());
return make_pair(pr + e * base, pr - e * base);
}
//グラフを表す構造体
struct Graph {
//辺を表す構造体
//rev : 逆辺 (to, from) が G[to] の中で何番目の要素か
//cap : 辺 (from, to) の容量
struct Edge {
long long rev, from, to, cap;
Edge(long long r, long long f, long long t, long long c) :
rev(r), from(f), to(t), cap(c) {}
};
//隣接リスト
vector<vector<Edge>> list;
//N : 頂点数
Graph(long long N = 0) : list(N) {}
//グラフの頂点数取得
size_t size() {
return list.size();
}
//Graph インスタンスを G として、
// G.list[v] を G[v] と書けるようにしておく
vector<Edge>& operator [] (long long i) {
return list[i];
}
//辺 e = (u, v) の逆辺 (v, u) を取得する
Edge& redge(const Edge& e) {
return list[e.to][e.rev];
}
//辺 e = (u, v) に流量 f のフローを流す
//e = (u, v) の流量が f だけ減少する
//この時、逆辺 (v, u) の流量を増やす
void run_flow(Edge& e, long long f) {
e.cap -= f;
redge(e).cap += f;
}
//頂点 from から頂点 to へ容量 cap の辺を張る
//このとき to から from へも容量 0 の辺を張っておく
void addedge(long long from, long long to, long long cap) {
long long fromrev = (long long)list[from].size();
long long torev = (long long)list[to].size();
list[from].push_back(Edge(torev, from, to, cap));
list[to].push_back(Edge(fromrev, to, from, 0));
}
};
struct Ford_Fulkerson {
static const int INF = 1 << 30;
vector<long long> seen;
Ford_Fulkerson() {}
//残余グラフ上で s-t パスを見つける（DFS）
//返り値は s-t パス上の容量の最小値（見つからなかったら 0）
//f: s から v へ到達した過程の各辺の容量の最小値
long long fodfs(Graph& G, long long v, long long t, long long f) {
//終端 t に到達したらリターン
if (v == t) return f;
//DFS
seen[v] = true;
for (auto& e : G[v]) {
if (seen[e.to]) continue;
//容量 0 の辺は実際には存在しない
if (e.cap == 0) continue;
//s-t パスを探す
//見つかったら flow はパス上の最小容量
//見つからなかったら f = 0
long long flow = fodfs(G, e.to, t, min(f, e.cap));
//s-t パスが見つからなかったら次辺を試す
if (flow == 0) continue;
//辺 e に容量 flow のフローを流す
G.run_flow(e, flow);
//s-t パスを見つけたらパス上最小容量を返す
return flow;
}
//s-t パスが見つからなかったことを示す
return 0;
}
//グラフ G の s-t 間の最大流量を求める
//ただしリターン時に G は残余グラフになる
long long solve(Graph& G, long long s, long long t) {
long long res = 0;
//残余グラフに s-t パスがなくなるまで反復
while (true) {
seen.assign((long long)G.size(), 0);
long long flow = fodfs(G, s, t, INF);
//s-t パスが見つからなかったら終了
if (flow == 0) return res;
//答えを加算
res += flow;
}
//no reach
return 0;
}
};
bool isprime(long long N) {
if (N < 2) return false;
for (long long i = 2; i * i <= N; i++) {
if (N % i == 0) return false;
}
return true;
}
struct EDGE {
long long to;
long long cost;
};
void dijkstra(const vector<vector<EDGE>>& G, int s, vector<long long>& dis, vector<long long>& prev) {
int N = G.size();
dis.resize(N, INF);
prev.resize(N, -1); // 初期化
priority_queue<P, vector<P>, greater<P>> pq;
dis[s] = 0;
pq.emplace(dis[s], s);
while (!pq.empty()) {
P p = pq.top();
pq.pop();
int v = p.second;
if (dis[v] < p.first) {
continue;
}
for (auto& e : G[v]) {
if (dis[e.to] > dis[v] + e.cost) {
dis[e.to] = dis[v] + e.cost;
prev[e.to] = v; // 頂点 v を通って e.to にたどり着いた
pq.emplace(dis[e.to], e.to);
}
}
}
}
//find : A 内に key のある位置（ないなら -1 ）
long long find(vector<long long>& A, long long key) {
if (A.empty()) return -1;
long long left = 0, right = A.size() - 1;
while (left <= right) {
long long mid = (left + right) / 2;
if (A[mid] == key) return mid;
else if (A[mid] < key) left = mid + 1;
else right = mid - 1;
}
return -1;
}
void BFS(vector<vector<long long>>& G, long long s, vector<long long>& dist) {
queue<long long>Q;
dist[s] = 0; Q.push(s);
while (!Q.empty()) {
long long v = Q.front(); Q.pop();
for (auto nv : G[v]) {
if (dist[nv] == INF) {
dist[nv] = dist[v] + 1;
Q.push(nv);
}
}
}
}
vector<int> string_to_bigint(string S) {
int N = S.size(); // N = (文字列 S の長さ)
vector<int> digit(N);
for (int i = 0; i < N; ++i) {
digit[i] = S[N - i - 1] - '0'; // 10^i の位の数
}
return digit;
}
string bigint_to_string(vector<int> digit) {
int N = digit.size(); // N = (配列 digit の長さ)
string str = "";
for (int i = N - 1; i >= 0; --i) {
str += digit[i] + '0';
}
return str;
}
vector<int> carry_and_fix(vector<int> digit) {
int N = digit.size();
for (int i = 0; i < N - 1; ++i) {
// 繰り上がり処理 (K は繰り上がりの回数)
if (digit[i] >= 10) {
int K = digit[i] / 10;
digit[i] -= K * 10;
digit[i + 1] += K;
}
// 繰り下がり処理 (K は繰り下がりの回数)
if (digit[i] < 0) {
int K = (-digit[i] - 1) / 10 + 1;
digit[i] += K * 10;
digit[i + 1] -= K;
}
}
// 一番上の桁が 10 以上なら、桁数を増やすことを繰り返す
while (digit.back() >= 10) {
int K = digit.back() / 10;
digit.back() -= K * 10;
digit.push_back(K);
}
// 1 桁の「0」以外なら、一番上の桁の 0 (リーディング・ゼロ) を消す
while (digit.size() >= 2 && digit.back() == 0) {
digit.pop_back();
}
return digit;
}
vector<int> multiplication(vector<int> digit_a, vector<int> digit_b) {
int NA = digit_a.size(); // A の桁数
int NB = digit_b.size(); // B の桁数
vector<int> res(NA + NB - 1);
for (int i = 0; i < NA; ++i) {
for (int j = 0; j < NB; ++j) {
res[i + j] += digit_a[i] * digit_b[j];
// 答えの i+j の位に digit_a[i] * digit_b[j] を足す
}
}
return carry_and_fix(res);
}
struct triple {
long long a; long long b; long long c;
};
const long long MOD = (long long)2e18;
const int MAX_C = 61;
long long Com[MAX_C][MAX_C];
void calc_com() {
memset(Com, 0, sizeof(Com));
Com[0][0] = 1;
for (int i = 1; i < MAX_C; ++i) {
Com[i][0] = 1;
for (int j = 1; j < MAX_C; ++j) {
Com[i][j] = (Com[i - 1][j - 1] + Com[i - 1][j]) % MOD;
}
}
}
vector<long long> get_path(const vector<long long>& prev, long long t, const vector<long long>& dist) {
vector<long long> path;
for (int cur = t; cur != -1; cur = prev[cur]) {
path.push_back(cur);
}
reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
return path;
}
long long calc = 0;
vector<long long> BFS_num(vector<vector<long long>>& G, long long s, vector<long long>& dist, vector<long long>& st, long long M) {
vector<long long>D(M, 0);
queue<long long>Q;
long long ans = 0;
dist[s] = 0; D[st[s]] = 1; Q.push(s);
while (!Q.empty()) {
long long v = Q.front(); Q.pop();
for (auto nv : G[v]) {
if (dist[nv] == -1) {
calc++;
dist[nv] = dist[v] + 1;
if (dist[nv] + st[s] == st[nv]) D[st[nv]]++;
Q.push(nv);
}
}
}
return D;
}
int main() {
ll N, S, T, K; cin >> N >> S >> T >> K;
vector<ll> X(N + 1);
for (int i = 1; i <= N; i++) cin >> X[i];
ll M; cin >> M;
vector<vector<P>>E(N + 1);
ll A, B, Y;
for (int i = 0; i < M; i++) {
cin >> A >> B >> Y;
E[A].push_back({ B, Y });
}
vector<vector<ll>> DP(N + 1, vector<ll>(K + 1, INF));
DP[S][1] = X[S];
vector<vector<P>>Prev(N + 1, vector<P>(K + 1, { 0, 0 }));
priority_queue<pair<ll, P>, vector<pair<ll, P>>, greater<pair<ll, P>>>Q;
Q.push(make_pair(0LL, make_pair(S, 1)));
pair<ll, P> R;
ll d, x, k, y, m;
while (!Q.empty()) {
R = Q.top();
Q.pop();
d = R.first;
x = R.second.first;
k = R.second.second;
if (DP[x][k] < d) continue;
if (x == T && k == K) break;
long long L = min(K, k + 1);
for (P a : E[x]) {
y = a.first, m = a.second;
if (DP[x][k] + m + X[y] < DP[y][L]) {
DP[y][L] = DP[x][k] + m + X[y];
Prev[y][L] = { x, k };
Q.push({ DP[y][L],{y,L} });
}
}
}
if (DP[T][K] >= INF) {
cout << "Impossible" << endl;
return 0;
}
x = T;
k = K;
vector<ll>Z;
while (k > 0) {
Z.push_back(x);
P ans = Prev[x][k];
x = ans.first; k = ans.second;
}
cout << "Possible" << endl << DP[T][K] << endl << Z.size() << endl;
for (long long i = Z.size() - 1; i >= 0; i--) {
if (i != Z.size() - 1) cout << ' ';
cout << Z[i];
}
cout << endl;
}