結果
| 問題 | No.1326 ふたりのDominator |
| ユーザー |
👑  Nachia
|
| 提出日時 | 2022-10-07 22:44:34 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 36 ms / 2,000 ms |
| コード長 | 19,345 bytes |
| コンパイル時間 | 1,794 ms |
| コンパイル使用メモリ | 93,924 KB |
| 実行使用メモリ | 10,928 KB |
| 最終ジャッジ日時 | 2023-09-03 14:18:23 |
| 合計ジャッジ時間 | 5,446 ms |
|
ジャッジサーバーID （参考情報） |
judge14 / judge13 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 1 ms
4,376 KB |
| testcase_01 | AC | 1 ms
4,376 KB |
| testcase_02 | AC | 2 ms
4,380 KB |
| testcase_03 | AC | 1 ms
4,380 KB |
| testcase_04 | AC | 1 ms
4,380 KB |
| testcase_05 | AC | 1 ms
4,376 KB |
| testcase_06 | AC | 1 ms
4,380 KB |
| testcase_07 | AC | 2 ms
4,376 KB |
| testcase_08 | AC | 2 ms
4,380 KB |
| testcase_09 | AC | 2 ms
4,376 KB |
| testcase_10 | AC | 2 ms
4,376 KB |
| testcase_11 | AC | 2 ms
4,380 KB |
| testcase_12 | AC | 35 ms
10,164 KB |
| testcase_13 | AC | 36 ms
10,160 KB |
| testcase_14 | AC | 35 ms
10,100 KB |
| testcase_15 | AC | 35 ms
10,072 KB |
| testcase_16 | AC | 32 ms
9,708 KB |
| testcase_17 | AC | 28 ms
8,368 KB |
| testcase_18 | AC | 28 ms
8,016 KB |
| testcase_19 | AC | 22 ms
7,324 KB |
| testcase_20 | AC | 28 ms
10,192 KB |
| testcase_21 | AC | 29 ms
10,112 KB |
| testcase_22 | AC | 32 ms
10,928 KB |
| testcase_23 | AC | 23 ms
10,116 KB |
| testcase_24 | AC | 35 ms
10,108 KB |
ソースコード
#line 2 "nachia\\array\\csr-array.hpp"
#include <utility>
#include <vector>
#include <algorithm>
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, const 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]] = 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
#line 5 "nachia\\tree\\heavy-light-decomposition.hpp"
namespace nachia{
struct HeavyLightDecomposition{
private:
int N;
std::vector<int> P;
std::vector<int> PP;
std::vector<int> PD;
std::vector<int> D;
std::vector<int> I;
std::vector<int> rangeL;
std::vector<int> rangeR;
public:
HeavyLightDecomposition(const CsrArray<int>& E = CsrArray<int>::Construct(1, {})){
N = E.size();
P.assign(N, -1);
I = {0};
I.reserve(N);
for(int i=0; i<(int)I.size(); i++){
int p = I[i];
for(int e : E[p]) if(P[p] != e){
I.push_back(e);
P[e] = p;
}
}
std::vector<int> Z(N, 1);
std::vector<int> nx(N, -1);
PP.resize(N);
for(int i=0; i<N; i++) PP[i] = i;
for(int i=N-1; i>=1; i--){
int p = I[i];
Z[P[p]] += Z[p];
if(nx[P[p]] == -1) nx[P[p]] = p;
if(Z[nx[P[p]]] < Z[p]) nx[P[p]] = p;
}
for(int p : I) if(nx[p] != -1) PP[nx[p]] = p;
PD.assign(N,N);
PD[0] = 0;
D.assign(N,0);
for(int p : I) if(p != 0){
PP[p] = PP[PP[p]];
PD[p] = std::min(PD[PP[p]], PD[P[p]]+1);
D[p] = D[P[p]]+1;
}
rangeL.assign(N,0);
rangeR.assign(N,0);
for(int p : I){
rangeR[p] = rangeL[p] + Z[p];
int ir = rangeR[p];
for(int e : E[p]) if(P[p] != e) if(e != nx[p]){
rangeL[e] = (ir -= Z[e]);
}
if(nx[p] != -1){
rangeL[nx[p]] = rangeL[p] + 1;
}
}
I.resize(N);
for(int i=0; i<N; i++) I[rangeL[i]] = i;
}
int depth(int p) const { return D[p]; }
int to_seq(int vertex) const { return rangeL[vertex]; }
int to_vtx(int seqidx) const { return I[seqidx]; }
int parent_of(int v) const { return P[v]; }
int heavy_root_of(int v) const { return PP[v]; }
int heavy_child_of(int v) const {
if(to_seq(v) == N-1) return -1;
int cand = to_vtx(to_seq(v) + 1);
if(PP[v] == PP[cand]) return cand;
return -1;
}
int lca(int u, int v) const {
if(PD[u] < PD[v]) std::swap(u, v);
while(PD[u] > PD[v]) u = P[PP[u]];
while(PP[u] != PP[v]){ u = P[PP[u]]; v = P[PP[v]]; }
return (D[u] > D[v]) ? v : u;
}
int dist(int u, int v) const {
return depth(u) + depth(v) - depth(lca(u,v)) * 2;
}
std::vector<std::pair<int,int>> path(int r, int c, bool include_root = true, bool reverse_path = false) const {
if(PD[c] < PD[r]) return {};
std::vector<std::pair<int,int>> res(PD[c]-PD[r]+1);
for(int i=0; i<(int)res.size()-1; i++){
res[i] = std::make_pair(rangeL[PP[c]], rangeL[c]+1);
c = P[PP[c]];
}
if(PP[r] != PP[c] || D[r] > D[c]) return {};
res.back() = std::make_pair(rangeL[r]+(include_root?0:1), rangeL[c]+1);
if(res.back().first == res.back().second) res.pop_back();
if(!reverse_path) std::reverse(res.begin(),res.end());
else for(auto& a : res) a = std::make_pair(N - a.second, N - a.first);
return res;
}
std::pair<int,int> subtree(int p){
return std::make_pair(rangeL[p], rangeR[p]);
}
int median(int x, int y, int z) const {
return lca(x,y) ^ lca(y,z) ^ lca(x,z);
}
int la(int from, int to, int d) const {
if(d < 0) return -1;
int g = lca(from,to);
int dist0 = D[from] - D[g] * 2 + D[to];
if(dist0 < d) return -1;
int p = from;
if(D[from] - D[g] < d){ p = to; d = dist0 - d; }
while(D[p] - D[PP[p]] < d){
d -= D[p] - D[PP[p]] + 1;
p = P[PP[p]];
}
return I[rangeL[p] - d];
}
};
} // namespace nachia
#line 4 "nachia\\graph\\graph.hpp"
#include <cassert>
#line 6 "nachia\\graph\\graph.hpp"
namespace nachia{
struct Graph {
public:
struct Edge{
int from, to;
void reverse(){ std::swap(from, to); }
};
using Base = std::vector<std::pair<int, int>>;
Graph(int n = 0, bool undirected = false) : m_n(n), m_e(), 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 };
}
Graph(int n, const std::vector<Edge>& edges, bool undirected = false) : m_n(n), m_e(edges), m_isUndir(undirected) {}
Graph(int n, std::vector<Edge>&& edges, bool undirected = false) : m_n(n), m_e(edges), m_isUndir(undirected) {}
int numVertices() const noexcept { return m_n; }
int numEdges() const noexcept { return int(m_e.size()); }
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]; }
}
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
#line 3 "nachia\\graph\\dfs-tree.hpp"
namespace nachia{
struct DfsTree{
std::vector<int> dfsOrd;
std::vector<int> parent;
template<bool OutOrd>
static DfsTree Construct(const CsrArray<int>& adj){
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=0; s<n; s++) if(parent[s] == -2){
int p = s;
if(p >= n) p -= n;
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;
}
}
res.parent = std::move(parent);
return res;
}
template<bool OutOrd>
static DfsTree Construct(const Graph& g){ return Construct<OutOrd>(g.getAdjacencyArray()); }
};
} // namespace nachia
#line 6 "nachia\\graph\\biconnected-components.hpp"
namespace nachia{
class BiconnectedComponents{
private:
int mn;
int mm;
int mnum_bcs;
Graph mG;
std::vector<std::pair<int,int>> m_bcVtxPair;
public:
BiconnectedComponents(Graph G = Graph(0, true)){
int n = mn = G.numVertices();
int m = mm = G.numEdges();
mG = std::move(G);
if(n == 0){ mnum_bcs = 0; return; }
auto adj = mG.getAdjacencyArray();
auto dfstree = DfsTree::Construct<false>(adj);
std::vector<int> vtxToDfsi(n), parent, low;
for(int i=0; i<n; i++) vtxToDfsi[dfstree.dfsOrd[i]] = i;
parent = std::move(dfstree.parent);
low = vtxToDfsi;
for(int p=0; p<n; p++) for(int e : adj[p]) low[p] = std::min(low[p], vtxToDfsi[e]);
for(int i=n-1; i>=0; i--){
int p = dfstree.dfsOrd[i];
int pp = parent[p];
if(pp >= 0) low[pp] = std::min(low[pp], low[p]);
}
int num_bcs = 0;
std::vector<int> res(m);
for(int p : dfstree.dfsOrd) if(parent[p] >= 0){
int pp = parent[p];
if(low[p] < vtxToDfsi[pp]){
low[p] = low[pp];
m_bcVtxPair.push_back(std::make_pair(low[p], p));
}
else{
low[p] = num_bcs++;
m_bcVtxPair.push_back(std::make_pair(low[p], pp));
m_bcVtxPair.push_back(std::make_pair(low[p], p));
}
}
for(int s=0; s<mn; s++) if(adj[s].size() == 0) m_bcVtxPair.push_back(std::make_pair(num_bcs++, s));
mnum_bcs = num_bcs;
}
int numComponents() const { return mnum_bcs; }
CsrArray<int> getBcVertices() const {
return CsrArray<int>::Construct(numComponents(), m_bcVtxPair);
}
Graph getBcTree() const {
int bct_n = mn + mnum_bcs;
std::vector<std::pair<int, int>> res = m_bcVtxPair;
for(auto& e : res) e.first += mn;
return Graph(bct_n, std::move(res), true);
}
CsrArray<int> getBcEdges() const {
auto bct = getBcTree().getAdjacencyArray();
std::vector<int> bfsP(bct.size(), -1);
std::vector<int> bfsD(bct.size(), 0);
std::vector<int> bfs(bct.size());
int p0 = 0, p1 = 0;
for(int s=0; s<bct.size(); s++) if(bfsP[s] < 0){
for(bfs[p1++]=s; p0<p1; p0++){
int p = bfs[p0];
for(auto e : bct[p]) if(bfsP[p] != e){
bfsP[e] = p;
bfsD[e] = bfsD[p] + 1;
bfs[p1++] = e;
}
}
}
std::vector<std::pair<int,int>> res(mm);
for(int i=0; i<mm; i++){
int u = mG[i].from, v = mG[i].to;
res[i].first = bfsP[(bfsD[u] <= bfsD[v]) ? v : u] - mn;
res[i].second = i;
}
return CsrArray<int>::Construct(mnum_bcs, res);
}
};
} // namespace nachia
#line 2 "nachia\\misc\\fastio.hpp"
#include <cstdio>
#include <cctype>
#include <cstdint>
#include <string>
namespace nachia{
struct CInStream{
private:
static const unsigned int INPUT_BUF_SIZE = 1 << 17;
unsigned int p = INPUT_BUF_SIZE;
static char Q[INPUT_BUF_SIZE];
public:
using MyType = CInStream;
char seekChar(){
if(p == INPUT_BUF_SIZE){
size_t len = fread(Q, 1, INPUT_BUF_SIZE, stdin);
if(len != INPUT_BUF_SIZE) Q[len] = '\0';
p = 0;
}
return Q[p];
}
void skipSpace(){ while(isspace(seekChar())) p++; }
uint32_t nextU32(){
skipSpace();
uint32_t buf = 0;
while(true){
char tmp = seekChar();
if('9' < tmp || tmp < '0') break;
buf = buf * 10 + (tmp - '0');
p++;
}
return buf;
}
int32_t nextI32(){
skipSpace();
if(seekChar() == '-'){ p++; return (int32_t)(-nextU32()); }
return (int32_t)nextU32();
}
uint64_t nextU64(){
skipSpace();
uint64_t buf = 0;
while(true){
char tmp = seekChar();
if('9' < tmp || tmp < '0') break;
buf = buf * 10 + (tmp - '0');
p++;
}
return buf;
}
int64_t nextI64(){
skipSpace();
if(seekChar() == '-'){ p++; return (int64_t)(-nextU64()); }
return (int64_t)nextU64();
}
char nextChar(){ skipSpace(); char buf = seekChar(); p++; return buf; }
std::string nextToken(){
skipSpace();
std::string buf;
while(true){
char ch = seekChar();
if(isspace(ch) || ch == '\0') break;
buf.push_back(ch);
p++;
}
return buf;
}
MyType& operator>>(unsigned int& dest){ dest = nextU32(); return *this; }
MyType& operator>>(int& dest){ dest = nextI32(); return *this; }
MyType& operator>>(unsigned long& dest){ dest = nextU64(); return *this; }
MyType& operator>>(long& dest){ dest = nextI64(); return *this; }
MyType& operator>>(unsigned long long& dest){ dest = nextU64(); return *this; }
MyType& operator>>(long long& dest){ dest = nextI64(); return *this; }
MyType& operator>>(std::string& dest){ dest = nextToken(); return *this; }
MyType& operator>>(char& dest){ dest = nextChar(); return *this; }
} cin;
struct FastOutputTable{
char LZ[1000][4] = {};
char NLZ[1000][4] = {};
constexpr FastOutputTable(){
using u32 = uint_fast32_t;
for(u32 d=0; d<1000; d++){
LZ[d][0] = ('0' + d / 100 % 10);
LZ[d][1] = ('0' + d / 10 % 10);
LZ[d][2] = ('0' + d / 1 % 10);
LZ[d][3] = '\0';
}
for(u32 d=0; d<1000; d++){
u32 i = 0;
if(d >= 100) NLZ[d][i++] = ('0' + d / 100 % 10);
if(d >= 10) NLZ[d][i++] = ('0' + d / 10 % 10);
if(d >= 1) NLZ[d][i++] = ('0' + d / 1 % 10);
NLZ[d][i++] = '\0';
}
}
};
struct COutStream{
private:
using u32 = uint32_t;
using u64 = uint64_t;
using MyType = COutStream;
static const u32 OUTPUT_BUF_SIZE = 1 << 17;
static char Q[OUTPUT_BUF_SIZE];
static constexpr FastOutputTable TB = FastOutputTable();
u32 p = 0;
static constexpr u32 P10(u32 d){ return d ? P10(d-1)*10 : 1; }
static constexpr u64 P10L(u32 d){ return d ? P10L(d-1)*10 : 1; }
template<class T, class U> static void Fil(T& m, U& l, U x) noexcept { m = l/x; l -= m*x; }
void next_dig9(u32 x){
u32 y;
Fil(y, x, P10(6));
nextCstr(TB.LZ[y]);
Fil(y, x, P10(3));
nextCstr(TB.LZ[y]); nextCstr(TB.LZ[x]);
}
public:
void nextChar(char c){
Q[p++] = c;
if(p == OUTPUT_BUF_SIZE){ fwrite(Q, p, 1, stdout); p = 0; }
}
void nextEoln(){ nextChar('\n'); }
void nextCstr(const char* s){ while(*s) nextChar(*(s++)); }
void nextU32(uint32_t x){
u32 y = 0;
if(x >= P10(9)){
Fil(y, x, P10(9));
nextCstr(TB.NLZ[y]); next_dig9(x);
}
else if(x >= P10(6)){
Fil(y, x, P10(6));
nextCstr(TB.NLZ[y]);
Fil(y, x, P10(3));
nextCstr(TB.LZ[y]); nextCstr(TB.LZ[x]);
}
else if(x >= P10(3)){
Fil(y, x, P10(3));
nextCstr(TB.NLZ[y]); nextCstr(TB.LZ[x]);
}
else if(x >= 1) nextCstr(TB.NLZ[x]);
else nextChar('0');
}
void nextI32(int32_t x){
if(x >= 0) nextU32(x);
else{ nextChar('-'); nextU32((u32)-x); }
}
void nextU64(uint64_t x){
u32 y = 0;
if(x >= P10L(18)){
Fil(y, x, P10L(18));
nextU32(y);
Fil(y, x, P10L(9));
next_dig9(y); next_dig9(x);
}
else if(x >= P10L(9)){
Fil(y, x, P10L(9));
nextU32(y); next_dig9(x);
}
else nextU32(x);
}
void nextI64(int64_t x){
if(x >= 0) nextU64(x);
else{ nextChar('-'); nextU64((u64)-x); }
}
void writeToFile(bool flush = false){
fwrite(Q, p, 1, stdout);
if(flush) fflush(stdout);
p = 0;
}
COutStream(){ Q[0] = 0; }
~COutStream(){ writeToFile(); }
MyType& operator<<(unsigned int tg){ nextU32(tg); return *this; }
MyType& operator<<(unsigned long tg){ nextU64(tg); return *this; }
MyType& operator<<(unsigned long long tg){ nextU64(tg); return *this; }
MyType& operator<<(int tg){ nextI32(tg); return *this; }
MyType& operator<<(long tg){ nextI64(tg); return *this; }
MyType& operator<<(long long tg){ nextI64(tg); return *this; }
MyType& operator<<(const std::string& tg){ nextCstr(tg.c_str()); return *this; }
MyType& operator<<(const char* tg){ nextCstr(tg); return *this; }
MyType& operator<<(char tg){ nextChar(tg); return *this; }
} cout;
char CInStream::Q[INPUT_BUF_SIZE];
char COutStream::Q[OUTPUT_BUF_SIZE];
} // namespace nachia
#line 6 "Main.cpp"
#define rep(i,n) for(int i=0; i<(int)(n); i++)
int main() {
using nachia::cin, nachia::cout;
int n; cin >> n;
int m; cin >> m;
nachia::Graph G(n, true);
for(int i=0; i<m; i++){ int u,v; cin >> u >> v; G.addEdge(u-1, v-1); }
auto hld_bct = nachia::HeavyLightDecomposition(nachia::BiconnectedComponents(G).getBcTree().getAdjacencyArray());
int q; cin >> q;
for(int queryi=0; queryi<q; queryi++){
int u,v; cin >> u >> v; u--; v--;
int d = hld_bct.dist(u,v);
int ans = std::max(0, d/2-1);
cout << ans << '\n';
}
return 0;
}