結果

問題 No.1078 I love Matrix Construction
ユーザー iiljj
提出日時 2020-06-13 20:31:42
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 536 ms / 2,000 ms
コード長 11,269 bytes
コンパイル時間 2,912 ms
コンパイル使用メモリ 212,288 KB
最終ジャッジ日時 2025-01-11 03:58:21
ジャッジサーバーID
(参考情報)
judge5 / judge3
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 22
権限があれば一括ダウンロードができます

ソースコード

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

/* #region Head */
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pll = pair<ll, ll>;
template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;
using vll = vc<ll>;
using vvll = vvc<ll>;
using vld = vc<ld>;
using vvld = vvc<ld>;
using vs = vc<string>;
using vvs = vvc<string>;
template <class T, class U> using um = unordered_map<T, U>;
template <class T> using pq = priority_queue<T>;
template <class T> using pqa = priority_queue<T, vc<T>, greater<T>>;
template <class T> using us = unordered_set<T>;
#define REP(i, m, n) for (ll i = (m), i##_len = (ll)(n); i < i##_len; ++(i))
#define REPM(i, m, n) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; ++(i))
#define REPR(i, m, n) for (ll i = (m), i##_min = (ll)(n); i >= i##_min; --(i))
#define REPD(i, m, n, d) for (ll i = (m), i##_len = (ll)(n); i < i##_len; i += (d))
#define REPMD(i, m, n, d) for (ll i = (m), i##_max = (ll)(n); i <= i##_max; i += (d))
#define REPI(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define ALL(x) begin(x), end(x)
#define SIZE(x) ((ll)(x).size())
#define PERM(c) \
sort(ALL(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(ALL(c)))
#define UNIQ(v) v.erase(unique(ALL(v)), v.end());
#define endl '\n'
#define sqrt sqrtl
#define floor floorl
#define log2 log2l
constexpr ll INF = 1'010'000'000'000'000'017LL;
constexpr ll MOD = 1'000'000'007LL; // 1e9 + 7
constexpr ld EPS = 1e-12;
constexpr ld PI = 3.14159265358979323846;
template <typename T> istream &operator>>(istream &is, vc<T> &vec) { // vector
for (T &x : vec) is >> x;
return is;
}
template <typename T> ostream &operator<<(ostream &os, vc<T> &vec) { // vector (for dump)
os << "{";
REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "" : ", ");
os << "}";
return os;
}
template <typename T> ostream &operator>>(ostream &os, vc<T> &vec) { // vector (inline)
REP(i, 0, SIZE(vec)) os << vec[i] << (i == i_len - 1 ? "\n" : " ");
return os;
}
template <typename T, typename U> istream &operator>>(istream &is, pair<T, U> &pair_var) { // pair
is >> pair_var.first >> pair_var.second;
return is;
}
template <typename T, typename U> ostream &operator<<(ostream &os, pair<T, U> &pair_var) { // pair
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// map, um, set, us
template <class T> ostream &out_iter(ostream &os, T &map_var) {
os << "{";
REPI(itr, map_var) {
os << *itr;
auto itrcp = itr;
if (++itrcp != map_var.end()) os << ", ";
}
return os << "}";
}
template <typename T, typename U> ostream &operator<<(ostream &os, map<T, U> &map_var) { return out_iter(os, map_var); }
template <typename T, typename U> ostream &operator<<(ostream &os, um<T, U> &map_var) {
os << "{";
REPI(itr, map_var) {
auto [key, value] = *itr;
os << "(" << key << ", " << value << ")";
auto itrcp = itr;
if (++itrcp != map_var.end()) os << ", ";
}
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, us<T> &set_var) { return out_iter(os, set_var); }
template <typename T> ostream &operator<<(ostream &os, pq<T> &pq_var) {
pq<T> pq_cp(pq_var);
os << "{";
if (!pq_cp.empty()) {
os << pq_cp.top(), pq_cp.pop();
while (!pq_cp.empty()) os << ", " << pq_cp.top(), pq_cp.pop();
}
return os << "}";
}
// dump
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail> void dump_func(Head &&head, Tail &&... tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) DUMPOUT << ", ";
dump_func(move(tail)...);
}
// chmax ()
template <typename T, typename U, typename Comp = less<>> bool chmax(T &xmax, const U &x, Comp comp = {}) {
if (comp(xmax, x)) {
xmax = x;
return true;
}
return false;
}
// chmin ()
template <typename T, typename U, typename Comp = less<>> bool chmin(T &xmin, const U &x, Comp comp = {}) {
if (comp(x, xmin)) {
xmin = x;
return true;
}
return false;
}
//
#define DEBUG_
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
struct AtCoderInitialize {
static constexpr int IOS_PREC = 15;
static constexpr bool AUTOFLUSH = false;
AtCoderInitialize() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(IOS_PREC);
if (AUTOFLUSH) cout << unitbuf;
}
} ATCODER_INITIALIZE;
string yes = "Yes", no = "No";
// string yes = "YES", no = "NO";
void yn(bool p) { cout << (p ? yes : no) << endl; }
/* #endregion */
/* #region Graph */
//
template <class weight_t, class flow_t> struct Edge {
ll src; //
ll dst; //
weight_t weight; //
flow_t cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(ll src, ll dst, weight_t weight) : src(src), dst(dst), weight(weight) {}
Edge(ll src, ll dst, weight_t weight, flow_t cap) : src(src), dst(dst), weight(weight), cap(cap) {}
// Edge
friend ostream &operator<<(ostream &os, Edge &edge) {
os << "(" << edge.src << " -> " << edge.dst << ", " << edge.weight << ")";
return os;
}
};
//
template <class weight_t, class flow_t> class Node : public vc<Edge<weight_t, flow_t>> {
public:
ll idx;
Node() : vc<Edge<weight_t, flow_t>>() {}
// void add(int a, int b, weight_t w, flow_t cap) { this->emplace_back(a, b, w, cap); };
};
// graph[i] := i
template <class weight_t, class flow_t> class Graph : public vc<Node<weight_t, flow_t>> {
public:
Graph() : vc<Node<weight_t, flow_t>>() {}
Graph(int n) : vc<Node<weight_t, flow_t>>(n) { REP(i, 0, n)(*this)[i].idx = i; }
//
void add_arc(int a, int b, weight_t w = 1, flow_t cap = 1) { (*this)[a].emplace_back(a, b, w, cap); }
//
void add_edge(int a, int b, weight_t w = 1, flow_t cap = 1) { add_arc(a, b, w, cap), add_arc(b, a, w, cap); }
};
// using Array = vc<Weight>;
// using Matrix = vc<Array>;
/* #endregion */
/* #region scc */
//
template <class weight_t, class flow_t> vll scc(const Graph<weight_t, flow_t> &g) {
ll n = SIZE(g); //
Graph<weight_t, flow_t> rg(n); //
for (const Node<weight_t, flow_t> &es : g)
for (Edge<weight_t, flow_t> e : es) {
swap(e.src, e.dst);
rg[e.src].emplace_back(e);
}
vll order;
order.reserve(n);
{ // dfs 1
vc<bool> visited(n), added(n);
REP(i, 0, n) {
if (visited[i]) continue;
stack<ll> stk;
stk.push(i);
while (!stk.empty()) {
ll cur = stk.top();
visited[cur] = true;
bool pushed = false;
for (const Edge<weight_t, flow_t> &e : g[cur])
if (!visited[e.dst]) stk.push(e.dst), pushed = true;
if (!pushed) { //
ll t = stk.top();
stk.pop(); //
if (!added[t]) added[t] = true, order.push_back(t);
}
}
}
reverse(ALL(order));
}
vll ret(n, -1);
{ // dfs 2
ll groupnum = 0;
for (ll &v : order) {
if (ret[v] != -1) continue;
stack<ll> stk;
stk.push(v);
while (!stk.empty()) {
ll cur = stk.top();
stk.pop(), ret[cur] = groupnum;
for (Edge<weight_t, flow_t> &e : rg[cur])
if (ret[e.dst] == -1) stk.push(e.dst);
}
++groupnum;
}
}
return ret;
}
/* #endregion */
/* #region TwoSat */
// 2-SAT
struct TwoSat {
using G = Graph<int, int>;
int _var_cnt; //
int _sz; //
G graph; // graph[i] <-> not(graph[i+_var_cnt])
vc<int> result; //
// var_cnt: P ¬P 1
TwoSat(int var_cnt) : _var_cnt(var_cnt), _sz(var_cnt * 2), graph(_sz), result(var_cnt) {}
// (x ∨ y) ¬x x+_var_cnt
void add_arcs(int x, int y) {
graph.add_arc((x + _var_cnt) % _sz, y); // ¬x -> y
graph.add_arc((y + _var_cnt) % _sz, x); // ¬y -> x
}
// false. result T/F
bool sat() {
vll groups = scc(graph);
// dump(groups);
REP(i, 0, _var_cnt) if (groups[i] == groups[i + _var_cnt]) return false;
REP(i, 0, _var_cnt) result[i] = groups[i] > groups[i + _var_cnt];
return true;
}
};
/* #endregion */
// Problem
void solve() {
ll n;
cin >> n;
vll s(n), t(n), u(n);
cin >> s >> t >> u;
ll var_cnt = n * n;
TwoSat ts(var_cnt);
auto idx = [&n](ll row, ll col) -> ll { return n * row + col; };
REP(i, 0, n) {
// i
s[i]--, t[i]--;
bool on_sj = !(u[i] & 1), on_jt = !((u[i] >> 1) & 1);
int offset_sj = on_sj ? 0 : var_cnt;
int offset_jt = on_jt ? 0 : var_cnt;
// dump(offset_sj, offset_jt);
REP(j, 0, n) {
int p1 = idx(s[i], j) + offset_sj;
int p2 = idx(j, t[i]) + offset_jt;
// dump(p1, p2);
ts.add_arcs(p1, p2);
}
}
if (ts.sat()) {
REP(row, 0, n) {
REP(col, 0, n) cout << ts.result[idx(row, col)] << (col == n - 1 ? "" : " ");
cout << endl;
}
} else {
cout << -1 << endl;
}
}
// entry point
int main() {
solve();
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0