結果

問題 No.977 アリス仕掛けの摩天楼
ユーザー 👑 NachiaNachia
提出日時 2024-06-20 19:19:00
言語 C++17(gcc12)
(gcc 12.3.0 + boost 1.87.0)
結果
AC  
実行時間 38 ms / 2,000 ms
コード長 11,400 bytes
コンパイル時間 1,434 ms
コンパイル使用メモリ 114,100 KB
実行使用メモリ 9,472 KB
最終ジャッジ日時 2024-06-20 19:19:04
合計ジャッジ時間 3,109 ms
ジャッジサーバーID
(参考情報)
judge4 / judge2
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 26
権限があれば一括ダウンロードができます

ソースコード

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

#ifdef NACHIA
#define _GLIBCXX_DEBUG
#else
#define NDEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <array>
#include <cmath>
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(int i=0; i<int(n); i++)
#define repr(i,n) for(int i=int(n)-1; i>=0; i--)
const i64 INF = 1001001001001001001;
using namespace std;
#include <cassert>
namespace nachia{
template<class Elem>
class CsrArray{
public:
struct ListRange{
using iterator = typename std::vector<Elem>::iterator;
iterator begi, endi;
iterator begin() const { return begi; }
iterator end() const { return endi; }
int size() const { return (int)std::distance(begi, endi); }
Elem& operator[](int i) const { return begi[i]; }
};
struct ConstListRange{
using iterator = typename std::vector<Elem>::const_iterator;
iterator begi, endi;
iterator begin() const { return begi; }
iterator end() const { return endi; }
int size() const { return (int)std::distance(begi, endi); }
const Elem& operator[](int i) const { return begi[i]; }
};
private:
int m_n;
std::vector<Elem> m_list;
std::vector<int> m_pos;
public:
CsrArray() : m_n(0), m_list(), m_pos() {}
static CsrArray Construct(int n, std::vector<std::pair<int, Elem>> items){
CsrArray res;
res.m_n = n;
std::vector<int> buf(n+1, 0);
for(auto& [u,v] : items){ ++buf[u]; }
for(int i=1; i<=n; i++) buf[i] += buf[i-1];
res.m_list.resize(buf[n]);
for(int i=(int)items.size()-1; i>=0; i--){
res.m_list[--buf[items[i].first]] = std::move(items[i].second);
}
res.m_pos = std::move(buf);
return res;
}
static CsrArray FromRaw(std::vector<Elem> list, std::vector<int> pos){
CsrArray res;
res.m_n = pos.size() - 1;
res.m_list = std::move(list);
res.m_pos = std::move(pos);
return res;
}
ListRange operator[](int u) { return ListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; }
ConstListRange operator[](int u) const { return ConstListRange{ m_list.begin() + m_pos[u], m_list.begin() + m_pos[u+1] }; }
int size() const { return m_n; }
int fullSize() const { return (int)m_list.size(); }
};
} // namespace nachia
namespace nachia{
struct Graph {
public:
struct Edge{
int from, to;
void reverse(){ std::swap(from, to); }
int xorval() const { return from ^ to; }
};
Graph(int n = 0, bool undirected = false, int m = 0) : m_n(n), m_e(m), m_isUndir(undirected) {}
Graph(int n, const std::vector<std::pair<int, int>>& edges, bool undirected = false) : m_n(n), m_isUndir(undirected){
m_e.resize(edges.size());
for(std::size_t i=0; i<edges.size(); i++) m_e[i] = { edges[i].first, edges[i].second };
}
template<class Cin>
static Graph Input(Cin& cin, int n, bool undirected, int m, bool offset = 0){
Graph res(n, undirected, m);
for(int i=0; i<m; i++){
int u, v; cin >> u >> v;
res[i].from = u - offset;
res[i].to = v - offset;
}
return res;
}
int numVertices() const noexcept { return m_n; }
int numEdges() const noexcept { return int(m_e.size()); }
int addNode() noexcept { return m_n++; }
int addEdge(int from, int to){ m_e.push_back({ from, to }); return numEdges() - 1; }
Edge& operator[](int ei) noexcept { return m_e[ei]; }
const Edge& operator[](int ei) const noexcept { return m_e[ei]; }
Edge& at(int ei) { return m_e.at(ei); }
const Edge& at(int ei) const { return m_e.at(ei); }
auto begin(){ return m_e.begin(); }
auto end(){ return m_e.end(); }
auto begin() const { return m_e.begin(); }
auto end() const { return m_e.end(); }
bool isUndirected() const noexcept { return m_isUndir; }
void reverseEdges() noexcept { for(auto& e : m_e) e.reverse(); }
void contract(int newV, const std::vector<int>& mapping){
assert(numVertices() == int(mapping.size()));
for(int i=0; i<numVertices(); i++) assert(0 <= mapping[i] && mapping[i] < newV);
for(auto& e : m_e){ e.from = mapping[e.from]; e.to = mapping[e.to]; }
m_n = newV;
}
std::vector<Graph> induce(int num, const std::vector<int>& mapping) const {
int n = numVertices();
assert(n == int(mapping.size()));
for(int i=0; i<n; i++) assert(-1 <= mapping[i] && mapping[i] < num);
std::vector<int> indexV(n), newV(num);
for(int i=0; i<n; i++) if(mapping[i] >= 0) indexV[i] = newV[mapping[i]]++;
std::vector<Graph> res; res.reserve(num);
for(int i=0; i<num; i++) res.emplace_back(newV[i], isUndirected());
for(auto e : m_e) if(mapping[e.from] == mapping[e.to] && mapping[e.to] >= 0) res[mapping[e.to]].addEdge(indexV[e.from], indexV[e.to]);
return res;
}
CsrArray<int> getEdgeIndexArray(bool undirected) const {
std::vector<std::pair<int, int>> src;
src.reserve(numEdges() * (undirected ? 2 : 1));
for(int i=0; i<numEdges(); i++){
auto e = operator[](i);
src.emplace_back(e.from, i);
if(undirected) src.emplace_back(e.to, i);
}
return CsrArray<int>::Construct(numVertices(), src);
}
CsrArray<int> getEdgeIndexArray() const { return getEdgeIndexArray(isUndirected()); }
CsrArray<int> getAdjacencyArray(bool undirected) const {
std::vector<std::pair<int, int>> src;
src.reserve(numEdges() * (undirected ? 2 : 1));
for(auto e : m_e){
src.emplace_back(e.from, e.to);
if(undirected) src.emplace_back(e.to, e.from);
}
return CsrArray<int>::Construct(numVertices(), src);
}
CsrArray<int> getAdjacencyArray() const { return getAdjacencyArray(isUndirected()); }
private:
int m_n;
std::vector<Edge> m_e;
bool m_isUndir;
};
} // namespace nachia
namespace nachia{
struct DfsTree{
std::vector<int> dfsOrd;
std::vector<int> parent;
template<bool OutOrd>
static DfsTree Construct(const CsrArray<int>& adj, int root = 0){
DfsTree res;
int n = adj.size();
res.dfsOrd.resize(n);
int Oi = 0;
std::vector<int> eid(n, 0), parent(n, -2);
for(int s=root; Oi<n; s == n-1 ? s=0 : ++s) if(parent[s] == -2){
int p = s;
parent[p] = -1;
while(0 <= p){
if(eid[p] == (OutOrd ? (int)adj[p].size() : 0)) res.dfsOrd[Oi++] = p;
if(eid[p] == (int)adj[p].size()){ p = parent[p]; continue; }
int nx = adj[p][eid[p]++];
if(parent[nx] != -2) continue;
parent[nx] = p;
p = nx;
}
s++; if(s == n) s=0;
}
res.parent = std::move(parent);
return res;
}
template<bool OutOrd>
static DfsTree Construct(const Graph& g, int root = 0){ return Construct<OutOrd>(g.getAdjacencyArray(), root); }
};
} // namespace nachia
namespace nachia{
struct TwoEdgeConnectedComponents{
Graph mG;
int m_numComponent;
std::vector<int> m_color;
TwoEdgeConnectedComponents(Graph G = Graph(0, true)){
assert(G.isUndirected());
int n = G.numVertices(), m = G.numEdges();
if(n == 0){ mG = G; m_numComponent = 0; return; }
std::vector<int> P, ord, I(n); {
auto dfsTree = DfsTree::Construct<false>(G);
P = std::move(dfsTree.parent);
ord = std::move(dfsTree.dfsOrd);
for(int i=0; i<n; i++) I[ord[i]] = i;
}
std::vector<int> rev = I, PE(n, -1);
for(int e=0; e<m; e++){
int v = G[e].from, w = G[e].to;
if(I[v] < I[w]) std::swap(v, w);
if(P[v] == w && PE[v] < 0){ PE[v] = e; }
else rev[v] = std::min(rev[v], I[w]);
}
for(int i=n-1; i>=0; i--){
int v = ord[i], w = P[v];
if(w >= 0) rev[w] = std::min(rev[w], rev[v]);
}
m_numComponent = 0;
m_color.resize(n);
for(int v : ord){
if(rev[v] == I[v]) m_color[v] = m_numComponent++;
else m_color[v] = m_color[P[v]];
}
mG = std::move(G);
}
int numComponents() const noexcept { return m_numComponent; }
int operator[](int v) const { return m_color[v]; }
CsrArray<int> getTeccVertices() const {
int n = mG.numVertices();
std::vector<std::pair<int, int>> res(n);
for(int i=0; i<n; i++) res[i] = { m_color[i], i };
return CsrArray<int>::Construct(numComponents(), res);
}
// bridge : -1
std::vector<int> getEdgeMapping() const {
std::vector<int> res(mG.numEdges(), -1);
for(int i=0; i<mG.numEdges(); i++) if(m_color[mG[i].from] == m_color[mG[i].to]) res[i] = m_color[mG[i].from];
return res;
}
std::vector<int> getVertexMapping() const { return m_color; }
};
}
namespace nachia {
struct DsuFast{
private:
std::vector<int> w;
public:
DsuFast(int n = 0) : w(n, -1) {}
int leader(int u){
if(w[u] < 0) return u;
return w[u] = leader(w[u]);
}
int operator[](int u){ return leader(u); }
int merge(int u, int v){
u = leader(u);
v = leader(v);
if(u == v) return u;
if(-w[u] < -w[v]) std::swap(u, v);
w[u] += w[v];
w[v] = u;
return u;
}
int size(int u){ return -w[leader(u)]; }
bool same(int u, int v){ return leader(u) == leader(v); }
};
} // namespace nachia
namespace nachia{
struct ConnectedComponents{
ConnectedComponents(const CsrArray<int>& adj){
int n = adj.size();
DsuFast dsu(n);
for(int v=0; v<n; v++) for(int w : adj[v]) dsu.merge(v, w);
m_color.assign(n, -1);
m_numC = 0;
for(int i=0; i<n; i++) if(dsu.leader(i) == i) m_color[i] = m_numC++;
for(int i=0; i<n; i++) m_color[i] = m_color[dsu.leader(i)];
}
ConnectedComponents(const Graph& G = Graph(0, true)){
int n = G.numVertices();
DsuFast dsu(n);
for(auto e : G) dsu.merge(e.from, e.to);
m_color.assign(n, -1);
m_numC = 0;
for(int i=0; i<n; i++) if(dsu.leader(i) == i) m_color[i] = m_numC++;
for(int i=0; i<n; i++) m_color[i] = m_color[dsu.leader(i)];
}
int numComponents() const noexcept { return m_numC; }
const std::vector<int>& getMapping() const { return m_color; }
CsrArray<int> getCsr() const {
std::vector<std::pair<int, int>> buf(m_color.size());
for(int i=0; i<(int)m_color.size(); i++){
buf[i] = std::make_pair(m_color[i], i);
}
return CsrArray<int>::Construct(numComponents(), std::move(buf));
}
private:
int m_numC;
std::vector<int> m_color;
};
} // namespace nachia
void testcase(){
int N; cin >> N;
auto graph = nachia::Graph::Input(cin, N, true, N-1, 0);
auto tecc = nachia::TwoEdgeConnectedComponents(graph).numComponents();
auto cc = nachia::ConnectedComponents(graph).numComponents();
if(cc == 1 || tecc <= 2){ cout << "Bob\n"; }
else cout << "Alice\n";
}
int main(){
ios::sync_with_stdio(false); cin.tie(nullptr);
testcase();
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0