text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 1e9 + 7;
const long long Mod = 998244353;
const double PI = 2 * asin(1);
int N, M, P[1000005], Group[1000005], Ans[1000005], Next[1000005];
vector<int> Num[1000005];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%d", P + i);
for (int i = 1; i <= N; i++) Group[i] = i;
for (int i = 0; i < M; i++) {
int A, B;
scanf("%d%d", &A, &B);
int GA = Group[A], GB = Group[B];
while (GA != Group[GA]) GA = Group[GA];
while (GB != Group[GB]) GB = Group[GB];
int G = min(GA, GB);
Group[A] = G;
Group[B] = G;
Group[max(GA, GB)] = G;
}
for (int i = 1; i <= N; i++) {
int G = Group[i];
while (G != Group[G]) G = Group[G];
Num[G].push_back(i);
}
for (int i = 1; i <= N; i++) {
if (Num[i].size() == 0) continue;
int S = Num[i].size();
for (int j = 0; j < S; j++) {
Next[j] = P[Num[i][j]];
}
sort(Next, Next + S, greater<int>());
for (int j = 0; j < S; j++) {
Ans[Num[i][j]] = Next[j];
}
}
for (int i = 1; i <= N; i++) {
printf("%d", Ans[i]);
if (i < N)
printf(" ");
else
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long POSITIVE_INFINITY = 9223372036854775807;
const long long NEGATIVE_INFINITY = -9223372036854775807;
const long long MOD = 1000000007;
const long double PI = acos(-1.0);
template <typename T>
inline T bigMod(T A, T B, T M = MOD) {
A %= M;
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T invMod(T A, T M = MOD) {
return bigMod(A, M - 2, M);
}
const int N = 200005;
void solve() {
int n, m;
cin >> n >> m;
vector<int> ar(n);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> val, pos, ans(n, 0);
vector<bool> vis(n, false);
function<void(int)> dfs = [&](int u) {
assert(vis[u] == false);
vis[u] = true;
pos.push_back(u);
for (int v : g[u]) {
if (vis[v] == false) {
dfs(v);
}
}
};
auto gen = [&]() {
for (int p : pos) {
val.push_back(ar[p]);
}
sort(val.rbegin(), val.rend());
sort(pos.begin(), pos.end());
for (int i = 0; i < (int)pos.size(); i++) {
ans[pos[i]] = val[i];
}
};
for (int i = 0; i < n; i++) {
if (vis[i] == false) {
pos.clear();
val.clear();
dfs(i);
gen();
}
}
for (int v : ans) {
cout << v << " ";
assert(v != 0);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int tc;
tc = 1;
while (tc--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num;
const long long int mx = 1e6;
int t;
int elementosP[mx + 5];
int tc = 0;
int vetComp[mx + 5];
int flag;
int val_n, val_m;
int x;
vector<int> aresta[mx + 5];
int y;
vector<int> guarda[mx + 5];
int cont;
void dfs(int pos, int id) {
int i, k;
t++;
vetComp[pos] = id;
num = id;
guarda[id].push_back(elementosP[pos]);
i = 0;
while (i < aresta[pos].size()) {
k = aresta[pos][i];
tc = pos;
if (vetComp[k] == 0) {
flag = 1;
dfs(k, id);
}
i++;
}
}
int main() {
int i, a, b, id;
for (; cin >> val_n >> val_m;) {
i = 1;
while (i <= val_n) {
scanf("%d", &elementosP[i]);
i++;
}
i = 1;
while (i <= val_m) {
scanf("%d %d", &a, &b);
t = val_n;
aresta[a].push_back(b);
cont += 1;
aresta[b].push_back(a);
i++;
}
id = 0;
i = 1;
while (i <= val_n) {
if (vetComp[i] == 0) {
flag = 1;
id++;
tc = val_m;
dfs(i, id);
cont += 1;
sort(guarda[id].begin(), guarda[id].end());
}
i++;
}
i = 1;
while (i <= val_n) {
a = vetComp[i];
cont = t;
b = guarda[a].size();
t++;
printf("%d ", guarda[a][b - 1]);
tc = i;
guarda[a].pop_back();
i++;
}
printf("\n");
i++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long* parent;
long long* size;
void make_set(long long v) {
parent[v] = v;
size[v] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_set(long long u, long long v) {
long long p1, p2;
p1 = find_set(u);
p2 = find_set(v);
if (p1 != p2) {
if (size[p1] < size[p2]) swap(p1, p2);
parent[p2] = p1;
size[p1] += size[p2];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> vc(n + 1);
parent = new long long[n + 1];
size = new long long[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> vc[i];
make_set(i);
}
long long a, b;
for (long long i = 0; i < m; i++) {
cin >> a >> b;
union_set(a, b);
}
unordered_map<long long, long long> mp;
vector<vector<long long> > ele(n + 1);
vector<vector<long long> > ind(n + 1);
long long k;
long long p = 0, pp;
for (long long i = 1; i <= n; i++) {
k = find_set(i);
if (mp[k] == 0) {
p++;
pp = p;
mp[k] = p;
} else {
pp = mp[k];
}
ele[pp].push_back(vc[i]);
ind[pp].push_back(i);
}
for (long long i = 1; i <= p; i++) {
sort(ele[i].begin(), ele[i].end(), greater<long long>());
sort(ind[i].begin(), ind[i].end());
for (long long j = 0; j < ele[i].size(); j++) {
vc[ind[i][j]] = ele[i][j];
}
}
for (long long i = 1; i <= n; i++) cout << vc[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n + 1], pos[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
vector<int> adj[n + 1];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[a[u]].push_back(a[v]);
adj[a[v]].push_back(a[u]);
}
bool visit[n + 1];
memset(visit, 0, sizeof(visit));
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
vector<int> val, tmp_pos;
queue<int> Q;
Q.push(i);
visit[i] = true;
val.push_back(i);
tmp_pos.push_back(pos[i]);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (!visit[v]) {
visit[v] = true;
Q.push(v);
val.push_back(v);
tmp_pos.push_back(pos[v]);
}
}
}
sort(val.rbegin(), val.rend());
sort(tmp_pos.begin(), tmp_pos.end());
for (int i = 0; i < val.size(); i++) a[tmp_pos[i]] = val[i];
val.clear();
tmp_pos.clear();
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " \n"[i == n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000005], frr[1000005];
int find(int x) { return x == frr[x] ? x : frr[x] = find(frr[x]); }
set<int> S[1000005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) frr[i] = i;
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
frr[find(x)] = find(y);
}
for (int i = 1; i <= n; i++) S[find(i)].insert(a[i]);
for (int i = 1; i <= n; i++) {
int t = find(i);
printf("%d%c", *--S[t].end(), " \n"[i == n]);
S[t].erase(--S[t].end());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int pwr(long long int base, long long int p, long long int mod) {
long long int ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int par[1000005];
vector<int> v[1000005];
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
par[x] = y;
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
int a[n];
for (int i = (0); i < (n); ++i) {
scanf("%d", &a[i]);
par[a[i]] = a[i];
}
for (int i = (0); i < (m); ++i) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
merge(x, y);
}
for (int i = (0); i < (n); ++i) {
int x = find(i + 1);
v[x].push_back(a[i]);
}
for (int i = (0); i < (n); ++i) {
sort(v[i + 1].begin(), v[i + 1].end());
}
for (int i = (0); i < (n); ++i) {
int x = find(i + 1);
a[i] = v[x].back();
v[x].pop_back();
}
for (int i = (0); i < (n); ++i) {
cout << a[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int a[MAXN], parent[MAXN], rnk[MAXN];
vector<int> arr[MAXN];
vector<int> ans;
void make_set(int v) {
parent[v] = v;
rnk[v] = 0;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rnk[a] < rnk[b]) swap(a, b);
parent[b] = a;
if (rnk[a] == rnk[b]) rnk[a]++;
}
}
int main() {
int n, m;
cin >> n >> m;
ans.clear();
ans.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
make_set(i);
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
union_sets(u, v);
}
for (int i = 0; i < n; i++) {
int st = find_set(i);
arr[st].push_back(a[i]);
}
for (int i = 0; i < n; i++) {
sort(arr[i].begin(), arr[i].end());
}
for (int i = 0; i < n; i++) {
int st = find_set(i);
int x = arr[st].back();
arr[st].pop_back();
ans[i] = x;
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int mxn = (1e6) + 5;
vector<int> graph[mxn];
vector<int> in[mxn];
vector<int> val[mxn];
int a[mxn];
int vis[mxn];
int cur = 0;
void dfs(int v) {
vis[v] = cur;
in[cur].push_back(v);
val[cur].push_back(a[v]);
for (int i = 0; i < graph[v].size(); ++i) {
int u = graph[v][i];
if (vis[u] == 0) dfs(u);
}
}
int ans[mxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (vis[i] == 0) {
++cur;
dfs(i);
}
for (int i = 1; i <= cur; ++i) {
sort(in[i].begin(), in[i].end());
sort(val[i].begin(), val[i].end());
for (int j = 0; j < in[i].size(); ++j)
ans[in[i][j]] = val[i][in[i].size() - (j + 1)];
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1000010] = {false};
int a[1000010];
vector<int> v[1000010];
inline void solve(int init) {
set<int> s;
priority_queue<int> qq;
queue<int> q;
q.push(init);
s.insert(init);
qq.push(a[init]);
vis[init] = true;
while (!q.empty()) {
int xx = q.front();
q.pop();
for (int i = 0; i < v[xx].size(); i++) {
if (!vis[v[xx][i]]) {
q.push(v[xx][i]);
vis[v[xx][i]] = true;
s.insert(v[xx][i]);
qq.push(a[v[xx][i]]);
}
}
}
set<int>::iterator it;
if (!qq.empty()) {
it = s.begin();
while (!qq.empty()) {
a[(*it)] = qq.top();
qq.pop();
it++;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, q, i, n1, n2;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i < q; i++) {
scanf("%d%d", &n1, &n2);
v[n1].push_back(n2);
v[n2].push_back(n1);
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
solve(i);
}
}
for (i = 1; i <= n; i++) printf("%d ", a[i]);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:640000000")
using namespace std;
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _swap(T& a, T& b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int t, n, m;
vector<int> adj[1000005];
int arr[1000005];
bool mark[1000005];
vector<int> v, res;
void bfs(int src) {
queue<int> q;
q.push(src);
mark[src] = 1;
v.push_back(src);
res.push_back(arr[src]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (adj[u].size()); i++) {
int vv = adj[u][i];
if (mark[vv] == 0) {
q.push(vv);
mark[vv] = 1;
v.push_back(vv);
res.push_back(arr[vv]);
}
}
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= (n); i++) adj[i].clear();
for (int i = 1; i <= (n); i++) scanf("%d", &arr[i]);
for (int i = 1; i <= (m); i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= (n); i++)
if (mark[i] == 0) {
res.clear();
v.clear();
bfs(i);
sort(v.begin(), v.end());
sort(res.begin(), res.end());
reverse(res.begin(), res.end());
for (int i = 0; i < (v.size()); i++) arr[v[i]] = res[i];
}
for (int i = 1; i <= (n); i++) printf("%d ", arr[i]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
priority_queue<int> q[N];
int fa[N];
int n;
void init() {
for (int i = 0; i <= n; i++) {
fa[i] = i;
while (!q[i].empty()) q[i].pop();
}
}
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a != b) fa[a] = fa[b];
}
int tar[N];
int main() {
int m;
while (scanf("%d%d", &n, &m) == 2) {
init();
memset(tar, 0, sizeof(tar));
for (int i = 1; i <= n; i++) scanf("%d", tar + i);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
merge(u, v);
}
for (int i = 1; i <= n; i++) q[find(i)].push(tar[i]);
for (int i = 1; i <= n; i++) {
int temp = q[find(i)].top();
q[find(i)].pop();
printf("%d", temp);
i == n ? printf("\n") : printf(" ");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
vector<int> g[N], comp;
int vis[N];
void dfs(int u) {
vis[u] = true;
comp.push_back(u);
for (int i = 0; i < g[u].size(); ++i)
if (!vis[g[u][i]]) dfs(g[u][i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int a[n + 1];
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
dfs(i);
vector<int> z;
for (int i = 0; i < comp.size(); ++i) z.push_back(a[comp[i]]);
sort(z.begin(), z.end());
reverse(z.begin(), z.end());
sort(comp.begin(), comp.end());
for (int i = 0; i < comp.size(); ++i) a[comp[i]] = z[i];
comp.clear();
}
}
for (int i = 1; i <= n; ++i) cout << a[i] << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
bool prime_check(long long int n) {
long long int i, j;
if (n == 1) {
return false;
}
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long int fact(long long int n) {
long long int prod = 1;
for (long long int i = 1; i <= n; i++) {
prod = (prod * i) % 1000000007;
}
return prod;
}
bool vowl(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
const int N = 1e6 + 4;
int rk[N], par[N];
int findp(int x) {
if (x == par[x]) return x;
return par[x] = findp(par[x]);
}
void Merge(int x, int y) {
x = findp(x);
y = findp(y);
if (x == y) return;
if (rk[x] > rk[y]) swap(x, y);
par[x] = y;
rk[y] += rk[x];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i;
cin >> n >> m;
int p[n + 4];
for (i = 1; i <= n; i++) cin >> p[i];
for (i = 1; i <= n; i++) {
par[i] = i;
rk[i] = 1;
}
for (i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
Merge(x, y);
}
vector<int> v[n + 3];
for (i = 1; i <= n; i++) {
v[findp(i)].push_back(p[i]);
}
for (i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
int ans[n + 3];
for (i = 1; i <= n; i++) {
ans[i] = v[findp(i)].back();
v[findp(i)].pop_back();
}
for (i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<list<int> > adjlist(2000000);
vector<int> key, value;
int visited[2000000], ans[2000000];
int ar[2000000];
bool compare(int a, int b) { return (a > b); }
void dfs(int i) {
list<int>::iterator it;
for (it = adjlist[i].begin(); it != adjlist[i].end(); it++) {
if (!visited[*it]) {
visited[*it] = 1;
key.push_back(*it);
value.push_back(ar[*it]);
dfs(*it);
}
}
}
int main() {
int n, m, i, a, b;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &a);
scanf("%d", &b);
adjlist[a].push_back(b);
adjlist[b].push_back(a);
}
for (i = 1; i <= n; i++) {
if (!visited[i]) {
visited[i] = 1;
key.push_back(i);
value.push_back(ar[i]);
dfs(i);
vector<int>::iterator it1, it2;
sort(key.begin(), key.end());
sort(value.begin(), value.end(), compare);
it1 = key.begin();
it2 = value.begin();
while (it1 != key.end()) {
ans[*it1] = (*it2);
it1++;
it2++;
}
key.clear();
value.clear();
}
}
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> b;
list<int> b1v;
vector<list<int>> aa;
void doRec(int vv) {
if (b[vv] > 0) return;
b[vv] = 1;
b1v.push_back(vv);
if (!aa[vv].empty())
for (auto it = aa[vv].begin(); it != aa[vv].end(); it++) doRec(*it);
}
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n + 1);
aa.resize(n + 1);
b.resize(n + 1, 0);
for (int i = 1; i < n + 1; i++) scanf("%d", &p[i]);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
aa[a].push_back(b);
aa[b].push_back(a);
}
for (int d = 1; d <= n; d++)
if (b[d] == 0) {
b1v.clear();
doRec(d);
set<int> su;
su.insert(b1v.begin(), b1v.end());
vector<int> p1;
p1.resize(su.size());
int pInd = 0;
for (auto bb = su.begin(); bb != su.end(); bb++) p1[pInd++] = p[*bb];
sort(p1.rbegin(), p1.rend());
pInd = 0;
for (auto bb = su.begin(); bb != su.end(); bb++) p[*bb] = p1[pInd++];
}
for (int i = 1; i < n + 1; i++) printf("%d ", p[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
int l = v.size();
for (int i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
void tr() { cout << endl; }
template <typename S, typename... Strings>
void tr(S x, const Strings&... rest) {
cout << x << ' ';
tr(rest...);
}
const int N = 1001000;
int n, m;
int p[N];
vector<int> g[N];
vector<int> comp[N];
int v[N];
int ans[N];
void dfs(int cur, int id) {
if (v[cur]) return;
v[cur] = 1;
comp[id].push_back(cur);
for (__typeof((g[cur]).begin()) it = (g[cur]).begin(); it != (g[cur]).end();
++it) {
dfs(*it, id);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!v[i]) {
dfs(i, cnt);
vector<int> t;
for (__typeof((comp[cnt]).begin()) it = (comp[cnt]).begin();
it != (comp[cnt]).end(); ++it) {
t.push_back(p[*it]);
}
sort(t.begin(), t.end(), greater<int>());
sort(comp[cnt].begin(), comp[cnt].end());
for (int j = 0; j < t.size(); j++) {
ans[comp[cnt][j]] = t[j];
}
cnt++;
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
vector<int> v1[1000000 + 1];
int taken[1000000 + 1];
vector<int> temp;
vector<int> temp1;
void bfs(int u) {
temp.clear();
temp1.clear();
queue<int> q;
q.push(u);
taken[u] = 1;
temp.push_back(u);
temp1.push_back(v[u]);
while (!q.empty()) {
int l = q.front();
q.pop();
for (int j = 0; j < v1[l].size(); j++) {
int x = v1[l][j];
if (taken[x] == 0) {
q.push(x);
taken[x] = 1;
temp.push_back(x);
temp1.push_back(v[x]);
}
}
}
}
int main() {
int n, i, p, q, a, b;
cin >> n >> q;
for (i = 1; i <= n; i++) {
scanf("%d", &p);
v.push_back(p);
}
while (q--) {
scanf("%d%d", &a, &b);
a--;
b--;
v1[a].push_back(b);
v1[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (taken[i] == 0) {
bfs(i);
sort(temp1.rbegin(), temp1.rend());
sort(temp.begin(), temp.end());
for (int j = 0; j < temp.size(); j++) {
v[temp[j]] = temp1[j];
}
}
}
for (int j = 0; j < v.size(); j++) {
printf("%d ", v[j]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000111], vis[1000111];
vector<pair<int, int> > v;
vector<int> adj[1000111];
vector<int> pos;
void dfs(int u) {
vis[u] = 1;
v.push_back(make_pair(a[u], u));
pos.push_back(u);
for (int i = 0; i < adj[u].size(); i++) {
int k = adj[u][i];
if (vis[k]) continue;
dfs(k);
}
}
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (i = 0; i < n; i++) {
if (vis[i]) continue;
v.clear();
pos.clear();
dfs(i);
sort(pos.rbegin(), pos.rend());
sort(v.rbegin(), v.rend());
for (j = 0; j < v.size(); j++) {
a[pos.back()] = v[j].first;
pos.pop_back();
}
}
for (i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[1000000];
int vis[1000000];
int a[1000000];
vector<int> num;
vector<int> idx;
int j;
void dfs(int node) {
vis[node] = j;
num.push_back(a[node]);
idx.push_back(node);
int i;
for (i = 0; i < v[node].size(); i++) {
int u = v[node][i];
if (vis[u] > j) dfs(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int ans[n];
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
ans[i] = a[i];
vis[i] = INT_MAX;
}
int x, y;
for (i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 0; i < n; i++) {
if (vis[i] > j) {
num.clear();
idx.clear();
dfs(i);
sort(num.begin(), num.end());
sort(idx.begin(), idx.end());
reverse(num.begin(), num.end());
int k;
for (k = 0; k < num.size(); k++) {
ans[idx[k]] = num[k];
}
j++;
}
}
for (i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000011;
int n, q, cnt, j, m, x, y;
int ans[N], t[N];
vector<int> d[N], kks, otv;
bool used[N];
void dfs(int v) {
int sm;
used[v] = 1;
kks.push_back(v);
otv.push_back(t[v]);
for (auto x : d[v]) {
if (!used[x]) {
dfs(x);
}
}
}
int main() {
scanf("%d%d/n", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d/n", &x, &y);
d[x].push_back(y);
d[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
sort(kks.begin(), kks.end());
sort(otv.begin(), otv.end());
for (auto x : kks) {
ans[x] = *(--otv.end());
otv.erase(--otv.end());
}
kks.clear();
otv.clear();
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
int n, m;
int ar[MAX];
vector<int> v[MAX];
vector<int> path;
vector<int> idx;
bool mk[MAX];
void dfs(int node) {
mk[node] = true;
path.push_back(ar[node]);
idx.push_back(node);
for (int i = 0; i < v[node].size(); i++)
if (!mk[v[node][i]]) dfs(v[node][i]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> ar[i];
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[b].push_back(a);
v[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (!mk[i]) {
dfs(i);
sort(path.begin(), path.end());
sort(idx.begin(), idx.end());
reverse(path.begin(), path.end());
for (int j = 0; j < idx.size(); j++) {
ar[idx[j]] = path[j];
}
idx.clear();
path.clear();
}
}
for (int i = 1; i <= n; i++) cout << ar[i] << (i == n ? "\n" : " ");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e6 + 1;
vector<vector<long long> > g(MAXN);
bool used[MAXN];
vector<long long> ans(MAXN);
priority_queue<long long> q;
vector<long long> a;
priority_queue<long long> val;
void dfs(long long v) {
val.push(a[v]);
q.push(-v);
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (!used[to]) {
used[to] = 1;
dfs(to);
}
}
}
void func() {
while (q.size() != 0) {
long long a = -q.top(), b = val.top();
ans[a] = b;
q.pop(), val.pop();
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long b;
cin >> b;
a.push_back(b);
}
for (long long i = 0; i < m; i++) {
long long l, r;
cin >> l >> r;
l--, r--;
g[r].push_back(l);
g[l].push_back(r);
}
for (long long i = 0; i < n; i++) {
if (!used[i]) {
used[i] = 1;
dfs(i);
func();
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m;
int a[maxn], par[maxn], t[maxn];
vector<int> g[maxn];
int get_par(int v) { return (par[v] == -1) ? v : par[v] = get_par(par[v]); }
void merge(int u, int v) {
u = get_par(u);
v = get_par(v);
if (v == u) return;
par[u] = v;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
memset(par, -1, sizeof par);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
merge(u, v);
}
for (int i = 1; i <= n; i++) g[get_par(i)].push_back(a[i]);
for (int i = 1; i <= n; i++) sort(g[i].begin(), g[i].end());
for (int i = 1; i <= n; i++) {
cout << g[get_par(i)].back() << ' ';
g[get_par(i)].pop_back();
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int viz[1000000 + 7], a[1000000 + 7], nc, b[1000000 + 7];
vector<int> L[1000000 + 7];
vector<int> c[1000000 + 7];
void Citire() {
int i, x, y;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
L[x].push_back(y);
L[y].push_back(x);
}
}
void DFS(int k, int nc) {
viz[k] = 1;
c[nc].push_back(k);
for (auto w : L[k])
if (!viz[w]) DFS(w, nc);
}
void CompConexe() {
int i;
for (i = 1; i <= n; i++)
if (!viz[i]) {
nc++;
DFS(i, nc);
sort(c[nc].begin(), c[nc].end());
}
}
void Rezolva() {
int i, k;
for (int pas = 1; pas <= nc; pas++) {
k = 0;
for (auto j : c[pas]) b[++k] = a[j];
sort(b + 1, b + k + 1, greater<int>());
i = 1;
for (auto j : c[pas]) a[j] = b[i++];
}
for (i = 1; i <= n; i++) printf("%d ", a[i]);
}
int main() {
Citire();
CompConexe();
Rezolva();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> num[1000005];
vector<int> pos[1000005];
int p[1000005], a[1000005], ans[1000005];
int fa[1000005];
int Find(int x) {
if (x == fa[x]) return x;
return fa[x] = Find(fa[x]);
}
void Merge(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return;
fa[x] = y;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
fa[i] = i;
scanf("%d", &a[i]);
p[i] = i;
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
Merge(a, b);
}
for (int i = 1; i <= n; i++) {
int x = Find(i);
pos[x].push_back(i);
num[x].push_back(-a[i]);
}
for (int i = 1; i <= n; i++) {
sort(num[i].begin(), num[i].end());
for (int j = 0; j < pos[i].size(); j++) {
ans[pos[i][j]] = -num[i][j];
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void Mark(int v, int c, const vector<vector<int>>& gr, vector<int>& color) {
color[v] = c;
for (int u : gr[v]) {
if (color[u] == -1) {
Mark(u, c, gr, color);
}
}
}
int main() {
int N, M;
scanf("%d%d", &N, &M);
vector<int> A(N);
for (int& a : A) {
scanf("%d", &a);
}
vector<vector<int>> gr(N);
for (int i = 0; i < M; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
gr[a].push_back(b);
gr[b].push_back(a);
}
vector<int> color(N, -1);
int color_cnt = 0;
for (int i = 0; i < N; ++i) {
if (color[i] == -1) {
Mark(i, color_cnt, gr, color);
++color_cnt;
}
}
vector<vector<int>> parts(color_cnt), indexes(color_cnt);
for (int i = 0; i < N; ++i) {
parts[color[i]].push_back(A[i]);
indexes[color[i]].push_back(i);
}
for (auto& p : parts) {
sort(p.begin(), p.end(), greater<int>());
}
vector<int> R(N);
for (int c = 0; c < color_cnt; ++c) {
for (int i = 0; i < parts[c].size(); ++i) {
R[indexes[c][i]] = parts[c][i];
}
}
for (int r : R) {
printf("%d ", r);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000009;
vector<long long int> v[N], v1, v2;
bool check[N];
long long int a[N];
void DFS(int x) {
check[x] = true;
for (int i = 0; i < v[x].size(); i++)
if (!check[v[x][i]]) {
v1.push_back(v[x][i]);
v2.push_back(a[v[x][i]]);
DFS(v[x][i]);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m, j, k;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> j >> k;
v[j].push_back(k);
v[k].push_back(j);
}
for (int i = 1; i <= n; i++) {
if (!check[i]) {
v1.push_back(i);
v2.push_back(a[i]);
DFS(i);
}
sort(v2.rbegin(), v2.rend());
sort(v1.begin(), v1.end());
for (int j = 0; j < v2.size(); j++) a[v1[j]] = v2[j];
v1.clear();
v2.clear();
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
return cout << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1000006;
vector<int> G[N], res[N];
int n, m;
int ans[N], inp[N];
int seen[N], arr[N];
void dfs(int u, int cnt) {
seen[u] = cnt;
res[cnt].push_back(inp[u]);
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i];
if (!seen[v]) {
dfs(v, cnt);
}
}
}
int main() {
n = in();
m = in();
for (int i = 1; i <= n; i++) inp[i] = in(), ans[i] = 0, seen[i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
u = in();
v = in();
G[u].push_back(v);
G[v].push_back(u);
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (!seen[i]) {
cnt = cnt + 1;
dfs(i, cnt);
sort(res[cnt].rbegin(), res[cnt].rend());
}
}
for (int i = 1; i <= n; i++) {
int x = seen[i];
printf("%d ", res[x][ans[x]]);
ans[x]++;
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, m, p[N], f[N], pos[N];
vector<int> vec[N];
int find(int u) { return u == f[u] ? u : f[u] = find(f[u]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", p + i), f[i] = i;
for (int u, v, i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
u = find(u);
v = find(v);
if (u != v) f[v] = u;
}
for (int i = 1; i <= n; i++) vec[find(i)].push_back(p[i]);
for (int i = 1; i <= n; i++)
if (f[i] == i) {
sort(vec[i].begin(), vec[i].end(), greater<int>());
}
for (int i = 1; i <= n; i++) {
printf("%d%c", vec[f[i]][pos[f[i]]++], " \n"[i == n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
inline int nxt() {
int wow;
scanf("%d", &wow);
return wow;
}
inline long long int lxt() {
long long int wow;
scanf("%lld", &wow);
return wow;
}
vector<int> v[1000002], temp;
int a[1000002], visited[1000002], ans[1000002];
bool comp(int x, int y) { return x > y; }
void dfs(int s) {
visited[s] = 1;
temp.push_back(s);
for (int i = 0; i < v[s].size(); i++) {
int t = v[s][i];
if (visited[t] == 0) dfs(t);
}
}
int main() {
int n = nxt(), m = nxt();
for (int i = 1; i <= n; i++) a[i] = nxt();
for (int i = 0; i < m; i++) {
int x = nxt(), y = nxt();
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
dfs(i);
sort(temp.begin(), temp.end(), comp);
vector<int> vara;
for (int i = 0; i < temp.size(); i++) vara.push_back(a[temp[i]]);
sort(vara.begin(), vara.end());
for (int i = 0; i < temp.size(); i++) ans[temp[i]] = vara[i];
temp.clear();
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7, mod1 = 1e9 + 9;
const long long N = 1000005;
vector<long long> v, v2;
int a[N], vis[N];
vector<long long> ed[N];
void dfs(int in) {
vis[in] = 1;
v.push_back((a[in]));
v2.push_back(in);
for (auto x : ed[in]) {
if (!vis[x]) dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n, m;
cin >> n >> m;
for (long long i = 1; i <= (n); i++) cin >> a[i];
for (long long i = 0; i < (m); i++) {
int x, y;
cin >> x >> y;
ed[x].push_back(y), ed[y].push_back(x);
}
for (long long i = 1; i <= (n); i++) {
if (!vis[i])
dfs(i);
else
continue;
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
sort((v2).begin(), (v2).end());
for (long long i = 0; i < ((int)v.size()); i++) {
a[v2[i]] = v[i];
}
v.clear();
v2.clear();
}
for (long long i = 1; i <= (n); i++) cout << a[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long mod = 998244353;
const double pi = acos(-1);
long long fastpow(long long b, long long e) {
if (!e) return 1;
long long ret = fastpow(b, e / 2);
ret = (ret * ret) % mod;
if (e % 2) ret = (ret * b) % mod;
return ret;
}
long long modinv(long long x) { return fastpow(x, mod - 2); }
double torad(double ang) { return ang * pi / 180.0; }
vector<vector<int> > v(N);
bool vis[N] = {0};
int a[N];
vector<int> idx, val;
void dfs(int node) {
if (vis[node]) return;
vis[node] = 1;
idx.push_back(node);
val.push_back(a[node]);
for (int i = 0; i < v[node].size(); i++) {
int cur = v[node][i];
dfs(cur);
}
}
int res[N];
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i);
sort(idx.begin(), idx.end());
sort(val.rbegin(), val.rend());
for (int j = 0; j < val.size(); j++) {
res[idx[j]] = val[j];
}
idx.clear();
val.clear();
}
}
for (int i = 0; i < n; i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int mod = 1000000007;
const double pi = acos(-1);
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
const int maxn = 1e6 + 100;
vector<int> v[maxn << 2];
int f[maxn];
int ite[maxn] = {0};
int find(int x) {
if (x == f[x]) return x;
return find(f[x]);
}
void add(int a, int b) {
a = find(a);
b = find(b);
f[a] = b;
}
int numb[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = (1); i <= (n); i++) gn(numb[i]), f[i] = i;
int a, b;
for (int i = (1); i <= (m); i++) {
cin >> a >> b;
add(a, b);
}
for (int i = (1); i <= (n); i++) v[find(f[i])].push_back(-numb[i]);
for (int i = (1); i <= (n); i++) sort(v[i].begin(), v[i].end());
for (int i = (1); i <= (n); i++) {
int f = find(i);
printf("%d ", -v[f][ite[f]++]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1123456;
int a[N];
vector<int> v[N];
int c[N];
priority_queue<int> q[N];
void dfs(int x, int t) {
c[x] = t;
q[t].push(a[x]);
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (!c[to]) {
dfs(to, t);
}
}
}
int main() {
int n, m, i, j, x, y;
n = read();
m = read();
for (i = 1; i <= n; i++) {
a[i] = read();
}
for (i = 1; i <= m; i++) {
x = read();
y = read();
v[x].push_back(y);
v[y].push_back(x);
}
int cnt = 1;
for (i = 1; i <= n; i++) {
if (!c[i]) {
dfs(i, cnt++);
}
}
for (i = 1; i <= n; i++) {
printf("%d ", q[c[i]].top());
q[c[i]].pop();
}
}
|
#include <bits/stdc++.h>
using namespace std;
class DSU {
public:
int *parent;
int n;
DSU(int n) : n(n) {
parent = new int[n];
for (int i = 0; i < n; ++i) parent[i] = -1;
};
int root(int x);
void merge(int x, int y);
bool areInSame(int x, int y);
~DSU();
};
int DSU::root(int x) {
return (parent[x] < 0 ? x : (parent[x] = root(parent[x])));
}
void DSU::merge(int x, int y) {
if ((x = root(x)) == (y = root(y))) return;
if (parent[x] > parent[y]) swap(x, y);
parent[x] += parent[y];
parent[y] = x;
}
bool DSU::areInSame(int x, int y) { return (root(x) == root(y)); }
DSU::~DSU() { delete parent; }
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
int n;
cin >> n;
int m;
cin >> m;
DSU d(n);
vector<int> a(n);
for (int o = 0; o < n; o++) {
cin >> a[o];
}
std::vector<pair<int, int> > v(m);
for (int i = 0; i < m; ++i) {
int o;
cin >> o;
int u;
cin >> u;
d.merge(u - 1, o - 1);
}
priority_queue<int> pq[n];
for (int i = 0; i < n; ++i) {
pq[d.root(i)].push(a[i]);
}
for (int i = 0; i < n; ++i) {
int y = pq[d.root(i)].top();
pq[d.root(i)].pop();
a[i] = y;
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
long long mod2 = 998244353;
long long OO = 1e18;
long long david_villa_pow(long long x, long long n) {
if (n == 0) return 1;
long long u = david_villa_pow(x, n / 2);
u = ((u % mod) * (u % mod)) % mod;
if (n % 2 == 1) u = ((u % mod) * (x % mod)) % mod;
return u % mod;
}
long long up(long long x, long long y) {
if (x % y == 0) return x / y;
return x / y + 1;
}
using namespace std;
int n, m;
int Leader[2000200];
int sz[2000200];
int get_Leader(int node);
void dsu(int x, int y) {
int lx = get_Leader(x);
int ly = get_Leader(y);
if (sz[lx] < sz[ly]) {
Leader[lx] = ly;
sz[ly] += sz[lx];
} else {
Leader[ly] = lx;
sz[lx] += sz[ly];
}
}
int get_Leader(int node) {
if (Leader[node] == node) return node;
return Leader[node] = get_Leader(Leader[node]);
}
int p[2000200];
set<int> s;
set<int>::iterator it;
set<int> s2;
set<int>::iterator it2;
vector<int> v[2000200];
int res[2000200];
void El_MaraVilla() {
long long i, j;
;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i]);
Leader[i] = i;
sz[i] = 1;
}
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
dsu(x, y);
}
for (i = 1; i <= n; i++) {
v[get_Leader(i)].push_back(i);
s.insert(get_Leader(i));
}
for (it = s.begin(); it != s.end(); it++) {
int L = (*it);
for (j = 0; j < v[L].size(); j++) s2.insert(p[v[L][j]]);
j = v[L].size() - 1;
for (it2 = s2.begin(); it2 != s2.end(); it2++) res[v[L][j--]] = (*it2);
s2.clear();
}
for (i = 1; i <= n; i++) printf("%d ", res[i]);
}
int main() {
long long T = 1;
while (T--) {
El_MaraVilla();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> ans[N];
vector<int> root;
int pos[N], par[N], a[N], vis[N];
int Find(int n) {
if (n == par[n]) return n;
return par[n] = Find(par[n]);
}
int main() {
int n, m, u, v;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
par[i] = i;
}
while (m--) {
scanf("%d %d", &u, &v);
u = Find(u), v = Find(v);
if (u != v) par[u] = v;
}
for (int i = 1; i <= n; ++i) {
int u = Find(i);
ans[u].push_back(a[i]);
if (!vis[u]) {
root.push_back(u);
vis[u] = true;
}
}
for (int i = 0; i < root.size(); ++i)
sort(ans[root[i]].rbegin(), ans[root[i]].rend());
for (int i = 1; i < n; ++i) printf("%d ", ans[Find(i)][pos[Find(i)]++]);
printf("%d\n", ans[Find(n)][pos[Find(n)]]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int mod = 1e9 + 9;
const int INF = 1e9 + 7;
const int mlog = 21;
const int SQ = 400;
vector<int> adj[maxn];
int mark[maxn], f[maxn], ptr[maxn];
int a[maxn];
bool cmp(int x, int y) { return a[x] > a[y]; }
int get(int v) { return f[v] = (f[v] == v ? v : get(f[v])); }
void merge(int v, int u) {
u = get(u);
v = get(v);
if (u == v) return;
if (adj[u].size() > adj[v].size()) swap(u, v);
for (int x : adj[u]) adj[v].push_back(x);
f[u] = v;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) f[i] = i, adj[i].push_back(i);
while (m--) {
int l, r;
cin >> l >> r;
l--, r--;
merge(l, r);
}
for (int i = 0; i < n; i++) {
int v = get(i);
if (!mark[v]) {
mark[v] = true;
sort(adj[v].begin(), adj[v].end(), cmp);
}
}
for (int i = 0; i < n; i++) {
int v = get(i);
cout << a[adj[v][ptr[v]]] << " ";
ptr[v]++;
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996);
const long long mod = 1e9 + 7;
const int iinf = (int)1e9;
const long long inf = (long long)1e18;
const double eps = (double)0.000001;
using namespace std;
template <class T, class T1>
void res(vector<T>& v, long long n, T1 a) {
v.assign(n, a);
}
template <class T, class T1>
void res(vector<vector<T>>& v, long long n, long long m, T1 a) {
v.assign(n, vector<T>(m, a));
}
template <class T, class T1>
void res(vector<vector<vector<T>>>& v, long long n, long long m, long long z,
T1 a) {
v.assign(n, vector<vector<T>>(m, vector<T>(z, a)));
}
void file_input() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const long long Z = 1e3 + 10;
const long long N = 1e6 + 10;
int n, m, i, j, k, l, r;
vector<int> g[N];
int ans[N], a[N], ind[N];
bool used[N];
vector<int> comp, compi;
void dfs(int v) {
used[v] = true;
comp.emplace_back(v);
compi.emplace_back(ind[v]);
for (auto r : g[v]) {
if (!used[r]) {
dfs(r);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
ans[i] = a[i];
}
for (i = 1; i <= m; i++) {
int v1, v2;
cin >> v1 >> v2;
ind[a[v1]] = v1;
ind[a[v2]] = v2;
v1 = a[v1];
v2 = a[v2];
g[v1].emplace_back(v2);
g[v2].emplace_back(v1);
}
for (i = 1; i <= n; i++) {
if (!used[i]) {
comp.clear();
compi.clear();
dfs(i);
sort((comp).begin(), (comp).end(), greater<int>());
sort((compi).begin(), (compi).end());
for (j = 0; j <= comp.size() - 1; j++) {
ans[compi[j]] = comp[j];
}
}
}
for (i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, d;
bool used[1000006];
vector<int> g[1000006];
vector<int> perm, pos;
vector<int> arr(1000006);
vector<int> ans(1000006);
void dfs(int v) {
if (used[v]) return;
used[v] = true;
pos.push_back(v);
perm.push_back(arr[v]);
for (auto to : g[v]) dfs(to);
}
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i]--;
}
vector<pair<int, int> > v(d);
for (int i = 0; i < d; i++) {
cin >> v[i].first >> v[i].second;
v[i].first--;
v[i].second--;
}
for (int i = 0; i < n; i++) {
used[i] = false;
}
for (int i = 0; i < d; i++) {
g[v[i].first].push_back(v[i].second);
g[v[i].second].push_back(v[i].first);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
cnt++;
pos.clear();
perm.clear();
dfs(i);
sort(pos.begin(), pos.end());
sort(perm.begin(), perm.end(), greater<int>());
for (int j = 0; j < perm.size(); j++) ans[pos[j]] = perm[j];
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000001], B[1000001], A[1000001], c, b, fix[1000001], Ans[1000001],
k;
vector<int> v[1000001];
void dfs(int x) {
if (fix[x]) return;
fix[x] = 1;
A[k] = a[x];
B[k++] = x;
for (int i = 0; i < v[x].size(); i++) {
dfs(v[x][i]);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> c >> b;
if (c == b) continue;
v[c].push_back(b);
v[b].push_back(c);
}
for (int i = 1; i <= n; i++) {
k = 1;
if (!fix[i]) dfs(i);
if (k == 1) continue;
sort(A + 1, A + k);
sort(B + 1, B + k);
for (int j = 1; j < k; j++) {
Ans[B[j]] = A[k - j];
}
}
for (int i = 1; i <= n; i++) cout << Ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int head[N], cnt;
struct edge {
int n, t;
edge(int a = 0, int b = 0) : n(a), t(b) {}
} e[N << 1];
void ins(int a, int b) {
e[cnt] = edge(head[a], b);
head[a] = cnt++;
}
int n, m, in[N], ans[N], t1[N], t2[N], cc;
bool vis[N];
queue<int> que;
void solve(int cur) {
int i, u, v;
while (!que.empty()) que.pop();
que.push(cur);
vis[cur] = 1;
cc = 1;
t1[0] = cur;
t2[0] = in[cur];
while (!que.empty()) {
u = que.front();
que.pop();
for (i = head[u]; i != -1; i = e[i].n) {
v = e[i].t;
if (vis[v]) continue;
vis[v] = 1;
que.push(v);
t1[cc] = v;
t2[cc++] = in[v];
}
}
sort(t1, t1 + cc);
sort(t2, t2 + cc, greater<int>());
for (i = 0; i < cc; ++i) ans[t1[i]] = t2[i];
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
int i, j, a, b;
for (i = 1; i <= n; ++i) scanf("%d", in + i);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
ins(a, b);
ins(b, a);
}
for (i = 1; i <= n; ++i)
if (!vis[i]) solve(i);
for (i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 2e18;
const int N = 1e6, M = N;
int n, m, G = 0;
vector<int> adj[N + 5];
int gr[N + 5], p[N + 5];
vector<int> pth[N + 5];
vector<int> PTH_myEndlessLove;
int Pos[N + 5];
void dfs(int u) {
gr[u] = G;
PTH_myEndlessLove.push_back(u);
for (int i = (0), _b = (((int)(adj[u]).size())); i < _b; ++i) {
int v = adj[u][i];
if (gr[v]) continue;
dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; ++i) cin >> p[i];
int u, v;
while (m--) {
cin >> u >> v;
adj[p[u]].push_back(p[v]);
adj[p[v]].push_back(p[u]);
}
for (int i = (1), _b = (n); i <= _b; ++i)
if (!gr[p[i]]) {
PTH_myEndlessLove.clear();
++G;
dfs(p[i]);
sort(PTH_myEndlessLove.begin(), PTH_myEndlessLove.end());
reverse(PTH_myEndlessLove.begin(), PTH_myEndlessLove.end());
pth[G] = PTH_myEndlessLove;
}
for (int i = (1), _b = (n); i <= _b; ++i) {
cout << pth[gr[p[i]]][Pos[gr[p[i]]]] << ' ';
++Pos[gr[p[i]]];
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int seen[1000100];
vector<int> g[1000100];
vector<int> gg;
void dfs(int u) {
if (seen[u] == 1) return;
seen[u] = 1;
gg.push_back(u);
for (auto i : g[u]) {
dfs(i);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int inp[n];
for (int i = 0; i < n; i++) {
scanf("%d", &inp[i]);
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
memset(seen, 0, sizeof(seen));
for (int i = 0; i < n; i++) {
if (seen[i] == 0) {
gg.clear();
dfs(i);
sort(gg.begin(), gg.end());
vector<int> num;
for (int j = 0; j < (int)gg.size(); j++) {
num.push_back(inp[gg[j]]);
}
sort(num.begin(), num.end());
reverse(num.begin(), num.end());
for (int j = 0; j < (int)gg.size(); j++) {
inp[gg[j]] = num[j];
}
}
}
for (int i = 0; i < n; i++) {
printf("%d ", inp[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<int> arr(n + 1);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int u, v;
vector<vector<int>> graph(n + 1);
for (int i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
vector<bool> visited(n + 1, false);
vector<int> store;
function<void(int)> dfs = [&](int u) {
visited[u] = true;
store.push_back(u);
for (auto item : graph[u]) {
if (!visited[item]) {
dfs(item);
}
}
};
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
store.clear();
dfs(i);
vector<int> values;
for (auto item : store) {
values.push_back(arr[item]);
}
sort(store.begin(), store.end());
sort(values.rbegin(), values.rend());
for (int k = 0; k < store.size(); k++) {
arr[store[k]] = values[k];
}
}
}
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int p[maxn];
int pa[maxn];
int ra[maxn];
int ans[maxn];
int kk[maxn];
vector<int> G[maxn];
vector<int> Gx[maxn];
map<int, int> ma;
void init(int n) {
for (int i = 0; i <= n; i++) {
pa[i] = i;
ra[i] = 0;
}
}
int find(int x) {
if (pa[x] != x) pa[x] = find(pa[x]);
return pa[x];
}
int unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return 0;
if (ra[x] < ra[y]) {
pa[x] = y;
} else {
pa[y] = x;
if (ra[x] == ra[y]) ra[x]++;
}
return 1;
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
ios::sync_with_stdio(false);
int n, m;
while (cin >> n >> m) {
ma.clear();
init(n + 1);
for (int i = 0; i <= n; i++) G[i].clear(), Gx[i].clear();
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
unite(x, y);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (find(i) == i) {
ma[i] = cnt;
G[cnt].push_back(i);
Gx[cnt++].push_back(p[i]);
}
}
for (int i = 1; i <= n; i++) {
if (find(i) == i) {
;
} else {
G[ma[find(i)]].push_back(i);
Gx[ma[find(i)]].push_back(p[i]);
}
}
for (int i = 0; i < cnt; i++) {
sort(G[i].begin(), G[i].end());
sort(Gx[i].begin(), Gx[i].end());
int l = G[i].size();
for (int j = 0; j < l; j++) {
ans[G[i][j]] = Gx[i][l - 1 - j];
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
void DFS(int u, vector<int> adj[], vector<bool> &vis) {
v.push_back(u);
vis[u] = true;
for (long long i = 0; i < adj[u].size(); i++)
if (!vis[adj[u][i]]) DFS(adj[u][i], adj, vis);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
int per[n + 1], ans[n + 1];
for (long long i = 1; i <= n; i++) cin >> per[i];
vector<int> adj[n + 1];
for (long long i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
};
vector<bool> vis(n + 1, false);
for (long long i = 1; i <= n; i++) {
if (vis[i] == false) {
DFS(i, adj, vis);
vector<int> temp;
for (long long j = 0; j < v.size(); j++) temp.push_back(per[v[j]]);
sort(temp.begin(), temp.end(), greater<int>());
sort(v.begin(), v.end());
for (long long j = 0; j < v.size(); j++) ans[v[j]] = temp[j];
v.clear();
}
}
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000001];
bool used[1000001] = {};
vector<int> p;
vector<int> pos, num;
void dfs(int v) {
used[v] = 1;
pos.push_back(v);
num.push_back(p[v]);
for (int e = 0; e < g[v].size(); ++e) {
if (!used[g[v][e]]) {
dfs(g[v][e]);
}
}
}
int main() {
int n, m;
int a, b;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
p.push_back(a);
}
for (int i = 0; i < m; ++i) {
scanf("%d %d", &a, &b);
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
pos.resize(0);
num.resize(0);
dfs(i);
sort(pos.begin(), pos.end());
sort(num.rbegin(), num.rend());
for (int j = 0; j < pos.size(); ++j) {
p[pos[j]] = num[j];
}
}
}
for (int i = 0; i < n; ++i) {
printf("%d ", p[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> pos, val, output(1000001, -1), input(1000001, 0),
visited(1000001, 0), g[1000001];
void dfs(int src) {
visited[src] = true;
pos.push_back(src);
val.push_back(input[src]);
for (auto i : g[src]) {
if (visited[i] == false) {
dfs(i);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> input[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
dfs(i);
sort(pos.begin(), pos.end());
sort(val.begin(), val.end(), greater<int>());
for (int i = 0; i < pos.size(); i++) {
output[pos[i]] = val[i];
}
pos.clear();
val.clear();
}
}
for (int i = 1; i <= n; i++) {
if (output[i] == -1) {
output[i] = input[i];
}
}
for (int i = 1; i <= n; i++) {
cout << output[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using v = vector<T>;
const long long inf = 4611686018427387903;
const long double EPS = 1e-10;
void read() {}
template <typename Arg, typename... Args>
void read(Arg& arg, Args&... args) {
cin >> (arg);
read(args...);
}
void print() {}
template <typename Arg, typename... Args>
void print(Arg arg, Args... args) {
cout << (arg) << " ";
print(args...);
}
int getInt() {
int a;
cin >> a;
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
string mirrored = "wioxvWTYUIOAHXVM";
const int N = 1000001;
int repr[N];
int siz[N];
vector<int> val[N];
int ffind(int a) { return (a == repr[a]) ? a : repr[a] = ffind(repr[a]); }
void unite(int a, int b) {
a = ffind(a);
b = ffind(b);
if (a == b) return;
if (siz[a] > siz[b]) swap(a, b);
repr[a] = b;
siz[b] += siz[a];
for (int i : val[a]) val[b].push_back(i);
}
void run() {
int n, m;
read(n, m);
int p[n];
for (int i = (0); i < (n); i++) {
repr[i] = i;
val[i].push_back(getInt());
siz[i] = 1;
}
for (int i = (0); i < (m); i++) {
int a, b;
read(a, b);
a--;
b--;
unite(a, b);
}
char is[n];
memset(is, 0, sizeof is);
for (int i = (0); i < (n); i++) {
int f = ffind(i);
if (is[f] == 0) {
sort(val[f].begin(), val[f].end());
is[f] = 1;
}
print(val[f].back());
val[f].pop_back();
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(12);
run();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
const long long int N = 10000000 + 6;
int ans[1000000 + 1];
vector<int> adj[1000000 + 1];
vector<int> vis(1000000 + 1);
int inde[1000000 + 10];
void dfs(int node, vector<int> &nums, vector<int> &in) {
vis[node] = 1;
for (int i : adj[node])
if (!vis[i]) dfs(i, nums, in);
nums.push_back(ans[node]);
in.push_back(node);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int v;
cin >> v;
inde[v] = i;
ans[i] = v;
}
while (m--) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vector<int> nums;
vector<int> in;
dfs(i, nums, in);
sort(nums.begin(), nums.end(), greater<int>());
sort(in.begin(), in.end());
for (int i = 0; i < nums.size(); i++) ans[in[i]] = nums[i];
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int n, k, ar[2000005];
vector<int> vec[2000005];
int w[2000005];
int get(int x) {
if (w[x] == x) return x;
return w[x] = get(w[x]);
}
void merge(int a, int b) {
a = get(a);
b = get(b);
w[a] = b;
}
int ans[2000005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
for (int i = 1; i <= n; i++) w[i] = i;
for (int i = 1; i <= k; i++) {
int a, b;
cin >> a >> b;
merge(a, b);
}
for (int i = 1; i <= n; i++) {
int id = get(i);
vec[id].push_back(ar[i]);
}
for (int i = 1; i <= n; i++) sort(vec[i].begin(), vec[i].end());
for (int i = 1; i <= n; i++) {
int id = get(i);
int val = vec[id].back();
vec[id].pop_back();
ans[i] = val;
}
for (int i = 1; i <= n; i++) {
if (i > 1) cout << " ";
cout << ans[i];
}
cout << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
inline int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
inline long long int bigmod(long long int a, long long int b, long long int m) {
if (b == 0) return 1 % m;
long long int x = bigmod(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) {
x = (x * a) % m;
}
return x;
}
inline long long int phi(long long int n) {
long long int ret = n;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
}
ret -= ret / i;
}
if (n > 1) {
ret -= ret / n;
}
return ret;
}
long long int missing_number(long long int A[], long long int n) {
long long int x1 = A[0], x2 = 1;
for (int i = 1; i < n; i++) x1 ^= A[i];
for (int i = 2; i <= n + 1; i++) x2 ^= i;
return (x1 ^ x2);
}
bool isFibo(long long int n) {
long long int A = (5 * n * n + 4);
long long int B = (5 * n * n - 4);
long long int C = sqrt(A);
long long int D = sqrt(B);
return (A == (C * C) || B == (D * D));
}
long long int classini(long long int n) { return (n & 1) ? -1 : 1; }
long long int factorial(int n) {
return (n == 1 || n == 0) ? 1 : factorial(n - 1) * n;
}
long long int catanal(long long int n) {
return (factorial(2 * n) / ((factorial(n + 1) * factorial(n))));
}
string orientation_3_ordered_point(vector<pair<int, int> > V) {
long long int value =
(V[1].second - V[0].second) * (V[2].first - V[1].first) -
(V[1].first * V[0].first) * (V[2].second - V[1].second);
string res;
if (value == 0) res = "colinear";
value == 1 ? res = "clockwise" : res = "counterclockwise";
return res;
}
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1};
string make_string(long long int num) {
stringstream ss;
ss << num;
string s;
ss >> s;
return s;
}
long long int make_num(string s) {
stringstream ss;
long long int tmp;
ss << s;
ss >> tmp;
return tmp;
}
int SET(int mask, int pos) { return (mask | (1 << pos)); }
int check(int mask, int pos) { return (mask & (1 << pos)); }
int Rank[1000011], parent[1000011];
void Build() {
for (int i = 1; i < 1000011; i++) {
parent[i] = i;
Rank[i] = 0;
}
}
int Find(int x) {
if (x == parent[x]) return x;
return parent[x] = Find(parent[x]);
}
void Union(int u, int v) {
int U = Find(u);
int V = Find(v);
if (U == V) return;
if (Rank[U] > Rank[V]) {
parent[V] = U;
} else
parent[U] = V;
if (Rank[U] == Rank[V]) Rank[V] += 1;
}
bool Same(int u, int v) { return Find(u) == Find(v); }
int N, M;
int Ans[1000011];
int Arr[1000011];
vector<int> Ele[1000011];
int main() {
Build();
scanf("%d", &N), scanf("%d", &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &Arr[i]);
}
while (M--) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
Union(u, v);
}
for (int i = 1; i <= N; i++) {
int root = Find(i);
Ele[root].push_back(Arr[i]);
}
for (int i = 1; i <= N; i++) {
sort(Ele[i].begin(), Ele[i].end());
}
for (int i = 1; i <= N; i++) {
int node = Find(i);
int num = Ele[node].back();
Ele[node].pop_back();
Ans[i] = num;
}
for (int i = 1; i <= N; i++) {
printf("%d ", Ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000010];
int vis[1000010];
int res[1000010];
vector<vector<int> > Graph(1000010);
vector<int> pos;
vector<int> val;
void DFS(int x) {
if (vis[x]) return;
val.push_back(a[x]);
pos.push_back(x);
vis[x] = 1;
for (int i = 0; i < Graph[x].size(); i++) {
if (!vis[Graph[x][i]]) {
DFS(Graph[x][i]);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
Graph[x].push_back(y);
Graph[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
pos.clear();
val.clear();
DFS(i);
sort(pos.begin(), pos.end());
sort(val.begin(), val.end());
reverse(val.begin(), val.end());
for (int i = 0; i < val.size(); i++) res[pos[i]] = val[i];
}
}
for (int i = 0; i < n; i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 23;
vector<long long> graf[N], comps[N], ids[N];
bool visited[N];
long long cnt = 0, a[N];
void dfs(long long x) {
visited[x] = 1;
comps[cnt].push_back(a[x]);
ids[cnt].push_back(x);
for (auto f : graf[x]) {
if (!visited[f]) {
dfs(f);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
graf[a].push_back(b);
graf[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
cnt++;
}
}
for (int i = 0; i < cnt; i++) {
sort(comps[i].begin(), comps[i].end());
sort(ids[i].begin(), ids[i].end());
for (long j = 0; j < ids[i].size(); j++) {
a[ids[i][j]] = comps[i][ids[i].size() - 1 - j];
}
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int P[1000001], S[1000001];
vector<int> G[1000001];
vector<int> Q[1000001];
void dfs(int v, int s) {
if (S[v] != -1) return;
S[v] = s;
Q[s].push_back(P[v]);
for (auto x : G[v]) dfs(x, s);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, a, b;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> P[i];
fill(S + 1, S + n + 1, -1);
for (int i = 0; i < m; ++i) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
int s = 0;
for (int i = 1; i <= n; ++i)
if (S[i] == -1) dfs(i, s++);
for (int i = 0; i < s; ++i) sort(Q[i].begin(), Q[i].end(), greater<int>());
fill(P, P + s, 0);
for (int i = 1; i <= n; ++i) cout << Q[S[i]][P[S[i]]++] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, nc = 0, a, b;
vector<vector<long long>> adj(1000005), comp1(1000005), comp2(1000005);
vector<long long> vis(1000005, 0), p(1000005);
void dfs(long long v) {
vis[v] = 1;
comp1[nc].push_back(v);
comp2[nc].push_back(p[v]);
for (long long j = 0; j < adj[v].size(); j++) {
if (!vis[adj[v][j]]) dfs(adj[v][j]);
}
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> p[i];
for (long long i = 1; i <= m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
nc++;
dfs(i);
}
}
for (long long i = 1; i <= nc; i++) {
sort(comp1[i].begin(), comp1[i].end());
sort(comp2[i].begin(), comp2[i].end());
for (long long it1 = 0, it2 = comp1[i].size() - 1; it1 < comp1[i].size();
it1++, it2--)
p[comp1[i][it1]] = comp2[i][it2];
}
for (long long i = 1; i <= n; i++) cout << p[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[1000000];
long long int per[1000000];
long long int vis[1000000];
vector<long long int> st;
vector<long long int> st2;
void dfs(long long int nd, long long int n) {
vis[nd] = 1;
st.push_back(nd);
st2.push_back(per[nd]);
for (int i = 0; i < adj[nd].size(); i++) {
if (!vis[adj[nd][i]]) dfs(adj[nd][i], n);
}
return;
}
int main() {
long long int m, n;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> per[i];
vis[i] = 0;
}
for (int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, n);
sort(st.begin(), st.end());
sort(st2.begin(), st2.end(), greater<long long int>());
for (int j = 0; j < st.size(); j++) per[st[j]] = st2[j];
while (!st.empty()) {
st.pop_back();
st2.pop_back();
}
}
}
for (int i = 0; i < n; i++) cout << per[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
vector<int> g[1000010], v1, v;
int a[1000010], ans[1000010], vis[1000010], pos[1000010];
void dfs(int z) {
vis[a[z - 1]] = 1;
v.push_back(a[z - 1]);
v1.push_back(z);
for (auto i : g[z]) {
if (!vis[a[i - 1]]) dfs(i);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i + 1;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i < n + 1; i++) {
if (!vis[a[i - 1]]) {
v.clear();
v1.clear();
dfs(i);
sort((v1).begin(), (v1).end());
sort(v.rbegin(), v.rend());
for (int j = 0; j < v.size(); j++) {
ans[v1[j]] = v[j];
}
}
}
for (int i = 1; i < n + 1; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
void quit();
using namespace std;
const long double PI = acos(-1);
const long double EPS = 1e-10;
double __t;
int n, m;
int p[1000010];
vector<int> g[1000010];
bool u[1000010];
int ans[1000010];
vector<int> pos;
vector<int> num;
void dfs(int v) {
u[v] = 1;
pos.push_back(v);
num.push_back(p[v]);
for (int first : g[v]) {
if (!u[first]) {
dfs(first);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
int a, b;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; ++i) {
if (!u[i]) {
pos.clear();
num.clear();
dfs(i);
sort(pos.begin(), pos.end());
sort(num.begin(), num.end(), greater<int>());
for (int j = 0; j < (int)pos.size(); ++j) {
ans[pos[j]] = num[j];
}
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << ' ';
}
quit();
}
void quit() { exit(0); }
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long minf = -(1e18);
bool visi[1000001];
vector<int> adj[1000001];
long long arr[1000001];
vector<int> pos;
vector<int> elements;
void dfs(int i) {
if (visi[i])
return;
else {
pos.push_back(i);
elements.push_back(arr[i]);
visi[i] = true;
for (auto j : adj[i])
if (!visi[j]) {
dfs(j);
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long n, m;
cin >> n >> m;
fill_n(visi, 1000001, false);
long long x, y;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visi[i]) {
dfs(i);
sort(pos.begin(), pos.end());
sort(elements.begin(), elements.end(), std::greater<int>());
for (int j = 0; j < pos.size(); j++) {
arr[pos[j]] = elements[j];
}
pos.clear();
elements.clear();
}
}
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
using mt = int32_t;
using fl = double;
template <typename T>
constexpr mt infValue = std::numeric_limits<T>::max() - 1000;
template <typename T>
constexpr mt maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
constexpr mt INF = infValue<mt>;
constexpr int64_t MOD = 998244353ll;
constexpr double EPS = 1e-6;
constexpr mt MAX = maxValue<mt>;
using pr = pair<mt, mt>;
constexpr auto N = 1000001;
constexpr auto K = 256;
constexpr auto P = 19;
constexpr auto M = 200111;
mt n, m;
mt p[N];
mt pvr[N], s[N];
void make_set(mt i) {
pvr[i] = i;
s[i] = i;
}
mt find_set(mt v) {
if (pvr[v] == v) return v;
return pvr[v] = find_set(pvr[v]);
}
void merge_set(mt u, mt v) {
u = find_set(u);
v = find_set(v);
if (u != v) {
if (s[u] < s[v]) swap(u, v);
pvr[v] = u;
s[u] += s[v];
}
}
vector<mt> v[N];
int main(void) {
scanf("%d %d", &n, &m);
for (mt i = 1; i <= (n); ++i) scanf("%d", p + i), make_set(i);
while (m--) {
mt a, b;
scanf("%d %d", &a, &b);
merge_set(p[a], p[b]);
}
for (mt i = 1; i <= (n); ++i) v[find_set(i)].push_back(i);
for (mt i = 1; i <= (n); ++i) sort(v[i].begin(), v[i].end());
for (mt i = 1; i <= (n); ++i) {
mt pv = find_set(p[i]);
printf("%d ", v[pv].back());
v[pv].pop_back();
}
putc('\n', stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powermod(long long a, long long b, long long c) {
long long ans = 1, tempans = a % c;
while (b > 0) {
if ((b & 1) == 1) {
ans = (ans * tempans) % c;
}
tempans = (tempans * tempans) % c;
b = b >> 1;
}
return ans;
}
long long modinverse(long long a, long long m) { return powermod(a, m - 2, m); }
long long add(long long x, long long y) {
x += y;
if (x >= 1000000007) return x - 1000000007;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + 1000000007;
return x;
}
long long mult(long long x, long long y) { return (x * y) % 1000000007; }
long long n, k;
set<long long, greater<long long>> s[1000005];
long long vis[1000006];
long long a[1000006];
vector<long long> edges[1000006];
void dfs(long long st, long long rakh) {
vis[st] = rakh;
s[rakh].insert(a[st]);
for (long long ch : edges[st]) {
if (!vis[ch]) {
dfs(ch, rakh);
}
}
}
void solve() {
long long k;
cin >> n >> k;
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
}
while (k--) {
long long x, y;
cin >> x >> y;
edges[x].push_back(y);
edges[y].push_back(x);
}
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, i);
long long x = *s[i].begin();
s[i].erase(s[i].begin());
a[i] = x;
} else {
long long p = vis[i];
long long x = *s[p].begin();
s[p].erase(s[p].begin());
a[i] = x;
}
}
for (long long i = 1; i <= n; i++) {
cout << a[i] << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
long long count = 0;
while (t--) {
count++;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int mod = 1000000007;
const double pi = acos(-1);
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
const int maxn = 1e6 + 100;
vector<int> v[maxn];
int f[maxn];
int ite[maxn] = {0};
int find(int x) {
if (x == f[x]) return x;
return find(f[x]);
}
void add(int a, int b) {
a = find(a);
b = find(b);
f[a] = b;
}
bool cmp(int &a, int &b) { return b < a; }
int numb[maxn];
int main() {
int n, m;
gn(n);
gn(m);
for (int i = (1); i <= (n); i++) gn(numb[i]), f[i] = i;
int a, b;
for (int i = (1); i <= (m); i++) {
gn(a);
gn(b);
add(a, b);
}
for (int i = (1); i <= (n); i++) v[find(f[i])].push_back(numb[i]);
for (int i = (1); i <= (n); i++) sort(v[i].begin(), v[i].end(), cmp);
for (int i = (1); i <= (n); i++) {
int f = find(i);
printf("%d ", v[f][ite[f]++]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1111111];
vector<int> g[1111111];
int c[1111111];
vector<int> nums[1111111];
vector<int> ids[1111111];
void dfs(int v, int cc) {
c[v] = cc;
for (int i : g[v]) {
if (c[i] == -1) {
dfs(i, cc);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
memset(c, -1, sizeof(c));
int cc = 0;
for (int i = 0; i < n; i++) {
if (c[i] == -1) {
dfs(i, cc++);
}
}
for (int i = 0; i < n; i++) {
nums[c[i]].push_back(a[i]);
ids[c[i]].push_back(i);
}
for (int i = 0; i < cc; i++) {
sort(nums[i].rbegin(), nums[i].rend());
for (int j = 0; j < nums[i].size(); j++) {
a[ids[i][j]] = nums[i][j];
}
}
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int mod = 1000000007;
const double pi = acos(-1);
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
int n, m;
const int maxn = 1e6 + 100;
int f[maxn];
int numb[maxn];
priority_queue<int> q[maxn];
int findf(int x) { return x == f[x] ? x : f[x] = findf(f[x]); }
void merge(int a, int b) {
a = findf(a);
b = findf(b);
if (a != b) f[a] = b;
}
int main() {
gn(n);
gn(m);
for (int i = (1); i <= (n); i++) {
gn(numb[i]);
f[i] = i;
}
int a, b;
for (int i = (1); i <= (m); i++) {
gn(a);
gn(b);
merge(a, b);
}
for (int i = (1); i <= (n); i++) q[findf(i)].push(numb[i]);
for (int i = (1); i <= (n); i++) {
printf("%d ", q[findf(i)].top());
q[findf(i)].pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s[1000005];
int v[1000005] = {0};
int ci[1000005] = {0};
int f(int x) { return ci[x] == x ? x : ci[x] = f(ci[x]); }
int main() {
int n, m;
cin >> n >> m;
int group = 1, tg = 0;
int i;
for (i = 1; i <= n; i++) cin >> v[i];
for (i = 1; i <= n; i++) ci[i] = i;
for (i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
int ta = f(a), tb = f(b);
if (ta != tb) ci[ta] = tb;
}
for (i = 1; i <= n; i++) {
s[f(i)].insert(v[i]);
}
for (i = 1; i <= n; i++) {
if (i != 1) putchar(' ');
int te = ci[i];
cout << *(--s[te].end());
s[te].erase(--s[te].end());
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
bool visited[N];
vector<vector<int>> adj;
class ProblemDSwapsInPermutation {
public:
int n, m;
vector<int> arr, num;
set<int> pos, s;
void dfs(int u) {
if (visited[u]) return;
visited[u] = true;
s.insert(arr[u]);
pos.insert(u);
for (int v : adj[u]) dfs(v);
}
void solve(std::istream& in, std::ostream& out) {
in >> n >> m;
arr.resize(n + 1);
adj = vector<vector<int>>(n + 1);
for (int i = 1; i <= n; ++i) in >> arr[i];
for (int i = 0; i < m; ++i) {
int u, v;
in >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(visited, false, sizeof(visited));
for (int i = 1; i <= n; ++i) {
if (!visited[i]) {
pos.clear();
s.clear();
num.clear();
dfs(i);
for (int x : s) num.push_back(x);
for (int x : pos) arr[x] = num.back(), num.pop_back();
}
}
for (int i = 1; i <= n; ++i) out << arr[i] << ' ';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ProblemDSwapsInPermutation solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct permuutation {
int a;
int id;
};
struct permuutation a[1000040];
int fa[1000040];
int temp[1000040];
int ID[1000040];
int aws[1000040];
int a1[1000040];
vector<permuutation> v[1000040];
bool cnp(struct permuutation A, struct permuutation B) { return A.a < B.a; }
int finds(int x) {
if (fa[x] != x) fa[x] = finds(fa[x]);
return fa[x];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i(1); i <= n; i++) {
scanf("%d", &a[i].a);
a[i].id = i;
fa[i] = i;
}
for (int i(1); i <= m; i++) {
int p, q;
scanf("%d%d", &p, &q);
p = finds(p);
q = finds(q);
if (p != q) fa[p] = q;
}
int cnt = 0;
for (int i(1); i <= n; i++) {
int x = finds(i);
if (x == i) temp[++cnt] = x;
v[x].push_back(a[i]);
}
for (int i1(1); i1 <= cnt; i1++) {
int i = temp[i1];
int su = v[i].size();
for (int j(0); j < su; j++) {
ID[j] = v[i][j].id;
a1[j] = v[i][j].a;
}
sort(a1, a1 + su);
sort(ID, ID + su);
for (int j(0); j < su; j++) aws[ID[j]] = a1[su - 1 - j];
}
for (int i(1); i <= n; i++) printf("%d ", aws[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[100005];
int a[1000005], vis[1000005], cnt;
vector<int> g[1000005], comp[1000005], vals[1000005];
void dfs(int node, int n) {
int i, j, k, m, ans, val;
vis[node] = 1;
comp[cnt].push_back(node);
vals[cnt].push_back(a[node]);
j = g[node].size();
for (i = 0; i < j; i++) {
if (!vis[g[node][i]]) {
dfs(g[node][i], n);
}
}
}
void dfs_getConnectedComponts(int n) {
int i, j, k, m, ans, val, ii;
cnt = 0;
for (i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, n);
sort(comp[cnt].begin(), comp[cnt].end());
sort(vals[cnt].begin(), vals[cnt].end(), std::greater<int>());
cnt++;
}
}
}
int main() {
int i, j, k, m, n, ans, val, t;
t = 1;
while (t--) {
cin >> (n);
cin >> (m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
g[i].clear();
comp[i].clear();
vals[i].clear();
vis[i] = 0;
}
for (i = 0; i < m; i++) {
scanf("%d %d", &j, &k);
j--;
k--;
g[j].push_back(k);
g[k].push_back(j);
}
dfs_getConnectedComponts(n);
for (i = 0; i < cnt; i++) {
k = comp[i].size();
for (j = 0; j < k; j++) a[comp[i][j]] = vals[i][j];
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph(1000100);
vector<int> values;
vector<int> indices;
bool visited[1000100];
int out[1000100];
void dfs(int c) {
visited[c] = true;
indices.push_back(c);
values.push_back(out[c]);
for (int i = 0; i < graph[c].size(); i++) {
if (!visited[graph[c][i]]) dfs(graph[c][i]);
}
}
int main() {
int n, m, x, y, s, e;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &out[i]);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) dfs(i);
sort(indices.begin(), indices.end());
sort(values.begin(), values.end());
reverse(values.begin(), values.end());
for (int j = 0; j < values.size(); j++) out[indices[j]] = values[j];
values.clear();
indices.clear();
}
for (int i = 1; i <= n; i++) printf("%d ", out[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<int> adj[maxn];
int a[maxn];
vector<int> comp;
bool mark[maxn];
void dfs(int v) {
if (mark[v]) return;
mark[v] = 1;
comp.push_back(v);
for (int u : adj[v]) dfs(u);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<vector<int> > vs;
for (int i = 0; i < n; i++) {
comp.clear();
dfs(i);
if (comp.size()) vs.push_back(comp);
}
for (auto v : vs) {
vector<int> th;
for (auto i : v) th.push_back(a[i]);
sort(th.begin(), th.end());
vector<int> vv = v;
sort(vv.begin(), vv.end());
for (int i = 0; i < vv.size(); i++) a[vv[i]] = th.back(), th.pop_back();
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int id[1000005];
int root(int x) {
while (x != id[x]) x = id[x];
return x;
}
void join(int a, int b) {
int ra = root(a), rb = root(b);
id[ra] = rb;
}
vector<int> v[1000005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) id[i] = i;
int a[n + 1];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int p, q;
for (int i = 0; i < m; i++) {
scanf("%d%d", &p, &q);
p--;
q--;
if (root(p) != root(q)) join(p, q);
}
for (int i = 0; i < n; i++) {
v[root(i)].push_back(i);
}
for (int i = 0; i < n; i++) {
vector<int> vt;
for (int j = 0; j < v[i].size(); j++) {
vt.push_back(a[v[i][j]]);
}
sort(vt.rbegin(), vt.rend());
sort(v[i].begin(), v[i].end());
for (int j = 0; j < v[i].size(); j++) {
a[v[i][j]] = vt[j];
}
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
vector<long long int> vv;
vector<long long int> vv2;
long long int n, m;
long long int a[1200000];
long long int was[1200000];
vector<long long int> eds[1200000];
void dfs(long long int v) {
vv.push_back(v);
vv2.push_back(a[v]);
was[v] = 1;
for (int u : eds[v])
if (!was[u]) dfs(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
}
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
eds[x].push_back(y);
eds[y].push_back(x);
}
for (int i = 0; i < n; ++i) {
if (!was[i]) {
vv.clear();
vv2.clear();
dfs(i);
sort(vv.begin(), vv.end());
sort(vv2.rbegin(), vv2.rend());
for (int i = 0; i < (int)vv.size(); ++i) a[vv[i]] = vv2[i];
}
}
for (int i = 0; i < n; ++i) cout << a[i] + 1 << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, arr[1000005], sz[1000005], fav[1000005], ans[1000005];
priority_queue<int> v[1000005];
void initi() {
for (int i = 1; i <= n; i++) {
arr[i] = i;
sz[i] = 1;
}
}
int root(int a) {
int x = arr[a];
while (x != arr[x]) {
x = arr[x];
}
return x;
}
void merge(int a, int b) {
int x = root(a);
int y = root(b);
if (sz[y] > sz[x]) swap(x, y);
arr[y] = x;
sz[x] += sz[y];
sz[y] = 0;
}
bool find(int a, int b) {
if (root(a) == root(b))
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, k, m, x, y;
cin >> n >> m;
initi();
for (i = 1; i <= n; i++) {
cin >> ans[i];
}
for (i = 1; i <= m; i++) {
cin >> x >> y;
if (!(find(x, y))) {
merge(x, y);
}
}
for (i = 1; i <= n; i++) {
x = root(i);
v[x].push(ans[i]);
}
for (i = 1; i <= n; i++) {
x = root(i);
y = root(x);
j = v[y].top();
fav[i] = j;
v[y].pop();
cout << j << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> temp, idx;
vector<int> graph[1000005];
bool visit[1000005];
int res[1000005], per[1000005];
void dfs(int node) {
visit[node] = true;
temp.push_back(per[node]);
idx.push_back(node);
for (int i = 0; i < graph[node].size(); i++) {
int v = graph[node][i];
if (!visit[v]) {
dfs(v);
}
}
}
int main() {
memset(visit, false, sizeof visit);
int from, to, x;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &per[i]);
res[i] = per[i];
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &from, &to);
graph[to].push_back(from);
graph[from].push_back(to);
}
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
temp.clear();
idx.clear();
dfs(i);
sort(temp.begin(), temp.end());
sort(idx.begin(), idx.end());
for (int j = 0; j < temp.size(); j++) {
res[idx[j]] = temp[temp.size() - j - 1];
}
}
}
cout << res[1];
for (int i = 2; i <= n; i++) {
printf(" %d", res[i]);
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 7;
vector<vector<int>> node;
vector<vector<int>> pos;
int point[maxN];
int n, m, cnt = 0;
int par[maxN], a[maxN];
int root(int p) {
if (par[p] == p)
return p;
else
return (par[p] = root(par[p]));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("test.inp", "r")) freopen("test.inp", "r", stdin);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
par[i] = i;
}
while (m--) {
int x, y;
cin >> x >> y;
int X = root(x);
int Y = root(y);
if (X != Y) {
par[X] = Y;
}
}
memset(point, -1, sizeof point);
for (int i = 1; i <= n; i++) {
if (point[root(i)] == -1) {
point[root(i)] = cnt++;
node.push_back({a[i]});
pos.push_back({i});
} else {
node[point[root(i)]].push_back(a[i]);
pos[point[root(i)]].push_back(i);
}
}
for (int i = 0; i < node.size(); i++) {
sort(node[i].begin(), node[i].end(), greater<int>());
}
for (int i = 0; i < node.size(); i++) {
for (int j = 0; j < node[i].size(); j++) {
a[pos[i][j]] = node[i][j];
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
priority_queue<int> Q[maxn];
int num[maxn];
int fa[maxn];
inline int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", num + i);
fa[i] = i;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
fa[Find(u)] = Find(v);
}
for (int i = 1; i <= n; i++) {
Find(i);
Q[fa[i]].push(num[i]);
}
for (int i = 1; i <= n; i++) {
printf("%d ", Q[fa[i]].top());
Q[fa[i]].pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int mod = 1000000007;
const double pi = acos(-1);
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
const int maxn = 1e6 + 100;
vector<int> v[maxn];
int f[maxn];
int ite[maxn] = {0};
int find(int x) {
if (x == f[x]) return x;
return find(f[x]);
}
void add(int a, int b) {
a = find(a);
b = find(b);
f[a] = b;
}
int numb[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = (1); i <= (n); i++) gn(numb[i]), f[i] = i;
int a, b;
for (int i = (1); i <= (m); i++) {
cin >> a >> b;
add(a, b);
}
for (int i = (1); i <= (n); i++) v[find(f[i])].push_back(-numb[i]);
for (int i = (1); i <= (n); i++) sort(v[i].begin(), v[i].end());
for (int i = (1); i <= (n); i++) {
int f = find(i);
printf("%d ", -v[f][ite[f]++]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a, b;
int arr[1000005];
vector<int> g[1000005];
vector<int> vec[1000005];
int cno[1000005];
int vis[1000005];
void dfs(int cur, int cn) {
vis[cur] = 1;
vec[cn].push_back(arr[cur]);
cno[cur] = cn;
for (auto i : g[cur]) {
if (!vis[i]) {
dfs(i, cn);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> arr[i];
for (int i = 0; i < m; ++i)
cin >> a >> b, a--, b--, g[a].push_back(b), g[b].push_back(a);
int cn = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
dfs(i, cn);
sort(vec[cn].begin(), vec[cn].end());
cn++;
}
}
for (int i = 0; i < n; ++i) {
int cm = cno[i];
cout << vec[cm][vec[cm].size() - 1] << " ";
vec[cm].pop_back();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int> > g(1000001);
vector<long long int> vis(1000001);
vector<long long int> topo;
void dfs(long long int node) {
vis[node] = 1;
for (long long int i = 0; i < g[node].size(); i++) {
if (!vis[g[node][i]]) dfs(g[node][i]);
}
topo.push_back(node);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
long long int m;
cin >> n >> m;
vector<long long int> p(n + 1, 0);
for (long long int i = 0; i < n; i++) cin >> p[i + 1];
vector<pair<long long int, long long int> > a(m);
for (long long int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second;
g[a[i].first].push_back(a[i].second);
g[a[i].second].push_back(a[i].first);
}
vector<long long int> ans(n + 1, -1);
for (long long int i = 0; i < n; i++) {
long long int node = i + 1;
if (!vis[node]) {
dfs(node);
sort(topo.begin(), topo.end());
vector<long long int> nn;
for (long long int j = 0; j < topo.size(); j++) {
nn.push_back(p[topo[j]]);
}
sort(nn.rbegin(), nn.rend());
for (long long int j = 0; j < topo.size(); j++) {
ans[topo[j]] = nn[j];
}
topo.clear();
}
}
for (long long int i = 0; i < n; i++) {
cout << ans[i + 1] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, vis[1000010];
vector<int> g[1000010], v, pos;
int ans[1000010], a[1000010];
void dfs(int x) {
vis[x] = 1;
pos.push_back(x);
for (auto &it : g[x]) {
if (!vis[it]) dfs(it);
}
}
int32_t main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
pos.clear();
v.clear();
dfs(i);
for (auto &it : pos) {
v.push_back(a[it]);
}
sort(pos.begin(), pos.end());
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < (v).size(); ++i) {
ans[pos[i]] = v[i];
}
}
}
for (int i = 1; i <= n; ++i) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
size_t p_len;
unsigned int p[1000000];
size_t union_data[1000000];
void reset_union_data() {
for (size_t i = 0; i < 1000000; ++i) union_data[i] = i;
}
size_t union_root(size_t i) {
static size_t *buf = (size_t *)malloc(sizeof(size_t) * 1000000);
size_t r, len = 0;
loop:
r = union_data[i];
if (r == i) {
for (i = 0; i < len; ++i) union_data[buf[i]] = r;
return r;
}
buf[len++] = i;
i = r;
goto loop;
}
void union_merge(size_t a, size_t b) {
union_data[union_root(a)] = union_root(b);
}
int main(void) {
unsigned int m, plen;
scanf(" %u %u", &plen, &m);
p_len = plen;
for (size_t i = 0; i < p_len; ++i) {
scanf(" %u", p + i);
}
reset_union_data();
for (unsigned int i = 0; i < m; ++i) {
unsigned int a, b;
scanf(" %u %u", &a, &b);
union_merge(a - 1, b - 1);
}
vector<size_t> roots;
size_t *root_mapping = (size_t *)malloc(sizeof(size_t) * 1000000),
root_count = 0;
for (size_t i = 0; i < 1000000; ++i) {
root_mapping[i] = 1000001;
}
vector<vector<size_t> > subsets;
for (size_t i = 0; i < p_len; ++i) {
size_t r = union_root(i);
if (root_mapping[r] == 1000001) {
roots.push_back(r);
root_mapping[r] = root_count++;
subsets.resize(root_mapping[r] + 1);
}
subsets[root_mapping[r]].push_back(p[i]);
}
for (size_t i = 0; i < root_count; ++i) {
sort(subsets[i].begin(), subsets[i].end());
}
for (size_t i = 0; i < p_len; ++i) {
size_t r = union_root(i);
p[i] = subsets[root_mapping[r]].back();
subsets[root_mapping[r]].pop_back();
}
char lastchar[2];
lastchar[0] = ' ';
lastchar[1] = '\n';
for (size_t i = 0; i < p_len; ++i) {
printf("%d%c", p[i], (int)*(lastchar + (i == p_len - 1)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 100;
int a[maxN];
vector<int> g[maxN], pos, values;
int n, m;
bool mark[maxN];
void input() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d ", &a[i]);
for (int i = 1; i <= m; i++) {
int k1, k2;
scanf("%d %d", &k1, &k2);
g[k1].push_back(k2);
g[k2].push_back(k1);
}
}
void dfs(int v) {
mark[v] = true;
pos.push_back(v);
values.push_back(a[v]);
for (int i = 0; i < g[v].size(); i++)
if (!mark[g[v][i]]) dfs(g[v][i]);
}
void alg() {
for (int i = 0; i < pos.size(); i++) a[pos[i]] = values[i];
}
int main() {
input();
for (int i = 1; i <= n; i++)
if (!mark[i]) {
dfs(i);
sort(values.begin(), values.end());
sort(pos.begin(), pos.end());
reverse(values.begin(), values.end());
alg();
values.clear();
pos.clear();
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt[2000010], to[2000010], fr[2000010], cnt = 0;
int n, m, vis[1000010], a[1000010], b[1000010], num = 0;
vector<int> v[1000010], pos[1000010];
void add(int x, int y) {
to[++cnt] = y;
nxt[cnt] = fr[x];
fr[x] = cnt;
}
void dfs(int x, int num) {
vis[x] = num;
v[num].push_back(a[x]);
pos[num].push_back(x);
for (int i = fr[x]; i; i = nxt[i]) {
int y = to[i];
if (vis[y]) continue;
dfs(y, num);
}
}
bool cmp(int x, int y) { return x > y; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
num++;
dfs(i, num);
sort(v[num].begin(), v[num].end(), cmp);
sort(pos[num].begin(), pos[num].end());
for (int i = 0; i < pos[num].size(); i++) b[pos[num][i]] = v[num][i];
}
for (int i = 1; i <= n; i++) printf("%d ", b[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> p, rank, setSize;
int numSets;
UnionFind(int n) {
numSets = n;
setSize.assign(n, 1);
rank.assign(n, 0);
p.resize(n);
for (int i = 0; i < (int)n; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (isSameSet(i, j)) return;
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
int n, m, x, y;
vector<int> p;
int main() {
cin >> n >> m;
p.resize(n);
for (int i = 0; i < (int)n; i++) cin >> p[i];
UnionFind uf(n);
for (int i = 0; i < (int)m; i++) {
cin >> x >> y;
uf.unionSet(x - 1, y - 1);
}
set<int> parents;
vector<priority_queue<int>> aux(n);
for (int i = 0; i < (int)n; i++) {
parents.insert(uf.findSet(i));
aux[uf.findSet(i)].push(p[i]);
}
for (int i = 0; i < (int)n; i++) {
p[i] = aux[uf.findSet(i)].top();
aux[uf.findSet(i)].pop();
}
for (int i = 0; i < (int)n; i++) cout << p[i] << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int sz, n, m, ans[1000010], a[1000010], idx[1000010], v[1000010], id[1000010];
vector<int> adj[1000010];
bool vis[1000010];
bool com(int a, int b) { return a > b; }
void dfs(int i) {
if (vis[i]) return;
vis[i] = 1;
v[sz] = a[i];
id[sz++] = i;
for (int j = 0; j < adj[i].size(); j++) dfs(adj[i][j]);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
idx[a[i]] = i;
}
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
sz = 1;
dfs(i);
sort(v + 1, v + sz, com);
sort(id + 1, id + sz);
for (int j = 1; j < sz; j++) ans[id[j]] = v[j];
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
return countbit(int(x & INT_MAX)) + countbit(int(x >> 32) & INT_MAX);
}
inline void printbit(int x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st = v;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const deque<A> &v) {
deque<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop_front();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
run();
return 0;
}
const int mod = 1e9 + 7;
const int N = 1003;
struct Edge {
int a, b;
long long cost;
Edge(int _a = 0, int _b = 0, long long _cost = 0)
: a(_a), b(_b), cost(_cost) {}
int to(int from) { return from == a ? b : a; }
};
vector<int> g[N];
vector<Edge> e;
vector<long long> d(N, LLONG_MAX);
vector<int> p(N, -1);
vector<bool> u(N * 100, false);
long long dejkstra(int s, int t, bool f = false) {
std::fill(d.begin(), d.end(), LLONG_MAX);
set<pair<long long, int> > st;
d[s] = 0;
st.insert({0, s});
while (!st.empty()) {
int v = (*st.begin()).second;
st.erase(st.begin());
for (int i = 0; i < ((int)g[v].size()); ++i) {
auto edg = e[g[v][i]];
if (edg.cost == 0 && f) continue;
long long cost = max(1ll, edg.cost);
if (d[edg.to(v)] > d[v] + cost) {
st.erase({d[edg.to(v)], edg.to(v)});
d[edg.to(v)] = d[v] + cost;
p[edg.to(v)] = g[v][i];
st.insert({d[edg.to(v)], edg.to(v)});
}
}
}
0 ? (cout << "d[t]"
<< " = " << (d[t]) << "\n")
: cout;
return d[t];
}
void run() {
int n, m, L, s, t;
scanf("%d%d", &n, &m);
scanf("%d%d%d", &L, &s, &t);
int a, b, c;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(((int)e.size()));
g[b].push_back(((int)e.size()));
e.push_back(Edge(a, b, c));
}
if (dejkstra(s, t, true) < L) {
printf("NO\n");
return;
}
while (dejkstra(s, t) <= L) {
int v = t;
vector<int> vct;
while (v != s) {
int id = p[v];
if (e[id].cost == 0) {
vct.push_back(id);
u[id] = 1;
}
v = e[id].to(v);
}
if (vct.empty()) break;
int need = L - d[t];
e[vct.back()].cost = 1 + need;
}
if (dejkstra(s, t) != L) {
printf("NO\n");
return;
}
for (int i = 0; i < m; ++i)
if (e[i].cost == 0) e[i].cost = u[i] ? 1ll : 1ll << 50;
printf("YES\n");
for (int i = 0; i < m; ++i) printf("%d %d %lld\n", e[i].a, e[i].b, e[i].cost);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long toit, next, from;
long long cap;
} road[200010];
long long q[3000010], n, m, s, t, cnt = 1;
long long l;
long long dis1[20010], dis2[20010];
long long listt[20010], vis[20010], in[20010];
inline void add(long long u, long long v, long long w) {
road[++cnt].toit = v;
road[cnt].next = listt[u];
listt[u] = cnt;
road[cnt].cap = w;
road[cnt].from = u;
}
inline void spfa(int s) {
dis1[s] = 0;
long long head = 0, tail = 1;
q[tail] = s;
in[s] = 1;
while (head < tail) {
int u = q[++head];
for (int w = listt[u]; w > 0; w = road[w].next) {
int v = road[w].toit;
if (dis1[v] <= dis1[u] + road[w].cap) continue;
dis1[v] = dis1[u] + road[w].cap;
if (in[v]) continue;
in[v] = 1;
q[++tail] = v;
}
in[u] = 0;
}
}
inline void SPFA(long long s) {
dis2[s] = 0;
long long head = 0, tail = 1;
q[tail] = s;
in[s] = 1;
while (head < tail) {
int u = q[++head];
for (int w = listt[u]; w > 0; w = road[w].next) {
int v = road[w].toit;
if (vis[w])
road[w xor 1].cap = road[w].cap =
max(road[w].cap, l - dis1[v] - dis2[u]);
if (dis2[v] <= dis2[u] + road[w].cap) continue;
dis2[v] = dis2[u] + road[w].cap;
if (in[v] == 1) continue;
in[v] = 1;
q[++tail] = v;
}
in[u] = 0;
}
}
int main() {
scanf("%lld%lld%lld%lld%lld", &n, &m, &l, &s, &t);
for (long long i = 0; i <= n; i++) vis[i] = 0;
for (long long i = 0; i <= n; i++) dis1[i] = 1e15;
for (long long i = 0; i <= n; i++) dis2[i] = 1e15;
long long a, b, c;
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld%lld", &a, &b, &c);
if (c == 0) vis[cnt + 1] = 1, vis[cnt + 2] = 1, c = 1;
add(a, b, c);
add(b, a, c);
}
for (long long i = 0; i <= n; i++) in[i] = 0;
spfa(t);
for (long long i = 0; i <= n; i++) in[i] = 0;
SPFA(s);
if (dis2[t] != l) {
printf("NO");
return 0;
}
printf("YES\n");
for (int i = 2; i <= m * 2; i++)
if (!(i & 1))
printf("%lld %lld %lld\n", road[i].from, road[i].toit, road[i].cap);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x;
scanf("%I64d", &x);
return x;
}
int getrand() {
srand(time(0));
int x = rand();
while (x-- > 0) {
rand();
}
return rand() % 732 + 1;
}
const int N = 12345;
vector<int> v[N];
int x[N], y[N], z[N];
int d[N];
bool used[N], use[N];
int p[N];
int main() {
int n, m, i, j, s, t, l;
cin >> n >> m >> l >> s >> t;
for (i = 1; i <= m; i++) {
cin >> x[i] >> y[i] >> z[i];
v[x[i]].push_back(i);
v[y[i]].push_back(i);
if (z[i])
used[i] = 1;
else
z[i] = 1;
}
while (1) {
for (i = 0; i < n; i++) d[i] = 1e9 + 7, use[i] = 0;
priority_queue<pair<int, int> > q;
q.push(make_pair(0, s));
d[s] = 0;
while (!q.empty()) {
int xx = q.top().second;
q.pop();
if (use[xx]) continue;
use[xx] = 1;
for (int i = 0; i < v[xx].size(); i++) {
int to = v[xx][i];
int yy = x[to];
if (yy == xx) yy = y[to];
int zz = z[to];
if (d[yy] > d[xx] + zz) {
d[yy] = d[xx] + zz;
q.push(make_pair(-d[yy], yy));
p[yy] = to;
}
}
}
if (d[t] > l) {
puts("NO");
return 0;
}
if (d[t] == l) break;
int id = -1;
int r = t;
while (r != s) {
int ind = p[r];
if (!used[ind]) {
id = ind;
break;
}
if (x[ind] == r)
r = y[ind];
else
r = x[ind];
}
if (id == -1) {
puts("NO");
return 0;
}
z[id] += l - d[t];
}
puts("YES");
for (i = 1; i <= m; i++) {
cout << x[i] << " " << y[i] << " " << z[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const double pi = acos(-1.0);
const long long Mod = 1000000007;
const int N = 1e3 + 5;
int ks = 0;
int n, m, s, t;
long long dis[N], cost[N * 10], L;
int used[N], deleted[N * 10];
pair<int, int> parent[N];
vector<pair<int, int> > g[N];
struct edge {
int x, y;
long long z;
bool operator<(const edge &f) const { return z > f.z; }
} E[N * 10];
void SPFA() {
for (int i = 0; i < n; i++) {
dis[i] = LLONG_MAX;
used[i] = 0;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.emplace(0, s);
dis[s] = 0;
while (q.size()) {
int from = q.top().second;
used[from] = 1;
q.pop();
for (auto i : g[from]) {
int to = i.first;
int id = i.second;
if (dis[from] + cost[id] < dis[to]) {
dis[to] = dis[from] + cost[id];
parent[to] = {from, id};
if (!used[to]) q.emplace(dis[to], to);
}
}
}
}
int main() {
scanf("%d%d%I64d%d%d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
scanf("%d%d%I64d", &E[i].x, &E[i].y, &E[i].z);
}
sort(E, E + m);
int last = 0;
for (int i = 0; i < m && E[i].z; i++, last++) {
cost[i] = E[i].z;
g[E[i].x].emplace_back(E[i].y, i);
g[E[i].y].emplace_back(E[i].x, i);
}
SPFA();
if (dis[t] < L) {
puts("NO");
return 0;
}
for (int i = last; i < m; i++) {
deleted[i] = cost[i] = 1;
g[E[i].x].emplace_back(E[i].y, i);
g[E[i].y].emplace_back(E[i].x, i);
}
SPFA();
if (dis[t] > L) {
puts("NO");
return 0;
}
puts("YES");
while (dis[t] < L) {
int cur = t;
while (cur != s) {
int id = parent[cur].second;
cur = parent[cur].first;
if (deleted[id]) {
cost[id] += L - dis[t];
break;
}
}
SPFA();
}
bool done[N];
memset(done, false, sizeof done);
for (int i = 0; i < n; i++) {
for (auto j : g[i]) {
if (done[j.first]) continue;
cout << i << ' ' << j.first << ' ' << cost[j.second] << '\n';
}
done[i] = true;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = 1010;
const int INF = (int)1e9 + 10;
int n, m, l, s, t, d[N], dis[N][N];
vector<int> child[N];
vector<pair<pair<int, int>, int>> ed;
vector<int> zle;
void dijkstra(bool flag) {
for (int i = 0; i < n; ++i) d[i] = INF;
d[s] = 0;
set<pair<int, int>> se;
se.insert({d[s], s});
while (!se.empty()) {
auto it = *se.begin();
se.erase(se.begin());
for (auto dz : child[it.second]) {
if (flag && dis[it.second][dz] == 0) continue;
if (d[dz] > it.first + dis[it.second][dz]) {
se.erase({d[dz], dz});
d[dz] = it.first + dis[it.second][dz];
se.insert({d[dz], dz});
}
}
}
}
int main() {
init_ios();
cin >> n >> m >> l >> s >> t;
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
dis[x][y] = dis[y][x] = z;
ed.push_back({{x, y}, z});
child[x].push_back(y);
child[y].push_back(x);
if (z == 0) zle.push_back(i);
}
dijkstra(true);
if (d[t] < l) {
cout << "NO\n";
return 0;
}
int x1 = 1, x2 = INF - 5, x3;
while (x2 - x1 > 1) {
x3 = (x1 + x2) / 2;
for (auto i : zle) {
int u = ed[i].first.first, v = ed[i].first.second;
dis[u][v] = dis[v][u] = x3;
}
dijkstra(false);
if (d[t] > l)
x2 = x3;
else
x1 = x3;
}
for (auto i : zle) {
int u = ed[i].first.first, v = ed[i].first.second;
dis[u][v] = dis[v][u] = x1;
}
dijkstra(false);
if (d[t] > l) {
cout << "NO\n";
return 0;
}
if (d[t] == l) {
cout << "YES\n";
for (auto it : ed)
cout << it.first.first << " " << it.first.second << " "
<< dis[it.first.first][it.first.second] << "\n";
return 0;
}
for (auto i : zle) {
int u = ed[i].first.first, v = ed[i].first.second;
dis[u][v] = dis[v][u] = x1 + 1;
dijkstra(false);
if (d[t] == l) {
cout << "YES\n";
for (auto it : ed)
cout << it.first.first << " " << it.first.second << " "
<< dis[it.first.first][it.first.second] << "\n";
return 0;
}
}
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> adia[1100];
int costsg;
int n, m;
int S, T, l;
int dist[1100];
vector<pair<pair<int, int>, pair<int, int>>> alone;
int cbin();
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> l >> S >> T;
int a, b, c;
while (m--) {
cin >> a >> b >> c;
if (c == 0) alone.push_back({{a, adia[a].size()}, {b, adia[b].size()}});
adia[a].push_back({b, c});
adia[b].push_back({a, c});
}
costsg = 100;
int p(0), q(1 << 30);
while (q) {
if (p + q <= 1000 * 1000 * 1100) {
costsg = p + q;
int x(cbin());
if (x <= l) p += q;
}
q >>= 1;
}
costsg = p;
if (cbin() > l || p == 0) {
cout << "NO";
return 0;
}
costsg = p + 1;
if (cbin() < l) {
cout << "NO";
return 0;
}
for (auto i : alone) {
adia[i.first.first][i.first.second].second =
adia[i.second.first][i.second.second].second = p;
}
int punere(p);
p = 0, q = 1 << 20;
while (q) {
if (p + q <= alone.size()) {
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
int x(cbin());
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second--,
adia[alone[i].second.first][alone[i].second.second].second--;
if (x <= l) p += q;
}
q >>= 1;
}
for (int i(0); i < p; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
cout << "YES\n";
for (int i(0); i < n; i++) {
for (auto j : adia[i]) {
if (j.first > i) cout << i << ' ' << j.first << ' ' << j.second << '\n';
}
}
return 0;
}
int cbin() {
for (int i(0); i <= n; i++) dist[i] = 1e9 + 100;
priority_queue<pair<int, int>> q;
q.push({0, S});
while (!q.empty()) {
int t(q.top().first), x(q.top().second);
t *= -1;
q.pop();
if (dist[x] < t) continue;
if (x == T) return dist[x];
for (auto i : adia[x]) {
if (!i.second) i.second = costsg;
if (dist[i.first] > t + i.second) {
dist[i.first] = t + i.second;
q.push({-dist[i.first], i.first});
}
}
}
return 2 * 1000 * 1000 * 1000;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const int mxn = 10010;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct edge {
int v, nxt, w;
} e[mxn << 1];
int hd[mxn], mct = 1;
void add_edge(int u, int v, int w) {
e[++mct].v = v;
e[mct].nxt = hd[u];
e[mct].w = w;
hd[u] = mct;
return;
}
long long dis[mxn], dis2[mxn];
bool inq[mxn];
void SPFA(int S) {
memset(dis, 0x3f, sizeof dis);
queue<int> q;
q.push(S);
dis[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
if (!inq[v]) {
inq[v] = 1;
q.push(v);
}
}
}
}
return;
}
struct EG {
int x, y, w;
bool use;
} ve[mxn];
int id[mxn], cnt = 0;
int n, m, S, T, L;
int main() {
int i, j;
n = read();
m = read();
L = read();
S = read() + 1;
T = read() + 1;
int u, v, w;
for (i = 1; i <= m; i++) {
u = read() + 1;
v = read() + 1;
w = read();
ve[i] = (EG){u, v, w, 0};
add_edge(u, v, w);
add_edge(v, u, w);
if (!w) {
ve[i].use = 1;
id[i] = mct - 1;
}
}
for (i = 1; i <= m; i++)
if (id[i]) e[id[i]].w = e[id[i] ^ 1].w = 1, ve[i].w = 1;
SPFA(S);
if (dis[T] > L) {
printf("NO\n");
return 0;
}
for (i = 1; i <= m; i++)
if (id[i]) e[id[i]].w = e[id[i] ^ 1].w = INF, ve[i].w = INF;
SPFA(S);
if (dis[T] < L) {
printf("NO\n");
return 0;
}
printf("YES\n");
if (dis[T] > L) {
for (i = 1; i <= m; i++) {
if (id[i]) {
ve[i].w = e[id[i]].w = e[id[i] ^ 1].w = 1;
SPFA(S);
if (dis[T] <= L) {
ve[i].w = e[id[i]].w = e[id[i] ^ 1].w = 1 + L - dis[T];
break;
}
}
}
}
for (i = 1; i <= m; i++)
printf("%d %d %d\n", ve[i].x - 1, ve[i].y - 1, ve[i].w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 50;
int n, m, L, sp, ep, lst[N], nx[N * 2], To[N * 2], w[N * 2], kd[N * 2], spcnt,
tot;
long long dis[N];
bool vis[N];
queue<int> q;
inline int read() {
int n = 0;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
return n;
}
struct edge {
int x, y, w, kd;
} e[N];
void add(int x, int y, int _w, int _k) {
++tot;
To[tot] = y, nx[tot] = lst[x], lst[x] = tot, w[tot] = _w, kd[tot] = _k;
}
long long spfa(int pos, int val) {
for (int i = 0; i <= n - 1; i++) dis[i] = inf, vis[i] = 0;
dis[sp] = 0, vis[sp] = 1, q.push(sp);
while (!q.empty()) {
int wei, t = q.front();
q.pop();
vis[t] = 0;
for (int i = lst[t]; i; i = nx[i]) {
if (kd[i] == -1)
wei = w[i];
else if (kd[i] < pos)
wei = 1;
else if (kd[i] == pos)
wei = val;
else
continue;
if (dis[t] + wei < dis[To[i]]) {
dis[To[i]] = dis[t] + wei;
if (!vis[To[i]]) q.push(To[i]), vis[To[i]] = 1;
}
}
}
return dis[ep];
}
void setwei(int pos, int val) {
for (int i = 1; i <= m; i++)
if (e[i].kd != -1) {
if (e[i].kd < pos)
e[i].w = 1;
else if (e[i].kd == pos)
e[i].w = val;
else
e[i].w = inf;
}
}
void output() {
for (int i = 1; i <= m; i++) {
printf("%d %d %d\n", e[i].x, e[i].y, e[i].w);
}
}
int main() {
n = read(), m = read(), L = read(), sp = read(), ep = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), z = read(), fl = -1;
if (z == 0) fl = ++spcnt;
e[i].x = x, e[i].y = y, e[i].w = z, e[i].kd = fl;
add(x, y, z, fl), add(y, x, z, fl);
}
long long L1 = spfa(spcnt, 1), L2 = spfa(0, 1);
if (L1 > L || L2 < L) {
puts("NO");
return 0;
}
int l = 1, r = spcnt, pos = 0;
while (l <= r) {
int mi = (l + r) >> 1;
long long t = spfa(mi, 1);
if (t <= L)
pos = mi, r = mi - 1;
else
l = mi + 1;
}
if (!pos)
setwei(0, 1);
else {
int l = 1, r = inf, answei;
while (l <= r) {
int mi = (l + r) >> 1;
long long t = spfa(pos, mi);
if (t <= L)
answei = mi, l = mi + 1;
else
r = mi - 1;
}
setwei(pos, answei);
}
puts("YES");
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t, a, b;
long long L, w;
long long dist[1024];
int parent[1024];
int marked[1024][1024] = {0};
int check[1024][1024] = {0};
vector<pair<pair<int, long long>, long long> > graph;
vector<pair<int, long long> > g[1024];
void Dijkstra(int s, int t) {
fill(parent, parent + n, -1);
fill(dist, dist + n, 1e18 + 1);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
dist[s] = 0;
parent[s] = s;
pq.push(pair<long long, int>(dist[s], s));
while (!pq.empty()) {
pair<long long, int> p = pq.top();
pq.pop();
int d = p.first;
int a = p.second;
for (int i = 0; i < g[a].size(); ++i) {
int k = g[a][i].first;
if (dist[k] > dist[a] + g[a][i].second) {
dist[k] = dist[a] + g[a][i].second;
parent[k] = a;
pq.push(pair<long long, int>(dist[k], k));
}
}
}
}
int main() {
cin >> n >> m >> L >> s >> t;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> w;
if (w == 0) {
marked[a][b] = 1;
marked[b][a] = 1;
w = 1;
}
g[a].push_back(make_pair(b, w));
g[b].push_back(make_pair(a, w));
graph.push_back(make_pair(pair<int, long long>(a, b), w));
}
Dijkstra(s, t);
if (dist[t] > L) {
cout << "NO" << endl;
} else {
while (dist[t] < L) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) check[i][j] = 0;
int x = t;
int cnt = 0;
long long diff = L - dist[t];
while (parent[x] != x) {
if (marked[parent[x]][x] == 1) {
marked[parent[x]][x] = 1 + diff;
marked[x][parent[x]] = 1 + diff;
diff = 0;
check[parent[x]][x] = 1;
check[x][parent[x]] = 1;
}
x = parent[x];
}
if (diff > 0) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; ++i) g[i].clear();
for (int i = 0; i < graph.size(); ++i) {
int a = graph[i].first.first;
int b = graph[i].first.second;
int w = graph[i].second;
if (w == 1 && check[a][b])
graph[i].second = marked[a][b];
else if (w == 1 && !check[a][b] && marked[a][b])
graph[i].second = L + 1, marked[a][b] = 0, marked[b][a] = 0;
g[a].push_back(make_pair(b, graph[i].second));
g[b].push_back(make_pair(a, graph[i].second));
}
Dijkstra(s, t);
}
if (dist[t] == L) {
cout << "YES" << endl;
for (int i = 0; i < graph.size(); ++i) {
int a = graph[i].first.first;
int b = graph[i].first.second;
long long w = graph[i].second;
cout << a << " " << b << " " << w << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10011;
long long int n, m, s, t, l;
long long int dtf[N], dtb[N], dt[N];
vector<int> gr[N];
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
std::greater<pair<long long int, long long int> > >
pq;
bool vs[N], is[N], ok;
int U[N], V[N], W[N];
int otherEnd(int u, int e) { return U[e] ^ V[e] ^ u; }
void dsp(long long int v) {
while (!pq.empty()) pq.pop();
for (long long int i = 0; i <= n + 4; ++i) vs[i] = 0, dt[i] = 1e17;
dt[v] = 0;
pq.push(make_pair(dt[v], v));
while (!pq.empty()) {
long long int pNode = (pq.top()).second;
pq.pop();
if (vs[pNode]) continue;
vs[pNode] = 1;
for (long long int i = 0; i < gr[pNode].size(); i++) {
long long int curNode = otherEnd(pNode, gr[pNode][i]);
long long int cost = W[gr[pNode][i]];
if (cost == 0) cost = 1;
if (dt[curNode] > dt[pNode] + cost) {
dt[curNode] = dt[pNode] + cost;
pq.push(make_pair(dt[curNode], curNode));
}
}
}
}
void dsp2(long long int v) {
while (!pq.empty()) pq.pop();
for (long long int i = 0; i <= n + 4; ++i) vs[i] = 0, dt[i] = 1e17;
dt[v] = 0;
pq.push(make_pair(dt[v], v));
while (!pq.empty()) {
long long int pNode = (pq.top()).second;
pq.pop();
if (vs[pNode]) continue;
vs[pNode] = 1;
for (long long int i = 0; i < gr[pNode].size(); i++) {
long long int curNode = otherEnd(pNode, gr[pNode][i]);
long long int cost = W[gr[pNode][i]];
if (cost == 0) {
cost = max(1LL, l - (dt[pNode] + dtb[curNode]));
W[gr[pNode][i]] = cost;
}
if (dt[curNode] > dt[pNode] + cost) {
dt[curNode] = dt[pNode] + cost;
pq.push(make_pair(dt[curNode], curNode));
}
}
}
}
int main() {
scanf("%lld", &n), scanf("%lld", &m), scanf("%lld", &l), scanf("%lld", &s),
scanf("%lld", &t);
s++, t++;
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d", &u), scanf("%d", &v), scanf("%d", &w);
u++, v++;
is[i] = 1;
U[i] = u, V[i] = v;
W[i] = w;
gr[u].push_back(i);
gr[v].push_back(i);
}
dsp(t);
for (int i = 1; i < n + 1; ++i) dtb[i] = dt[i];
dsp2(s);
if (dt[t] != l) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 0; i < m; ++i) {
printf("%d %d %d\n", U[i] - 1, V[i] - 1, W[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
long long d[1000];
long long n, m, L, s, t;
struct edge {
int to;
long long cost;
edge(int _to, long long _cost) {
to = _to;
cost = _cost;
};
};
vector<edge> G[1000];
struct node {
int from, to;
long long cost;
node(int _from, int _to, long long _cost) {
from = _from;
to = _to;
cost = _cost;
};
};
vector<node> E;
void dijkstra(int s) {
fill(d, d + n, INF);
d[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(pair<long long, int>(0, s));
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int v = p.second;
if (d[v] >= p.first) {
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
q.push(pair<long long, int>(d[e.to], e.to));
}
}
}
}
}
int main() {
cin >> n >> m >> L >> s >> t;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
if (w) {
G[u].push_back(edge(v, w));
G[v].push_back(edge(u, w));
} else {
E.push_back(node(u, v, w));
}
}
dijkstra(s);
if (d[t] < L) {
cout << "NO" << endl;
} else if (d[t] == L) {
printf("YES\n");
bool vis[1000][1000];
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int to = G[i][j].to;
if (!vis[i][to]) {
vis[i][to] = vis[to][i] = true;
printf("%d %d %lld\n", i, to, G[i][j].cost);
}
}
}
for (int i = 0; i < E.size(); i++) {
printf("%d %d %lld\n", E[i].from, E[i].to, INF);
}
} else {
bool flag = false;
long long dis = d[t];
int pos;
for (int i = 0; i < E.size(); i++) {
node e = E[i];
G[e.from].push_back(edge(e.to, 1));
G[e.to].push_back(edge(e.from, 1));
dijkstra(s);
if (d[t] <= L) {
flag = true;
pos = i;
break;
}
}
if (!flag) {
printf("NO\n");
return 0;
}
int tmp = t;
bool vis[1000][1000];
memset(vis, 0, sizeof(vis));
printf("YES\n");
for (int i = 0; i < pos; i++) {
node e = E[i];
printf("%d %d 1\n", E[i].from, E[i].to);
vis[e.from][e.to] = vis[e.to][e.from] = true;
}
printf("%d %d %lld\n", E[pos].from, E[pos].to, L - d[t] + 1);
vis[E[pos].from][E[pos].to] = vis[E[pos].to][E[pos].from] = true;
for (int i = pos + 1; i < E.size(); i++) {
printf("%d %d %lld\n", E[i].from, E[i].to, INF);
vis[E[i].from][E[i].to] = vis[E[i].to][E[i].from] = true;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int to = G[i][j].to;
if (!vis[i][to]) {
vis[i][to] = vis[to][i] = true;
printf("%d %d %lld\n", i, to, G[i][j].cost);
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int M = 1e4 + 5;
const long long INF = 1e15;
struct node {
int s, e, next, f, mark;
long long w;
} edge[M << 1];
int tot;
int first[N], inq[N], pre[N], up[N];
long long dis[N];
void init(int n) {
tot = 0;
for (int i = 0; i <= n; i++) first[i] = -1, dis[i] = INF;
}
void add(int u, int v, long long w) {
int f = !w;
if (!w) w = INF;
edge[tot] = (node){u, v, first[u], f, 0, w};
first[u] = tot++;
edge[tot] = (node){v, u, first[v], f, 0, w};
first[v] = tot++;
}
queue<int> q;
void spfa(int st, int ed) {
while (!q.empty()) q.pop();
dis[st] = 0;
inq[st] = 1;
pre[st] = -1;
q.push(st);
while (!q.empty()) {
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = first[u]; i != -1; i = edge[i].next) {
int v = edge[i].e;
if (dis[u] + edge[i].w > dis[v]) continue;
dis[v] = dis[u] + edge[i].w;
up[v] = i;
pre[v] = u;
if (!inq[v]) inq[v] = 1, q.push(v);
}
}
}
int n, m, st, ed, u, v;
long long w, L;
int main() {
scanf("%d%d%I64d%d%d", &n, &m, &L, &st, &ed);
init(n);
for (int i = 1; i <= m; i++) {
scanf("%d%d%I64d", &u, &v, &w);
add(u, v, w);
}
spfa(st, ed);
if (dis[ed] < L) return 0 * puts("NO");
for (int i = 0; i <= n; i++) dis[i] = INF, inq[i] = 0;
for (int i = 0; i < tot; i++)
if (edge[i].w == INF) edge[i].w = 1LL;
spfa(st, ed);
if (dis[ed] > L) return 0 * puts("NO");
while (1) {
for (int i = 0; i <= n; i++) inq[i] = 0, dis[i] = INF;
spfa(st, ed);
if (dis[ed] == L) break;
for (int i = 0; i < tot; i++)
if (edge[i].f) edge[i].mark = 0;
int now = ed, ff = 0;
long long left = L - dis[ed];
while (now != st) {
if (edge[up[now]].f) {
edge[up[now]].mark = edge[up[now] ^ 1].mark = 1;
if (!ff) ff = 1, edge[up[now]].w += left, edge[up[now] ^ 1].w += left;
}
now = pre[now];
}
for (int i = 0; i < tot; i++)
if (edge[i].f && !edge[i].mark) edge[i].w = INF;
}
puts("YES");
for (int i = 0; i < tot; i += 2)
printf("%d %d %I64d\n", edge[i].s, edge[i].e, edge[i].w);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.