Created
June 13, 2020 16:45
-
-
Save SamZhangQingChuan/e7f2de326178b4f8305a526d935be573 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#pragma comment(linker, "/stack:200000000") | |
#pragma GCC optimize("Ofast") | |
//#pragma GCC optimize(3) | |
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native") | |
//#pragma GCC target("sse3","sse2","sse") | |
//#pragma GCC target("avx","sse4","sse4.1","sse4.2","ssse3") | |
//#pragma GCC target("f16c") | |
//#pragma GCC optimize("inline","fast-math","unroll-loops","no-stack-protector") | |
//#pragma GCC diagnostic error "-fwhole-program" | |
//#pragma GCC diagnostic error "-fcse-skip-blocks" | |
//#pragma GCC diagnostic error "-funsafe-loop-optimizations" | |
//#pragma GCC diagnostic error "-std=c++14" | |
#include "bits/stdc++.h" | |
#include "ext/pb_ds/tree_policy.hpp" | |
#include "ext/pb_ds/assoc_container.hpp" | |
#define PB push_back | |
#define PF push_front | |
#define LB lower_bound | |
#define UB upper_bound | |
#define fr(x) freopen(x,"r",stdin) | |
#define fw(x) freopen(x,"w",stdout) | |
#define REP(x, l, u) for(ll x = l;x<u;x++) | |
#define RREP(x, l, u) for(ll x = l;x>=u;x--) | |
#define complete_unique(a) a.erase(unique(begin(a),end(a)),end(a)) | |
#define mst(x, a) memset(x,a,sizeof(x)) | |
#define all(a) begin(a),end(a) | |
#define rall(a) rbegin(a),rend(a) | |
#define PII pair<int,int> | |
#define PLL pair<ll,ll> | |
#define MP make_pair | |
#define lowbit(x) ((x)&(-(x))) | |
#define bitcnt(x) (__builtin_popcountll(x)) | |
#define lson (ind<<1) | |
#define rson (ind<<1|1) | |
#define se second | |
#define fi first | |
#define sz(x) ((int)x.size()) | |
#define EX0 exit(0); | |
typedef long long ll; | |
typedef unsigned long long ull; | |
typedef double db; | |
typedef long double ld; | |
using namespace __gnu_pbds; //required | |
using namespace std; | |
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; | |
typedef vector<ll> VLL; | |
typedef vector<int> VI; | |
const ll mod = 1e9 + 7; | |
string to_string (string s) { return '"' + s + '"'; } | |
string to_string (const char *s) { return to_string ((string) s); } | |
string to_string (bool b) { return (b ? "true" : "false"); } | |
template<typename A, typename B> | |
string to_string (pair<A, B> p) { return "(" + to_string (p.first) + ", " + to_string (p.second) + ")"; } | |
template<typename A> | |
string to_string (A v) { | |
bool first = true; | |
string res = "{"; | |
for (const auto &x : v) { | |
if (!first) { res += ", "; } | |
first = false; | |
res += to_string (x); | |
} | |
res += "}"; | |
return res; | |
} | |
void debug_out () { cerr<<endl; } | |
template<typename Head, typename... Tail> | |
void debug_out (Head H, Tail... T) { | |
cerr<<" "<<to_string (H); | |
debug_out (T...); | |
} | |
#ifdef LOCAL | |
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__) | |
#else | |
#define dbg(...) {} | |
#endif | |
template<typename T, typename S> | |
inline bool upmin (T &a, const S &b) { return a > b ? a = b, 1 : 0; } | |
template<typename T, typename S> | |
inline bool upmax (T &a, const S &b) { return a < b ? a = b, 1 : 0; } | |
ull twop (ll x) { return 1ULL<<x; } | |
ll MOD (ll a, ll m) { | |
a %= m; | |
if (a < 0)a += m; | |
return a; | |
} | |
ll inverse (ll a, ll m) { | |
a = MOD (a, m); | |
if (a <= 1)return a; | |
return MOD ((1 - inverse (m, a) * m) / a, m); | |
} | |
template<typename T> | |
T sqr (T x) { return x * x; } | |
ll gcd (ll a, ll b) { | |
a = abs (a), b = abs (b); | |
while (b != 0) { | |
a %= b; | |
swap (a, b); | |
} | |
return a; | |
} | |
ll fast (ll a, ll b) { | |
ll ans = 1; | |
while (b) { | |
if (b & 1)ans *= a; | |
a *= a; | |
b /= 2; | |
} | |
return ans; | |
} | |
ll fast (ll a, ll b, ll mod) { | |
if (b < 0)a = inverse (a, mod), b = -b; | |
ll ans = 1; | |
while (b) { | |
if (b & 1)ans = ans * a % mod; | |
a = a * a % mod; | |
b /= 2; | |
} | |
return ans % mod; | |
} | |
namespace CircleSquareTree { | |
struct Edge { | |
ll from, to, id; | |
Edge (ll from, ll to, ll id) : from (from), to (to), id (id) {} | |
}; | |
const ll N = 500010; //开两倍 | |
ll low[N], dfn[N], cnt = 1; | |
vector<Edge> adj[N]; | |
vector<Edge> stack; | |
int down[N], up[N]; | |
void addEdge (int a, int b, int id) { | |
adj[a].PB (Edge (a, b, id)); | |
adj[b].PB (Edge (b, a, id)); | |
} | |
vector<vector<Edge>> comp[N]; | |
void tarjan (ll cur, Edge edge) { | |
dfn[cur] = low[cur] = cnt++; | |
for (auto e:adj[cur]) { | |
if (e.id != edge.id) { | |
auto to = e.to; | |
if (!dfn[to]) { | |
stack.PB (e); | |
tarjan (to, e); | |
upmin (low[cur], low[to]); | |
if (low[to] >= dfn[cur]) { | |
vector<Edge> components; | |
while (true) { | |
auto cur = stack.back (); | |
stack.pop_back (); | |
components.PB (cur); | |
if (cur.id == e.id)break; | |
} | |
comp[cur].PB (components); | |
if (sz(components) == 1) { | |
// bridge | |
upmax (down[cur], down[e.to] + 1); | |
} else { | |
// bcc | |
dbg(cur); | |
VLL row; | |
for (auto e:components) { | |
dbg(e.from, e.to); | |
row.PB (e.to); | |
} | |
{ | |
int len = sz(components) + 1; | |
REP(i, 0, sz (components)) { | |
upmax (down[cur], down[components[i].to] + min (1 + i, len - i - 1)); | |
} | |
} | |
REP(_, 0, 2) { | |
int len = sz(row) + 1; | |
deque<ll> q; | |
REP(i, 0, sz (row)) { | |
while (sz(q) and i - q.front () > len - (i - q.front ()))q.pop_front (); | |
if (sz(q)) { | |
upmax (up[row[i]], down[row[q.front ()]] + i - q.front ()); | |
} | |
while (sz(q) and down[row[i]] - down[row[q.back ()]] >= i-q.back())q.pop_back (); | |
q.PB (i); | |
} | |
int cur = 0; | |
ll mx = -1e8; | |
REP(i, 0, sz (row)) { | |
while (i - cur >= len - (i - cur)) { | |
upmax (mx, down[row[cur]] + len + cur); | |
cur++; | |
} | |
upmax (up[row[i]], mx - i); | |
} | |
reverse (all(row)); | |
} | |
} | |
} | |
} else { | |
upmin (low[cur], dfn[to]); | |
} | |
} | |
} | |
} | |
void dfs2 (ll cur, Edge edge) { | |
dbg("222", cur); | |
dfn[cur] = 1; | |
REP(_, 0, 2) { | |
int mx = up[cur]; | |
for (const auto &components:comp[cur]) { | |
if (sz(components) == 1) { | |
upmax (up[components[0].to], mx + 1); | |
upmax (mx, down[components[0].to] + 1); | |
} else { | |
int len = sz(components) + 1; | |
REP(i, 0, sz (components)) { | |
upmax (up[components[i].to], mx + min (1 + i, len - i - 1)); | |
} | |
REP(i, 0, sz (components)) { | |
upmax (mx, down[components[i].to] + min (1 + i, len - i - 1)); | |
} | |
} | |
} | |
reverse (all(comp[cur])); | |
} | |
for (auto e:adj[cur]) { | |
if (e.id != edge.id) { | |
auto to = e.to; | |
if (!dfn[to]) { | |
dfs2 (to, e); | |
} | |
} | |
} | |
} | |
void clean (int n) { | |
fill (low, low + n + 1, 0); | |
fill (dfn, dfn + n + 1, 0); | |
cnt = 1; | |
stack.clear (); | |
} | |
// 圆方树在realAdj,编号为 [1,square) | |
void run (int n, vector<PLL > edges) { | |
clean (n); | |
REP(i, 0, sz (edges)) { | |
addEdge (edges[i].fi, edges[i].se, i); | |
} | |
tarjan (1, Edge (0, 0, -1)); | |
clean (n); | |
dfs2 (1, Edge (0, 0, -1)); | |
REP(i, 1, n + 1)dbg(i, down[i], up[i]); | |
REP(i, 1, n + 1)cout<<max (up[i], down[i])<<" "; | |
} | |
} | |
namespace SOLVE { | |
void main () { | |
vector<PLL > v; | |
ll n, m; | |
cin>>n>>m; | |
REP(i, 0, m) { | |
ll a, b; | |
cin>>a>>b; | |
v.emplace_back (a, b); | |
} | |
CircleSquareTree::run (n, v); | |
} | |
} | |
signed main () { | |
#ifdef LOCAL | |
fr("/Users/zhangqingchuan/Desktop/cp/cp/input.txt"); | |
fw("/Users/zhangqingchuan/Desktop/cp/cp/output.txt"); | |
#endif | |
ios::sync_with_stdio (false); | |
cin.tie (nullptr); | |
cout.tie (nullptr); | |
int t = 1; | |
// cin >> t; | |
for (int i = 1; i <= t; i++) { | |
// cout<<"Case #"<<i<<": "; | |
SOLVE::main (); | |
} | |
// clock_t st = clock(); | |
// while(clock() - st < 3.0 * CLOCKS_PER_SEC){ | |
// | |
// } | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment