text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long int infLL = 90000000000000000;
const int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
long long int converter(string a) {
long long int i, mul = 1, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
set<long long int> s;
set<long long int>::iterator it, pr;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, n, m, ans = 0LL, sum = 0LL, val, l, r, temp, left, right,
flag = 0LL, k, a;
cin >> n >> k >> a >> m;
long long int total = (n + 1) / (a + 1);
for (i = 1; i <= m && !flag; i++) {
cin >> val;
it = s.lower_bound(val);
l = 0, r = n + 1;
if (it != s.begin()) {
pr = it;
pr--;
l = *pr;
}
if (it != s.end()) r = *it;
temp = abs(r - l) / (a + 1);
left = abs(r - val) / (a + 1);
right = abs(val - l) / (a + 1);
total = total + left + right - temp;
if (total < k) {
ans = i;
flag = 1;
}
s.insert(val);
;
}
if (!flag) {
cout << "-1" << '\n';
return 0;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, a;
long long used[200010];
long long mini = 1e9;
int main() {
cin >> n >> k >> a >> m;
long long arr[m];
for (long long i = 0; i < m; i++) {
cin >> arr[i];
}
long long left = 0;
long long right = m - 1;
long long mid;
while (left <= right) {
for (long long i = 1; i <= n; i++) {
used[i] = 0;
}
mid = left + (right - left) / 2;
used[arr[mid]] = 1;
for (long long i = 0; i <= mid; i++) {
used[arr[i]] = 1;
}
long long cnt = 0;
long long ok = 0;
int ko = 0;
for (long long i = 1; i <= n; i++) {
if (used[i] == 0) {
cnt++;
if (cnt == a) {
cnt = 0;
ok++;
i++;
}
} else {
ko++;
cnt = 0;
}
}
if (ok < k) {
right = mid - 1;
mini = min(mid + 1, mini);
} else {
left = mid + 1;
}
}
if (mini == 1e9) {
cout << -1 << endl;
} else {
cout << mini << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int p[200005], a[200005], fr[200005];
int qr[200005];
bool b[200005];
int n, m, s, q;
int findp(int x) {
if (p[x] == x) return x;
return p[x] = findp(p[x]);
}
int main() {
int t, i, j, k, sm = 0;
scanf("%d%d%d%d", &n, &m, &s, &q);
for (i = 0; i < q; i++) {
scanf("%d", &qr[i]);
b[qr[i]] = 1;
}
int lst = 0, x, y;
a[lst] = 0;
p[0] = 0;
for (i = 1; i <= n; i++) {
if (b[i] == 1) {
fr[lst] = (a[lst] + 1) / (s + 1);
sm += fr[lst];
p[i] = lst = i;
a[lst] = 0;
} else
p[i] = lst, a[lst]++;
}
fr[lst] = (a[lst] + 1) / (s + 1);
sm += fr[lst];
if (sm >= m) {
printf("-1\n");
return 0;
}
for (i = q - 1; i > -1; i--) {
y = findp(qr[i]);
x = findp(y - 1);
sm -= fr[y];
sm -= fr[x];
a[x] += a[y] + 1;
fr[x] = (a[x] + 1) / (s + 1);
sm += fr[x];
p[y] = x;
if (sm >= m) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 1;
int n, A, k, a[maxn], b[maxn];
int slove(int x) {
for (int i = 1; i <= x; i++) b[i] = a[i];
sort(b + 1, b + x + 1);
int i, l = 1, cou = 0;
for (i = 1; i <= x; i++) {
int w = (b[i] - l + 1) / (A + 1);
cou += w;
l = b[i] + 1;
}
cou += (n - l + 1 + 1) / (A + 1);
if (cou >= k) return 1;
return 0;
}
int main() {
int ans, m;
while (scanf("%d%d%d", &n, &k, &A) != EOF) {
ans = 0x3f3f3f3f;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
int l = 1, r = m;
while (l <= r) {
int mid = (l + r) / 2;
if (slove(mid))
l = mid + 1;
else
r = mid - 1, ans = min(ans, mid);
}
if (ans == 0x3f3f3f3f)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int f[N], c[N];
int n, k, a;
int ans, l, r;
int m;
bool check(int x) {
memset(f, 0, sizeof f);
int cnt = 0;
f[++cnt] = 0;
for (int i(1); i <= (x); ++i) f[++cnt] = c[i];
f[++cnt] = n + 1;
sort(f + 1, f + cnt + 1);
int now = 0;
for (int i(1); i <= (cnt - 1); ++i) now += (f[i + 1] - f[i]) / (a + 1);
return now >= k;
}
int main() {
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &m);
for (int i(1); i <= (m); ++i) scanf("%d", c + i);
if (check(m)) return 0 * puts("-1");
l = 1, r = m;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid + 1;
else
r = mid;
}
if (check(l))
ans = r;
else
ans = l;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, sum;
struct zz {
int val, id;
} a[200005];
bool cmp(zz x, zz y) { return x.val < y.val; }
bool Check(int x) {
int tot = 0, l = 0;
for (int i = 1; i <= m; i++) {
if (a[i].id <= x) {
tot += (a[i].val - l) / (sum + 1);
l = a[i].val;
}
}
tot += (n - l + 1) / (sum + 1);
return k <= tot;
}
int main() {
cin >> n >> k >> sum;
cin >> m;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i].val);
a[i].id = i;
}
sort(a + 1, a + m + 1, cmp);
int l = 1, r = m;
int ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (!Check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> str;
int main() {
int n, k, a;
cin >> n >> k >> a;
int m;
cin >> m;
str.insert(0);
str.insert(n + 1);
int cn = (n + 1) / (a + 1);
int ret = -1;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
if (ret != -1) continue;
set<int>::iterator ithg = str.upper_bound(x);
set<int>::iterator itlb = --ithg;
ithg++;
cn = cn - (((*ithg) - 1) - ((*itlb) + 1) + 2) / (a + 1);
cn = cn + (((*ithg) - 1) - (x + 1) + 2) / (a + 1) +
((x - 1) - ((*itlb) + 1) + 2) / (a + 1);
str.insert(x);
if (cn < k && ret == -1) ret = i + 1;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int n, k, a, m, ships;
set<pair<int, int> > xs;
int calc(int l, int r) { return (r - l + 2) / (a + 1); }
int main() {
scanf("%d %d %d %d", &n, &k, &a, &m);
xs.insert(make_pair(n, 1));
ships = calc(1, n);
for (int i = 0; i < int(m); i++) {
int x, newk1 = 0, newk2 = 0;
scanf("%d", &x);
auto it = xs.lower_bound(make_pair(x, -1));
int l = it->second, r = it->first;
if (x - 1 >= l) newk1 = calc(l, x - 1);
if (x + 1 <= r) newk2 = calc(x + 1, r);
ships -= calc(l, r);
ships += newk1 + newk2;
if (ships < k) {
printf("%d\n", i + 1);
return 0;
}
xs.erase(it);
if (x - 1 >= l) xs.insert(make_pair(x - 1, l));
if (x + 1 <= r) xs.insert(make_pair(r, x + 1));
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201000;
int arr[maxn];
set<int> S;
set<int>::iterator it;
set<int>::iterator itb;
set<int>::iterator ite;
int main() {
int n, k, a;
cin >> n >> k >> a;
int m;
cin >> m;
for (int i = 1; i <= m; i++) cin >> arr[i];
S.insert(0);
S.insert(n + 1);
int can = (n + 1) / (a + 1);
int chek = -1;
for (int i = 1; i <= m; i++) {
if (S.find(arr[i]) != S.end()) continue;
S.insert(arr[i]);
it = S.find(arr[i]);
it--;
itb = it;
it++, it++;
ite = it;
it--;
can += (*it - *itb) / (a + 1);
can += (*ite - *it) / (a + 1);
can -= (*ite - *itb) / (a + 1);
if (can < k) {
chek = i;
break;
}
}
cout << chek << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, res = -1;
bool off = false;
scanf("%d %d %d", &n, &k, &a);
int m;
scanf("%d", &m);
set<pair<int, int> > intv;
intv.insert(make_pair(n, 1));
int num = (n + 1) / (a + 1);
for (int i = 1; i <= m; i++) {
int b;
scanf("%d", &b);
set<pair<int, int> >::iterator p = intv.lower_bound(make_pair(b, 0));
int l = p->second;
int r = p->first;
num -= (r - l + 2) / (a + 1);
intv.erase(make_pair(r, l));
if (b > l) {
intv.insert(make_pair(b - 1, l));
num += (b - l + 1) / (a + 1);
}
if (b < r) {
intv.insert(make_pair(r, b + 1));
num += (r - b + 1) / (a + 1);
}
if (num < k && !off) {
res = i;
off = true;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c, m, x, mx = 0;
cin >> n >> k >> c >> m;
mx = (n + 1) / (c + 1);
set<int> s;
s.insert(0), s.insert(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
set<int>::iterator A, B;
cin >> x;
A = s.lower_bound(x);
A--;
B = s.upper_bound(x);
a = *A;
a++;
b = *B;
b--;
mx -= ((b - a + 2) / (c + 1)) -
((b - x + 1) / (c + 1) + (x - a + 1) / (c + 1));
if (mx < k) return cout << i + 1 << endl, 0;
s.insert(x);
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, n, k, m, x;
scanf("%d %d %d %d", &N, &k, &n, &m);
set<int> st;
st.insert(0);
st.insert(N + 1);
int sets = (N + 1) / (n + 1);
for (int i = 1; i <= m; ++i) {
scanf("%d", &x);
auto up = st.upper_bound(x);
auto lw = --st.upper_bound(x);
int tmp = (*up - *lw) / (n + 1);
sets -= tmp;
sets += ((*up - x) / (n + 1) + (x - *lw) / (n + 1));
if (sets < k) {
printf("%d", i);
return 0;
}
st.insert(x);
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
int calc(pair<int, int> p, int a) {
int len = p.second - p.first + 1;
return (len + 1) / (a + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, a, m;
cin >> n >> k >> a >> m;
vector<int> x(m);
for (int i = 0; i < m; i++) cin >> x[i];
set<pair<int, int>> seg;
seg.insert({1, n});
int sum = calc({1, n}, a);
for (int i = 0; i < m; i++) {
pair<int, int> p = *prev(seg.upper_bound({x[i], INF}));
if (p.first == p.second) {
sum -= calc(p, a);
seg.erase(p);
if (sum < k) {
cout << i + 1 << endl;
return 0;
}
continue;
}
sum -= calc(p, a);
if (p.first == x[i]) {
pair<int, int> q = {p.first + 1, p.second};
sum += calc(q, a);
seg.insert(q);
} else if (p.second == x[i]) {
pair<int, int> q = {p.first, p.second - 1};
sum += calc(q, a);
seg.insert(q);
} else {
pair<int, int> q = {p.first, x[i] - 1};
pair<int, int> r = {x[i] + 1, p.second};
sum += calc(q, a);
sum += calc(r, a);
seg.insert(q);
seg.insert(r);
}
seg.erase(p);
if (sum < k) {
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> S;
set<int>::iterator it;
int main() {
int n, k, a, m, x;
scanf("%d%d%d", &n, &k, &a);
int rest = (n + 1) / (a + 1);
scanf("%d", &m);
S.insert(0);
S.insert(n + 1);
int flag = -1;
for (int i = 1; i <= m && flag == -1; i++) {
scanf("%d", &x);
S.insert(x);
it = S.lower_bound(x);
it--;
int l = *it;
it = S.upper_bound(x);
int r = *it;
rest -= (r - l) / (a + 1);
rest += (r - x) / (a + 1);
rest += (x - l) / (a + 1);
if (rest < k) flag = i;
}
printf("%d\n", flag);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
long long myceil(long long a, long long b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
bool isPerSquare(long double a) {
if (a < 0) return false;
long long sr = sqrt(a);
return (sr * sr == a);
}
long long arr1[200002];
long long arr2[200002];
long long arr2D[1001][1001];
vector<long long> vec;
long long getval(pair<long long, long long> p, long long a) {
if (p.first == -1) return 0;
return (p.second - p.first + 2) / (a + 1);
}
void solve() {
long long n, m, a, b, c, k;
string s;
cin >> n >> k >> a;
cin >> m;
for (long long i = 0; i < m; i++) cin >> arr1[i];
set<pair<long long, long long>> unoccupied;
unoccupied.insert({1, n});
long long maxposs = (n + 1) / (a + 1);
for (long long i = 0; i < m; i++) {
pair<long long, long long> findgap =
*prev(unoccupied.upper_bound({arr1[i], arr1[i]}));
if ((*unoccupied.upper_bound({arr1[i], arr1[i]})).first == arr1[i]) {
findgap = *unoccupied.upper_bound({arr1[i], arr1[i]});
}
maxposs -= getval(findgap, a);
unoccupied.erase(findgap);
pair<long long, long long> leftgap = {-1, -1}, rightgap = {-1, -1};
if (findgap.first <= (arr1[i] - 1)) leftgap = {findgap.first, arr1[i] - 1};
if (findgap.second >= (arr1[i] + 1))
rightgap = {arr1[i] + 1, findgap.second};
long long newval = maxposs + getval(leftgap, a) + getval(rightgap, a);
if (newval < k) {
cout << i + 1 << endl;
return;
}
unoccupied.insert(leftgap);
unoccupied.insert(rightgap);
maxposs = newval;
}
cout << -1 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (int it = 1; it <= t; it++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int n, k, a, m;
int main() {
cin >> n >> k >> a;
cin >> m;
s.clear();
s.insert(0);
s.insert(n + 1);
int tp = (n + 1) / (a + 1), pos = 0;
bool fl = false;
for (int i = 1; i <= m; i++) {
pos = i;
int x;
cin >> x;
set<int>::iterator v;
v = s.lower_bound(x);
int r = *v;
v--;
int l = *v;
tp = tp - (r - l) / (a + 1) + (x - l) / (a + 1) + (r - x) / (a + 1);
if (tp < k) {
fl = true;
break;
}
s.insert(x);
}
if (fl)
cout << pos;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int roundpow2(int x) {
int y = 1;
while (y < x) {
y *= 2;
}
return y;
}
class SegmentTree {
private:
vector<pair<int, int>> tree;
int sz;
void push(int i) {
if (tree[i] != make_pair(-1, -1)) {
tree[i * 2 + 1] = tree[i];
tree[i * 2 + 2] = tree[i];
tree[i] = make_pair(-1, -1);
}
}
pair<int, int> query(int i, int tl, int tr, int index) {
if (tl == tr - 1) {
return tree[i];
}
push(i);
int tm = (tl + tr) / 2;
if (index < tm) {
return query(2 * i + 1, tl, tm, index);
} else {
return query(2 * i + 2, tm, tr, index);
}
}
void update(int i, int tl, int tr, int l, int r, pair<int, int> val) {
if (l >= tr || r <= tl) {
return;
}
if (l <= tl && tr <= r) {
tree[i] = val;
return;
}
if (tl == tr - 1) {
return;
}
push(i);
int tm = (tl + tr) / 2;
update(i * 2 + 1, tl, tm, l, r, val);
update(i * 2 + 2, tm, tr, l, r, val);
}
public:
SegmentTree(int n) {
sz = roundpow2(n);
tree.resize(2 * sz, make_pair(-1, -1));
for (int i = n - 1; i < 2 * n - 1; i++) {
tree[i] = make_pair(0, n - 1);
}
}
pair<int, int> query(int index) { return query(0, 0, sz, index); }
void update(int l, int r, pair<int, int> val) {
update(0, 0, sz, l, r + 1, val);
}
};
int n, k, a;
int m;
int func(int l, int r) { return (r - l + 2) / (a + 1); }
int main() {
cin >> n >> k >> a >> m;
SegmentTree tree(n);
int p = func(0, n - 1);
int ans = -1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
x--;
pair<int, int> v = tree.query(x);
int l = v.first;
int r = v.second;
p -= func(l, r);
p += func(l, x - 1);
p += func(x + 1, r);
tree.update(l, x - 1, make_pair(l, x - 1));
tree.update(x + 1, r, make_pair(x + 1, r));
if (p < k && ans == -1) {
ans = i + 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> section;
map<int, int> maps;
int main() {
int n, k, a, m, point;
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &m);
maps[0] = 0;
maps[n + 1] = 0;
int can = (n + 1) / (a + 1);
map<int, int>::iterator myit;
map<int, int>::iterator myit2;
for (int i = 1; i <= m; i++) {
scanf("%d", &point);
myit = maps.lower_bound(point);
myit2 = myit;
myit--;
maps[point] = 0;
int dist = myit2->first - myit->first;
int dist1 = (point - myit->first);
int dist2 = (myit2->first - point);
can -= dist / (a + 1);
can += dist1 / (a + 1);
can += dist2 / (a + 1);
if (can < k) {
printf("%d\n", i);
return 0;
}
}
printf("%d\n", -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long double pi = 3.14159265358979323846264338327950288419716939937510;
long long po(long long a, long long b) {
long long res = 1 % mod;
a %= mod;
for (; b; b >>= 1) {
if (b & (1LL)) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const long double eps = 1e-10;
const int oo = 1000000009;
const long long ooo = 2e18 + 5;
int n, k, a;
int q;
vector<int> Q;
int battel[200009];
bool isLied(int x) {
memset(battel, 0, sizeof(battel));
for (int i = 0; i <= x; i++) battel[Q[i]]++;
int K, A;
K = k, A = a;
for (int i = 1; i <= n; i++) {
if (battel[i])
A = a;
else
A--;
if (A == 0) {
A = a;
i++;
K--;
}
if (K == 0) return false;
}
if (K == 0) return false;
return true;
}
int main() {
scanf("%d %d %d\n", &n, &k, &a);
scanf("%d", &q);
Q.resize(q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
int low = 0, high = q - 1, ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (isLied(mid)) {
ans = mid;
high = mid - 1;
} else
low = mid + 1;
}
if (ans == -1)
cout << ans;
else
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &a) {
static char c;
static int fh;
while (((c = getchar()) < '0' | c > '9') && c != '-')
;
if (c == '-')
fh = -1, a = 0;
else
fh = 1, a = c - '0';
while ((c = getchar()) <= '9' && c >= '0') a = (a << 3) + (a << 1) + c - '0';
a = a * fh;
}
template <class T>
void write(T a) {
if (a == 0)
putchar('0');
else {
if (a < 0) putchar('-'), a = -a;
static char c[30];
static int c0;
c0 = 0;
while (a) c[++c0] = a % 10 + '0', a /= 10;
while (c0) putchar(c[c0--]);
}
}
long int steps[200005];
map<long int, long int> m;
map<long int, long int>::iterator it;
int main() {
long int n, k, a;
read(n);
read(k);
read(a);
long int q, i;
read(q);
for (i = 0; i < q; i++) read(steps[i]);
m[1] = n;
long int cnt = 0, s, mid, lo, hi;
s = n;
if (s / a > 0) cnt += (s + 1) / (a + 1);
for (i = 0; i < q; i++) {
mid = steps[i];
it = m.upper_bound(mid);
if (it != m.begin()) it--;
lo = it->first;
hi = it->second;
m.erase(it);
s = hi - lo + 1;
if (s / a > 0) cnt -= (s + 1) / (a + 1);
s = mid - lo;
if (s / a > 0) cnt += (s + 1) / (a + 1);
m[lo] = mid - 1;
s = hi - (mid + 1) + 1;
if (s / a > 0) cnt += (s + 1) / (a + 1);
m[mid + 1] = hi;
if (cnt < k) {
cout << i + 1 << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, A, M;
int Array[200005];
int V[200005];
set<pair<int, int> > S;
void Read() {
cin >> N >> K >> A >> M;
for (int i = 1; i <= N; i++) V[i] = 1;
for (int i = 1; i <= M; i++) cin >> Array[i];
}
int binSearch(int left, int poz) {
int right = poz, sol = poz + 1, mid;
while (left <= right) {
mid = (left + right) / 2;
if (V[mid] == 1) {
sol = mid;
right = mid - 1;
} else
left = mid + 1;
}
return sol;
}
void Solve() {
int total = (N + 1) / (A + 1);
S.insert(make_pair(1, N));
for (int i = 1; i <= M; i++) {
int val = Array[i];
if (V[Array[i]] == 0) continue;
V[Array[i]] = 1;
pair<int, int> p = make_pair(Array[i], N + 1);
set<pair<int, int> >::iterator it = S.upper_bound(p);
--it;
p = *it;
S.erase(p);
total -= (p.second - p.first + 2) / (A + 1);
total += (val - p.first + 1) / (A + 1);
total += (p.second - val + 1) / (A + 1);
if (val != p.first) S.insert(make_pair(p.first, val - 1));
if (val != p.second) S.insert(make_pair(val + 1, p.second));
if (total < K) {
cout << i << "\n";
return;
}
}
cout << "-1\n";
}
int main() {
Read();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
void CI(int &_x) { scanf("%d", &_x); }
void CO(int &_x) { cout << _x; }
template <typename T>
void getarray(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
int dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dr4[4] = {0, 0, 1, -1};
int dc4[4] = {-1, 1, 0, 0};
int kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
int main() {
int n, k, a;
CI(n);
CI(k);
CI(a);
set<pair<int, int> > S;
S.insert(make_pair(1, n));
int maxi_boat = (n + 1) / (a + 1);
set<pair<int, int> >::iterator it;
int m;
CI(m);
for (int i = 1; i <= m; i++) {
int shot_point;
CI(shot_point);
it = S.lower_bound(make_pair(shot_point, -1));
pair<int, int> temp = *it;
if (it == S.end() || temp.first > shot_point) it--;
temp = *it;
maxi_boat -= (temp.second - temp.first + 2) / (a + 1);
S.erase(it);
pair<int, int> f_p, s_p;
f_p = make_pair(temp.first, shot_point - 1);
s_p = make_pair(shot_point + 1, temp.second);
maxi_boat += (f_p.second - f_p.first + 2) / (a + 1);
maxi_boat += (s_p.second - s_p.first + 2) / (a + 1);
if (maxi_boat < k) {
cout << i << "\n";
return 0;
}
S.insert(f_p);
S.insert(s_p);
}
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
int stone[200005];
int road[200005];
bool ok(int x) {
memset(road, 0, sizeof road);
for (int i = 1; i <= x; i++) road[stone[i]] = 1;
int cnt = 0;
int l = 0;
for (int i = 1; i <= n; i++) {
if (road[i] == 1) {
l = 0;
continue;
}
l++;
if (l == a) {
cnt++;
l = -1;
}
}
return cnt >= k;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> a;
cin >> m;
for (int i = 1; i <= m; i++) cin >> stone[i];
int lo = 0, hi = m + 1;
while (hi - lo > 1) {
int mid = (lo + hi) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
if (hi == m + 1)
cout << -1 << '\n';
else
cout << hi << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree[200010];
void update(int idx, int x, int n) {
while (idx <= n) {
tree[idx] += x;
idx += idx & (-idx);
}
}
int query(int idx) {
if (idx <= 0) return 0;
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= idx & (-idx);
}
return sum;
}
int n;
int _search(int fx, int l, int r, int ck) {
int mid, ret;
while (l <= r) {
mid = (l + r) / 2;
if (ck == 1) {
int qq = query(fx) - query(mid - 1);
if (qq == 1) {
ret = mid;
l = mid + 1;
} else if (qq > 1) {
l = mid + 1;
} else
r = mid - 1;
} else {
int qq = query(mid) - query(fx - 1);
if (qq == 1) {
ret = mid;
r = mid - 1;
} else if (qq > 1) {
r = mid - 1;
} else
l = mid + 1;
}
}
return ret;
}
int main() {
int k, a, m, i, id;
scanf("%d %d %d", &n, &k, &a);
update(1, 1, n + 2);
update(n + 2, 1, n + 2);
int z = a + 1;
int ans = (n + 1) / z;
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &id);
int l = _search(id + 1, 0, id + 1, 1);
int r = _search(id + 1, id + 1, n + 2, 2);
ans = ans - ((r - l - 1 + 1) / z);
ans += ((id + 1 - l - 1 + 1) / z) + ((r - id - 1 - 1 + 1) / z);
update(id + 1, 1, n + 2);
if (ans < k) {
printf("%d\n", i);
return 0;
}
}
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, k;
int x[200030], xx[200030];
bool judge(int m) {
for (int i = 1; i <= m; i++) xx[i] = x[i];
sort(xx + 1, xx + 1 + m);
int ans = 0;
xx[0] = 0;
for (int i = 1; i <= m; i++) ans += (xx[i] - xx[i - 1]) / (a + 1);
ans += (n - xx[m] + 1) / (a + 1);
return ans < k;
}
int main() {
int m;
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", x + i);
int ans = 1 << 30;
int l = 1, r = m, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (judge(mid))
ans = min(ans, mid), r = mid - 1;
else
l = mid + 1;
}
if (ans == (1 << 30)) ans = -1;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t, x, y, z,
mx, mn, s, lo, hi, mid;
char c[1000009], d[1000009], ch;
int isvalid(int num) {
memset(b, 0, sizeof(b));
b[0] = b[n + 1] = 1;
for (int o = 0; o < num; o++) {
b[a[o]] = 1;
}
int cnt = 0;
int prev = 0;
for (int o = 1; o <= n + 1; o++) {
if (b[o] == 1) {
int g = o - prev - 1;
prev = o;
int tmp = (g + 1) / (x + 1);
cnt += tmp;
}
}
if (cnt >= k) {
return 1;
} else {
return 0;
}
}
int main() {
while (scanf("%d %d %d", &n, &k, &x) != EOF) {
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d", &a[i]);
}
lo = 1;
hi = m;
ans = m + 1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (isvalid(mid) == 1) {
lo = mid + 1;
} else {
ans = mid;
hi = mid - 1;
}
}
if (ans == m + 1) {
ans = -1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
const int MXN = 6 * 50010;
const int C = 262144;
const int INF = 1000000001;
namespace SAT2 {
vector<int> G[MXN], GT[MXN], H[MXN], vert[MXN];
int pre[MXN], skl[MXN];
vector<int> fu;
class SAT2 {
SAT2() {}
int n, czas, skla;
int neg(int v1) { return (v1 + n) % (2 * n); }
void addEdge(int v1, int v2) {
G[neg(v1)].push_back(v2);
GT[v2].push_back(neg(v1));
G[neg(v2)].push_back(v1);
GT[v1].push_back(neg(v2));
}
void dfs(int x) {
pre[x] = ++czas;
for (__typeof((G[x]).begin()) it = ((G[x]).begin()); it != (G[x]).end();
++it)
if (!pre[*it]) dfs(*it);
fu.push_back(x);
}
void dfs2(int x) {
skl[x] = skla;
vert[skla].push_back(x);
for (__typeof((GT[x]).begin()) it = ((GT[x]).begin()); it != (GT[x]).end();
++it)
if (!skl[*it]) dfs2(*it);
}
void dfs3(int x) {
pre[x] = 1;
for (__typeof((H[x]).begin()) it = ((H[x]).begin()); it != (H[x]).end();
++it)
if (!pre[*it]) dfs3(*it);
fu.push_back(x);
}
void clear() {
fu.clear();
for (int i = (0); i <= (2 * n); i++) pre[i] = skl[i] = 0;
for (int i = (0); i <= (2 * n); i++) {
G[i].clear();
GT[i].clear();
vert[i].clear();
H[i].clear();
}
}
public:
SAT2(int _n) {
czas = 0;
skla = 0;
n = _n;
}
void add(int v1, bool pos1, int v2, bool pos2) {
addEdge((pos1 ? neg(v1) : v1), (pos2 ? neg(v2) : v2));
}
pair<bool, vector<bool> > solve() {
for (int i = (0); i <= (2 * n - 1); i++)
if (!pre[i]) dfs(i);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (!skl[w]) {
skla++;
dfs2(w);
}
}
skla++;
for (int i = (0); i <= (n - 1); i++)
if (skl[i] == skl[i + n]) {
clear();
return make_pair(false, vector<bool>());
}
for (int i = (0); i <= (2 * n - 1); i++) {
for (__typeof((G[i]).begin()) it = ((G[i]).begin()); it != (G[i]).end();
++it)
H[skl[i]].push_back(skl[*it]);
}
fu.clear();
for (int i = (0); i <= (skla); i++) pre[i] = 0;
for (int i = (0); i <= (skla - 1); i++)
if (!pre[i]) dfs3(i);
vector<bool> res(2 * n, 0);
vector<int> tmp(skla + 1, -1);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (tmp[w] == -1) tmp[w] = 0;
if (tmp[w] == 1)
for (__typeof((H[w]).begin()) it = ((H[w]).begin()); it != (H[w]).end();
++it)
tmp[*it] = 1;
for (__typeof((vert[w]).begin()) it = ((vert[w]).begin());
it != (vert[w]).end(); ++it) {
tmp[skl[neg(*it)]] = !tmp[w];
res[*it] = tmp[w];
res[neg(*it)] = !tmp[w];
}
}
clear();
return make_pair(true, res);
}
};
} // namespace SAT2
int n2, m;
vector<pair<int, pair<int, int> > > G2[MXN];
int c[MXN], t[MXN];
pair<bool, vector<bool> > check(int second) {
SAT2::SAT2 SAT(3 * m);
for (int i = (0); i <= (m - 1); i++)
if (t[i] > second) SAT.add(i, 1, i, 1);
for (int i = (1); i <= (n2); i++) {
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int iter = j;
while (iter < (int)(G2[i]).size() && G2[i][j].first == G2[i][iter].first)
iter++;
if (iter - j > 2)
return make_pair(false, vector<bool>());
else if (iter - j == 2)
SAT.add(G2[i][j].second.second, 0, G2[i][j + 1].second.second, 0);
j = iter - 1;
}
int last = -1;
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int ei = G2[i][j].second.second;
int pi = ei;
if (i < G2[i][j].second.first)
pi += m;
else
pi += 2 * m;
SAT.add(pi, 1, ei, 1);
if (last != -1) {
SAT.add(ei, 1, last, 0);
SAT.add(pi, 1, last, 0);
}
last = pi;
}
}
return SAT.solve();
}
void test() {
scanf("%d %d", &n2, &m);
int mx = 0;
for (int i = (1); i <= (m); i++) {
int a, b;
scanf("%d %d %d %d", &a, &b, &c[i - 1], &t[i - 1]);
mx = max(mx, t[i - 1]);
G2[a].push_back(make_pair(c[i - 1], make_pair(b, i - 1)));
G2[b].push_back(make_pair(c[i - 1], make_pair(a, i - 1)));
}
for (int i = (1); i <= (n2); i++) sort((G2[i]).begin(), (G2[i]).end());
int res = INF;
int L = 0, R = mx;
vector<bool> ans;
while (L <= R) {
int second = (L + R) / 2;
pair<bool, vector<bool> > p1 = check(second);
if (p1.first) {
if (res > second) {
res = second;
ans = p1.second;
}
R = second - 1;
} else
L = second + 1;
}
if (res != INF) {
printf("Yes\n");
int cnt = 0;
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) cnt++;
printf("%d %d\n", res, cnt);
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) printf("%d ", i + 1);
printf("\n");
} else
printf("No\n");
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1e9 + 100;
const long long LINF = 1e18 + 100;
const int MAXN = 50100;
const int MEM = 6 * MAXN;
int n, m;
int ef[MAXN], eto[MAXN], col[MAXN], tim[MAXN];
vector<int> ngb[MAXN];
int gn;
vector<int> adj[MEM], rev[MEM];
int cnum[MEM], cn;
bool mark[MEM], ans[MEM];
vector<int> stk;
void dfs1(int v) {
mark[v] = true;
for (int u : adj[v])
if (!mark[u]) dfs1(u);
stk.push_back(v);
}
void dfs2(int v) {
mark[v] = true;
cnum[v] = cn;
for (int u : rev[v])
if (!mark[u]) dfs2(u);
}
inline int NOT(int x) {
if (x > 2 * m) return (x % 2 ? x + 1 : x - 1);
return (x > m ? x - m : x + m);
}
inline void addedge(int x, int y) {
adj[x].push_back(y);
rev[y].push_back(x);
}
inline void addcond(int x, int y) {
addedge(NOT(x), y);
addedge(NOT(y), x);
}
bool check(int x) {
gn = 2 * m;
for (int i = (0); i < (int)(MEM); i++) adj[i].clear(), rev[i].clear();
stk.clear();
memset(mark, 0, sizeof(mark));
memset(ans, 0, sizeof(ans));
memset(cnum, 0, sizeof(cnum));
cn = 0, gn = 2 * m;
for (int v = (1); v < (int)(n + 1); v++) {
if (ngb[v].empty()) continue;
;
;
sort((ngb[v]).begin(), (ngb[v]).end(),
[&](int x, int y) { return col[x] < col[y]; });
int ind = -1;
for (int i = 0; i < (int)ngb[v].size();) {
int j;
for (j = i; j < (int)ngb[v].size() && col[ngb[v][i]] == col[ngb[v][j]];
j++)
;
if (j - i > 2 || (j - i == 2 && ind >= 0)) return false;
if (j - i == 2) ind = i;
i = j;
}
if (ind >= 0) {
addcond(ngb[v][ind], ngb[v][ind + 1]);
}
gn += 2;
addcond(gn, NOT(ngb[v][0]));
for (int i = (1); i < (int)((int)ngb[v].size()); i++) {
gn += 2;
addcond(NOT(gn - 2), gn);
addcond(NOT(gn - 2), NOT(ngb[v][i]));
addcond(gn, NOT(ngb[v][i]));
};
;
}
for (int i = (1); i < (int)(m + 1); i++)
if (tim[i] > x) addcond(NOT(i), NOT(i));
for (int i = (1); i < (int)(gn + 1); i++)
if (!mark[i]) dfs1(i);
memset(mark, 0, sizeof(mark));
while (!stk.empty()) {
int v = stk.back();
stk.pop_back();
if (!mark[v]) cn++, dfs2(v);
};
;
for (int i = (1); i < (int)(gn + 1); i++) {
if (cnum[i] == cnum[NOT(i)])
return false;
else if (cnum[i] > cnum[NOT(i)])
ans[i] = 1;
}
return true;
}
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = (1); i < (int)(m + 1); i++) {
cin >> ef[i] >> eto[i] >> col[i] >> tim[i];
ngb[ef[i]].push_back(i);
ngb[eto[i]].push_back(i);
}
int l = -1, r = INF;
while (r - l > 1) {
int mid = (r + l) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (r > 1e9 + 10) return cout << "No\n", 0;
cout << "Yes\n";
check(r);
vector<int> res;
for (int i = (1); i < (int)(m + 1); i++)
if (ans[i]) res.push_back(i);
cout << r << ' ' << res.size() << '\n';
for (int u : res) cout << u << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 100;
int n, m, U[MAXN], V[MAXN], c[MAXN], t[MAXN];
int res[MAXN];
map<int, int> mp;
vector<int> adj[MAXN], in[MAXN], out[MAXN], vec;
bool mark[MAXN], is[MAXN];
void dfs(int u) {
mark[u] = true;
for (int i = 0; i < out[u].size(); i++) {
int v = out[u][i];
if (!mark[v]) dfs(v);
}
vec.push_back(u);
}
void dfs2(int u, int cc) {
res[u] = cc;
for (int i = 0; i < in[u].size(); i++) {
int v = in[u][i];
if (res[v] == -1) dfs2(v, cc);
}
}
inline void add_e(int a, int b) {
out[a ^ 1].push_back(b);
in[b].push_back(a ^ 1);
out[b ^ 1].push_back(a);
in[a].push_back(b ^ 1);
}
bool ok(int mid) {
int C = m;
for (int i = 0; i < MAXN; i++) {
in[i].clear(), out[i].clear();
mark[i] = is[i] = 0;
res[i] = -1;
}
vec.clear();
for (int i = 0; i < n; i++) {
mp.clear();
int cur = -1;
for (int j = 0; j < adj[i].size(); j++) {
int id = adj[i][j];
if (cur == -1)
cur = id;
else {
add_e(2 * cur + 1, 2 * id + 1);
add_e(2 * cur + 1, 2 * C);
add_e(2 * id + 1, 2 * C);
cur = C;
C++;
}
if (!mp[c[id]])
mp[c[id]] = id + 1;
else if (mp[c[id]] == -1)
return false;
else
add_e(2 * (mp[c[id]] - 1), 2 * id), mp[c[id]] = -1;
}
}
for (int i = 0; i < m; i++)
if (t[i] > mid)
out[2 * i].push_back(2 * i + 1), in[2 * i + 1].push_back(2 * i);
for (int i = 0; i < 2 * C; i++)
if (!mark[i]) dfs(i);
int cnt = 0;
for (int i = 2 * C - 1; i >= 0; i--) {
if (res[vec[i]] == -1) dfs2(vec[i], cnt++);
}
for (int i = 0; i < 2 * C; i += 2) {
if (res[i] == res[i + 1])
return false;
else if (res[i] > res[i + 1])
is[i / 2] = true;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> U[i] >> V[i] >> c[i] >> t[i], V[i]--, U[i]--;
adj[V[i]].push_back(i), adj[U[i]].push_back(i);
}
int l = 0, r = INT_MAX / 2 + 10;
if (!ok(r)) return cout << "No" << endl, 0;
while (r - l > 1) {
int mid = (r + l) / 2;
if (ok(mid))
r = mid;
else
l = mid;
}
if (r >= INT_MAX / 2 + 5) return cout << "No" << endl, 0;
if (ok(0)) {
cout << "Yes" << endl;
cout << 0 << " " << 0 << endl;
return 0;
}
ok(r);
cout << "Yes" << endl;
int ans = 0;
for (int i = 0; i < m; i++)
if (is[i]) ans++;
cout << r << " " << ans << endl;
for (int i = 0; i < m; i++)
if (is[i]) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
const int MAXV = 6 * MAXN;
const int MAXE = 20 * MAXN;
struct Graph {
struct edge {
int to;
edge *nxt;
} edges[MAXE + 5], *adj[MAXV + 5], *ecnt;
Graph() { ecnt = edges; }
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
} G1, G2;
int n, m, cnt;
struct edge {
int u, v, c, t, id;
edge() {}
edge(int _u, int _v, int _c, int _t, int _id)
: u(_u), v(_v), c(_c), t(_t), id(_id) {}
} e[MAXN + 5];
bool cmp(const edge &a, const edge &b) { return a.t < b.t; }
int dfn[MAXV + 5], low[MAXV + 5], id[MAXV + 5];
int stk[MAXV + 5], tp, dcnt, tot;
void dfs(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool check(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs(i);
for (int i = 0; i < m; i++) {
if (id[i << 1] == id[i << 1 | 1]) return false;
}
return true;
}
vector<int> v1[MAXV + 5];
void dfs2(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs2(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
v1[tot].push_back(stk[tp]);
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool tag[MAXV + 5];
vector<int> ans;
void print(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs2(i);
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < (int)v1[i].size(); j++) {
int x = v1[i][j];
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt)
if (tag[id[p->to]]) tag[i] = true;
}
if (!tag[i]) {
for (int j = 0; j < (int)v1[i].size(); j++)
if (v1[i][j] < 2 * m) tag[id[v1[i][j] ^ 1]] = true;
}
}
for (int i = 0; i < m; i++) {
if (tag[id[i << 1]]) ans.push_back(i + 1);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
}
map<int, int> mp;
vector<edge> vec[MAXN + 5];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, c, t;
scanf("%d%d%d%d", &u, &v, &c, &t);
e[i] = edge(u, v, c, t, i);
vec[u].push_back(e[i]), vec[v].push_back(e[i]);
}
cnt = 2 * m;
for (int i = 1; i <= n; i++) {
bool flag = false;
mp.clear();
for (int j = 0; j < (int)vec[i].size(); j++) {
if (mp.count(vec[i][j].c)) {
if (flag)
puts("No"), exit(0);
else
flag = true;
int x = vec[i][j].id, y = mp[vec[i][j].c];
G1.addedge(x << 1, y << 1 | 1), G1.addedge(y << 1, x << 1 | 1);
} else
mp[vec[i][j].c] = vec[i][j].id;
}
if (vec[i].size() >= 2) {
int lst = (vec[i][0].id << 1);
for (int j = 1; j < (int)vec[i].size(); j++) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j + 1 == (int)vec[i].size()) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
lst = (vec[i][vec[i].size() - 1].id << 1);
for (int j = (int)vec[i].size() - 2; j >= 0; j--) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j == 0) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
}
}
sort(e, e + m, cmp);
if (!check(m - 1))
puts("No"), exit(0);
else
puts("Yes");
int le = -1, ri = m - 1;
while (le < ri) {
int mid = (le + ri) >> 1;
if (check(mid))
ri = mid;
else
le = mid + 1;
}
printf("%d ", le == -1 ? 0 : e[le].t), print(le);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5, inf = INT_MAX;
int n, m, x[MAXN], y[MAXN], c[MAXN], t[MAXN], cmp[MAXN], cnt;
vector<int> adj[MAXN], in[MAXN], out[MAXN], tmp;
vector<pair<int, int>> es;
map<pair<int, int>, int> e1, e2;
bool mark[MAXN];
inline void add(int u, int v) {
out[u].push_back(v);
in[v].push_back(u);
return;
}
void dfs(int v) {
mark[v] = true;
for (int u : out[v])
if (!mark[u]) dfs(u);
tmp.push_back(v);
return;
}
void dfs2(int v) {
mark[v] = true;
cmp[v] = cnt;
for (int u : in[v])
if (!mark[u]) dfs2(u);
return;
}
inline bool check(int w) {
tmp.clear();
cnt = 0;
for (int i = 0; i < MAXN; i++) {
in[i].clear();
out[i].clear();
mark[i] = false;
cmp[i] = 0;
}
for (int i = 0; i < m; i++)
if (t[i] > w) add(i * 2 + 1, i * 2);
for (auto i : es) {
add(i.first * 2, i.second * 2 + 1);
add(i.second * 2, i.first * 2 + 1);
}
int last = m, pre;
for (int i = 0; i < n; i++) {
if (adj[i].empty()) continue;
pre = adj[i][0];
for (int j = 1; j < (int)adj[i].size(); j++) {
int ind = adj[i][j];
add(pre * 2 + 1, last * 2 + 1);
add(last * 2, pre * 2);
add(ind * 2 + 1, last * 2 + 1);
add(last * 2, ind * 2);
add(pre * 2 + 1, ind * 2);
add(ind * 2 + 1, pre * 2);
pre = last;
last++;
}
}
for (int i = 0; i < last * 2; i++)
if (!mark[i]) dfs(i);
for (int i = 0; i < MAXN; i++) mark[i] = 0;
reverse(tmp.begin(), tmp.end());
for (int v : tmp)
if (!mark[v]) {
cnt++;
dfs2(v);
}
for (int i = 0; i < last; i++)
if (cmp[i * 2] == cmp[i * 2 + 1]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> c[i] >> t[i];
x[i]--;
y[i]--;
adj[x[i]].push_back(i);
adj[y[i]].push_back(i);
if (e2[{c[i], x[i]}] || e2[{c[i], y[i]}]) {
cout << "No" << endl;
return 0;
}
swap(e1[{c[i], x[i]}], e2[{c[i], x[i]}]);
e1[{c[i], x[i]}] = i + 1;
swap(e1[{c[i], y[i]}], e2[{c[i], y[i]}]);
e1[{c[i], y[i]}] = i + 1;
if (e2[{c[i], x[i]}])
es.push_back({e1[{c[i], x[i]}] - 1, e2[{c[i], x[i]}] - 1});
if (e2[{c[i], y[i]}])
es.push_back({e1[{c[i], y[i]}] - 1, e2[{c[i], y[i]}] - 1});
}
if (!check(inf)) {
cout << "No" << endl;
return 0;
}
int l = -1, r = inf;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
check(r);
vector<int> ans;
for (int i = 0; i < m; i++)
if (cmp[i * 2] < cmp[i * 2 + 1]) ans.push_back(i + 1);
cout << "Yes" << endl << r << " " << (int)ans.size() << endl;
for (int i : ans) cout << i << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
const int MAXV = 6 * MAXN;
const int MAXE = 20 * MAXN;
struct Graph {
struct edge {
int to;
edge *nxt;
} edges[MAXE + 5], *adj[MAXV + 5], *ecnt;
Graph() { ecnt = edges; }
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
} G1, G2;
int n, m, cnt;
struct edge {
int u, v, c, t, id;
edge() {}
edge(int _u, int _v, int _c, int _t, int _id)
: u(_u), v(_v), c(_c), t(_t), id(_id) {}
} e[MAXN + 5];
bool cmp(const edge &a, const edge &b) { return a.t < b.t; }
int dfn[MAXV + 5], low[MAXV + 5], id[MAXV + 5];
int stk[MAXV + 5], tp, dcnt, tot;
void dfs(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool check(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs(i);
for (int i = 0; i < m; i++) {
if (id[i << 1] == id[i << 1 | 1]) return false;
}
return true;
}
vector<int> v1[MAXV + 5];
void dfs2(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs2(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
v1[tot].push_back(stk[tp]);
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool tag[MAXV + 5];
vector<int> ans;
void print(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs2(i);
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < (int)v1[i].size(); j++) {
int x = v1[i][j];
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt)
if (tag[id[p->to]]) tag[i] = true;
}
if (!tag[i]) {
for (int j = 0; j < (int)v1[i].size(); j++)
if (v1[i][j] < 2 * m) tag[id[v1[i][j] ^ 1]] = true;
}
}
for (int i = 0; i < m; i++) {
if (tag[id[i << 1]]) ans.push_back(i + 1);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
}
map<int, int> mp;
vector<edge> vec[MAXN + 5];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, c, t;
scanf("%d%d%d%d", &u, &v, &c, &t);
e[i] = edge(u, v, c, t, i);
vec[u].push_back(e[i]), vec[v].push_back(e[i]);
}
cnt = 2 * m;
for (int i = 1; i <= n; i++) {
bool flag = false;
mp.clear();
for (int j = 0; j < (int)vec[i].size(); j++) {
if (mp.count(vec[i][j].c)) {
if (flag)
puts("No"), exit(0);
else
flag = true;
int x = vec[i][j].id, y = mp[vec[i][j].c];
G1.addedge(x << 1, y << 1 | 1), G1.addedge(y << 1, x << 1 | 1);
} else
mp[vec[i][j].c] = vec[i][j].id;
}
if (vec[i].size() >= 2) {
int lst = (vec[i][0].id << 1);
for (int j = 1; j < (int)vec[i].size(); j++) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j + 1 == (int)vec[i].size()) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
lst = (vec[i][vec[i].size() - 1].id << 1);
for (int j = (int)vec[i].size() - 2; j >= 0; j--) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j == 0) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
}
}
sort(e, e + m, cmp);
if (!check(m - 1))
puts("No"), exit(0);
else
puts("Yes");
int le = -1, ri = m - 1;
while (le < ri) {
int mid = (le + ri) >> 1;
if (check(mid))
ri = mid;
else
le = mid + 1;
}
printf("%d ", le == -1 ? 0 : e[le].t), print(le);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace common {
void exit() {
cout << "No";
::exit(0);
}
} // namespace common
namespace graph {
struct edge {
int u, v, c, t;
};
vector<edge> e;
vector<int> g[50000];
void add_edge(int u, int v, int c, int t) {
g[u].push_back(e.size());
g[v].push_back(e.size());
e.push_back({u, v, c, t});
}
void init(int n, int m) {
for (int i = 0; i < m; i++) {
int u, v, c, t;
cin >> u >> v >> c >> t;
add_edge(u - 1, v - 1, c - 1, t);
}
for (int i = 0; i < n; i++)
sort(g[i].begin(), g[i].end(),
[](int a, int b) { return e[a].c < e[b].c; });
}
} // namespace graph
namespace two_sat {
vector<int> g[300000];
}
namespace tarjan {
int dfn[300000], low[300000], index, com[300000], cnt;
bool vis[300000], ins[300000];
stack<int> s;
vector<int> ch[300000];
void _init() {
memset(vis, 0x00, sizeof vis);
index = cnt = 0;
}
void dfs(int u) {
dfn[u] = low[u] = index++;
vis[u] = ins[u] = true;
s.push(u);
for (int v : two_sat::g[u]) {
if (!vis[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (ins[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
int v;
ch[cnt].clear();
do {
v = s.top();
s.pop();
ins[v] = false;
com[v] = cnt;
ch[cnt].push_back(v);
} while (u != v);
cnt++;
}
}
void solve(int n) {
_init();
for (int i = 0; i < n; i++)
if (!vis[i]) dfs(i);
}
} // namespace tarjan
namespace two_sat {
vector<int> ng[300000];
int in[300000], res[300000];
bool vis[50000];
void add_edge(int u, int v, bool fu, bool fv) {
g[u * 2 + 1 - fu].push_back(v * 2 + 1 - fv);
}
void init(int n, int m) {
for (int i = 0; i < n; i++) {
bool flag = false;
if (graph::g[i].empty()) continue;
for (int j = 0; j < graph::g[i].size(); j++) {
int x = graph::g[i][j];
int xx = vis[x] ? x + 2 * m : x + m;
add_edge(x, xx, true, true);
add_edge(xx, x, false, false);
if (j == 0) continue;
int y = graph::g[i][j - 1];
int yy = vis[y] ? y + 2 * m : y + m;
vis[xx] = vis[yy] = true;
if (graph::e[x].c == graph::e[y].c)
if (flag)
common::exit();
else {
flag = true;
add_edge(x, y, false, true);
add_edge(y, x, false, true);
}
add_edge(yy, xx, true, true);
add_edge(xx, yy, false, false);
add_edge(yy, x, true, false);
add_edge(x, yy, true, false);
}
for (int j : graph::g[i]) vis[j] = true;
}
}
void _init(int n, int mid) {
for (int i = 0; i < n; i++) ng[i].clear();
memset(in, 0x00, sizeof in);
memset(res, 0xff, sizeof res);
for (int i = 0; i < graph::e.size(); i++)
if (graph::e[i].t > mid) two_sat::add_edge(i, i, true, false);
}
void _clean(int n) {
for (int i = 0; i < n; i++)
while (!g[i].empty() && g[i].back() == (i ^ 1)) two_sat::g[i].pop_back();
}
bool check(int n, int mid) {
using tarjan::ch;
using tarjan::com;
_init(n, mid);
tarjan::solve(n);
for (int i = 0; i < n / 2; i++)
if (com[i * 2] == com[i * 2 + 1]) {
_clean(n);
return false;
}
for (int u = 0; u < n; u++)
for (int v : g[u])
if (com[u] != com[v]) {
ng[com[v]].push_back(com[u]);
in[com[u]]++;
}
queue<int> q, nq;
for (int i = 0; i < tarjan::cnt; i++)
if (in[i] == 0) {
q.push(i);
for (int j : ch[i]) nq.push(j);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : ng[u])
if (--in[v] == 0) {
q.push(v);
for (int i : ch[v]) nq.push(i);
}
}
while (!nq.empty()) {
int x = nq.front();
nq.pop();
if (res[x] != -1) continue;
for (int i : ch[com[x]]) res[i] = 1;
x ^= 1;
for (int i : ch[com[x]]) res[i] = 0;
nq.push(com[x]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : ng[u])
if (res[ch[v][0]] == -1) {
for (int i : ch[v]) res[i] = 0;
q.push(v);
}
}
}
_clean(n);
return true;
}
} // namespace two_sat
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
graph::init(n, m);
two_sat::init(n, m);
int l = 0, r = 1e9, ans = -1;
vector<int> v;
while (l <= r) {
int mid = (l + r) / 2;
if (two_sat::check(m * 6, mid)) {
ans = mid;
r = mid - 1;
v.clear();
for (int i = 0; i < m; i++)
if (two_sat::res[i * 2]) v.push_back(i);
} else
l = mid + 1;
}
if (ans == -1) common::exit();
cout << "Yes" << endl << ans << ' ' << v.size() << endl;
for (int i : v) cout << i + 1 << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
const int MXN = 50010;
const int C = 262144;
const int INF = 1000000001;
int n, czas, skla;
vector<int> G[6 * MXN], GT[6 * MXN], H[6 * MXN], vert[6 * MXN];
vector<int> pre, skl, fu;
class SAT2 {
SAT2() {}
int neg(int v1) { return (v1 + n) % (2 * n); }
void addEdge(int v1, int v2) {
G[neg(v1)].push_back(v2);
GT[v2].push_back(neg(v1));
G[neg(v2)].push_back(v1);
GT[v1].push_back(neg(v2));
}
void dfs(int x) {
pre[x] = ++czas;
for (__typeof((G[x]).begin()) it = ((G[x]).begin()); it != (G[x]).end();
++it)
if (!pre[*it]) dfs(*it);
fu.push_back(x);
}
void dfs2(int x) {
skl[x] = skla;
vert[skla].push_back(x);
for (__typeof((GT[x]).begin()) it = ((GT[x]).begin()); it != (GT[x]).end();
++it)
if (!skl[*it]) dfs2(*it);
}
void dfs3(int x) {
pre[x] = 1;
for (__typeof((H[x]).begin()) it = ((H[x]).begin()); it != (H[x]).end();
++it)
if (!pre[*it]) dfs3(*it);
fu.push_back(x);
}
public:
void clear() {
fu.clear();
pre.clear();
skl.clear();
for (int i = (0); i <= (2 * n); i++) {
G[i].clear();
GT[i].clear();
vert[i].clear();
H[i].clear();
}
}
SAT2(int _n) {
clear();
czas = 0;
skla = 0;
n = _n;
pre.resize(2 * n, 0);
skl.resize(2 * n, 0);
}
void add(int v1, bool pos1, int v2, bool pos2) {
addEdge((pos1 ? neg(v1) : v1), (pos2 ? neg(v2) : v2));
}
pair<bool, vector<bool> > solve() {
for (int i = (0); i <= (2 * n - 1); i++)
if (!pre[i]) dfs(i);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (!skl[w]) {
skla++;
dfs2(w);
}
}
skla++;
for (int i = (0); i <= (n - 1); i++)
if (skl[i] == skl[i + n]) return make_pair(false, vector<bool>());
for (int i = (0); i <= (2 * n - 1); i++) {
for (__typeof((G[i]).begin()) it = ((G[i]).begin()); it != (G[i]).end();
++it)
H[skl[i]].push_back(skl[*it]);
}
fu.clear();
pre = vector<int>(skla, 0);
for (int i = (0); i <= (skla - 1); i++)
if (!pre[i]) dfs3(i);
vector<bool> res(2 * n, 0);
vector<int> tmp(skla + 1, -1);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (tmp[w] == -1) tmp[w] = 0;
if (tmp[w] == 1)
for (__typeof((H[w]).begin()) it = ((H[w]).begin()); it != (H[w]).end();
++it)
tmp[*it] = 1;
for (__typeof((vert[w]).begin()) it = ((vert[w]).begin());
it != (vert[w]).end(); ++it) {
tmp[skl[neg(*it)]] = !tmp[w];
res[*it] = tmp[w];
res[neg(*it)] = !tmp[w];
}
}
return make_pair(true, res);
}
};
int n2, m;
vector<pair<int, pair<int, int> > > G2[MXN];
int c[MXN], t[MXN];
pair<bool, vector<bool> > check(int second) {
SAT2 SAT(3 * m);
for (int i = (0); i <= (m - 1); i++)
if (t[i] > second) SAT.add(i, 1, i, 1);
for (int i = (1); i <= (n2); i++) {
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int iter = j;
while (iter < (int)(G2[i]).size() && G2[i][j].first == G2[i][iter].first)
iter++;
if (iter - j > 2)
return make_pair(false, vector<bool>());
else if (iter - j == 2)
SAT.add(G2[i][j].second.second, 0, G2[i][j + 1].second.second, 0);
j = iter - 1;
}
int last = -1;
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int ei = G2[i][j].second.second;
int pi = ei;
if (i < G2[i][j].second.first)
pi += m;
else
pi += 2 * m;
SAT.add(pi, 1, ei, 1);
if (last != -1) {
SAT.add(ei, 1, last, 0);
SAT.add(pi, 1, last, 0);
}
last = pi;
}
}
return SAT.solve();
}
void test() {
scanf("%d %d", &n2, &m);
int mx = 0;
for (int i = (1); i <= (m); i++) {
int a, b;
scanf("%d %d %d %d", &a, &b, &c[i - 1], &t[i - 1]);
mx = max(mx, t[i - 1]);
G2[a].push_back(make_pair(c[i - 1], make_pair(b, i - 1)));
G2[b].push_back(make_pair(c[i - 1], make_pair(a, i - 1)));
}
for (int i = (1); i <= (n2); i++) sort((G2[i]).begin(), (G2[i]).end());
int res = INF;
int L = 0, R = mx;
vector<bool> ans;
while (L <= R) {
int second = (L + R) / 2;
pair<bool, vector<bool> > p1 = check(second);
if (p1.first) {
if (res > second) {
res = second;
ans = p1.second;
}
R = second - 1;
} else
L = second + 1;
}
if (res != INF) {
printf("Yes\n");
int cnt = 0;
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) cnt++;
printf("%d %d\n", res, cnt);
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) printf("%d ", i + 1);
printf("\n");
} else
printf("No\n");
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50005, M = 50005, inf = 1000000005;
template <class T>
void read(T &x) {
int sgn = 1;
char ch;
x = 0;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') ch = getchar(), sgn = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= sgn;
}
template <class T>
void write(T x) {
if (x < 0)
putchar('-'), write(-x);
else if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
struct edge {
int to, nxt, col, t;
} graph[M * 12 + N * 4];
int n, m, t_lim, head[N], cnt = 0;
void addedge(int u, int v, int col, int t) {
edge e = {v, head[u], col, t};
graph[head[u] = cnt++] = e;
}
int dfn[M * 12 + N * 4], low[M * 12 + N * 4], scc[M * 12 + N * 4],
tot = 0, now = 0, t = 0;
vector<int> g[M * 12 + N * 4];
stack<int> stk;
bool vis[M * 12 + N * 4], flag = true;
void dfs(int u) {
dfn[u] = low[u] = ++now;
stk.push(u), vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!dfn[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (u < (m << 1) && graph[u].t > t_lim && (u & 1)) {
int v = u ^ 1;
if (!dfn[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
t++;
for (;;) {
int v = stk.top();
vis[v] = false;
stk.pop(), scc[v] = t;
if (v == u) break;
}
}
}
bool check() {
for (int i = 0; i < tot; i++) dfn[i << 1] = dfn[i << 1 | 1] = 0;
for (int i = 0; i < tot; i++) {
if (!dfn[i << 1]) dfs(i << 1);
if (!dfn[i << 1 | 1]) dfs(i << 1 | 1);
}
for (int i = 0; i < tot; i++) {
if (scc[i << 1] == scc[i << 1 | 1]) return false;
}
return flag;
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) head[i] = -1;
for (int i = 0; i < m; i++) {
int u, v, c, t;
read(u), read(v), read(c), read(t);
addedge(u, v, c, t), addedge(v, u, c, t);
}
tot = m;
for (int i = 1; i <= n; i++) {
int total = 0, e1, e2;
vector<int> adj;
map<int, int> id;
for (int j = head[i]; ~j; j = graph[j].nxt) {
if (id[graph[j].col]) {
e1 = id[graph[j].col], e2 = j;
total++;
}
id[graph[j].col] = j, adj.push_back(j);
}
if (total > 1)
flag = false;
else if (total) {
for (int j = head[i]; ~j; j = graph[j].nxt) {
if (j != e1 && j != e2) g[j ^ (j & 1) ^ 1].push_back(j ^ (j & 1));
}
g[e1 ^ (e1 & 1)].push_back(e2 ^ (e2 & 1) ^ 1);
g[e2 ^ (e2 & 1)].push_back(e1 ^ (e1 & 1) ^ 1);
g[e1 ^ (e1 & 1) ^ 1].push_back(e2 ^ (e2 & 1));
g[e2 ^ (e2 & 1) ^ 1].push_back(e1 ^ (e1 & 1));
} else {
int s = adj.size();
vector<int> pre, suf;
pre.push_back(tot++);
for (int j = 0; j < s; j++) {
pre.push_back(tot);
g[adj[j] ^ (adj[j] & 1) ^ 1].push_back(tot << 1 | 1);
g[tot << 1].push_back(adj[j] ^ (adj[j] & 1));
g[pre[j] << 1 | 1].push_back(tot << 1 | 1);
g[tot << 1].push_back(pre[j] << 1);
tot++;
}
suf.push_back(tot++);
for (int j = s - 1; j >= 0; j--) {
suf.push_back(tot);
g[adj[j] ^ (adj[j] & 1) ^ 1].push_back(tot << 1 | 1);
g[tot << 1].push_back(adj[j] ^ (adj[j] & 1));
g[suf[s - j] << 1 | 1].push_back(tot << 1 | 1);
g[tot << 1].push_back(suf[s - j] << 1);
tot++;
}
for (int j = 0; j < s; j++) {
g[adj[j] ^ (adj[j] & 1) ^ 1].push_back(pre[j] << 1);
g[pre[j] << 1 | 1].push_back(adj[j] ^ (adj[j] & 1));
g[adj[j] ^ (adj[j] & 1) ^ 1].push_back(suf[s - 1 - j] << 1);
g[suf[s - 1 - j] << 1 | 1].push_back(adj[j] ^ (adj[j] & 1));
}
}
}
int l = 0, r = inf;
while (l < r) {
int mid = l + r >> 1;
t_lim = mid, now = t = 0;
if (check())
r = mid;
else
l = mid + 1;
}
if (l >= inf)
puts("No");
else {
int total = 0;
t_lim = l, check();
for (int i = 0; i < m; i++) {
if (scc[i << 1 | 1] < scc[i << 1]) total++;
}
puts("Yes");
write(l), putchar(' ');
write(total), putchar('\n');
for (int i = 0; i < m; i++) {
if (scc[i << 1 | 1] < scc[i << 1]) write(i + 1), putchar(' ');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const int inf = 1e9;
long long int linf = 1000000ll * 10000 * 10000;
const int maxn = 3e5 + 20;
const int maxfn = 5e4 + 20;
int kmch = 15e4 + 5, V, n, m, psb;
vector<int> sat_adj[2][maxn], vec[maxn], cl, ans, comp;
vector<pair<pair<int, int>, pair<int, int> > > adj[maxfn], E;
stack<int> stk;
int bag[maxn], mark[maxn];
void pre_dfs(int v) {
mark[v] = 1;
for (int u : sat_adj[0][v]) {
if (!mark[u]) {
pre_dfs(u);
}
}
stk.push(v);
}
void dfs(int v, int id) {
mark[v] = 1;
bag[v] = id;
for (int u : sat_adj[1][v]) {
if (!mark[u]) {
dfs(u, id);
}
}
}
inline int var(int x) {
if (x >= kmch) {
x -= kmch;
} else {
x += kmch;
}
return x;
}
inline void make_condition(int v, int u) {
sat_adj[0][var(u)].push_back(v);
if (u != v) sat_adj[0][var(v)].push_back(u);
sat_adj[1][v].push_back(var(u));
if (u != v) sat_adj[1][u].push_back(var(v));
}
inline bool is_posbl() {
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= V; i++) {
if (!mark[i]) {
pre_dfs(i);
}
if (!mark[var(i)]) {
pre_dfs(var(i));
}
}
memset(mark, 0, sizeof(mark));
int cnt = 0;
while (!stk.empty()) {
int v = stk.top();
stk.pop();
if (!mark[v]) {
dfs(v, cnt++);
}
}
for (int i = 1; i <= V; i++) {
if (bag[i] == bag[var(i)]) {
return false;
}
}
return true;
}
inline void set_condition(int x) {
for (int i = 1; i <= V; i++) {
sat_adj[0][i].clear();
sat_adj[0][var(i)].clear();
sat_adj[1][i].clear();
sat_adj[1][var(i)].clear();
}
int ind = 0;
for (auto P : E) {
ind++;
if (P.first.first > x) {
make_condition(ind, ind);
}
}
ind = 0;
for (int i = 1; i <= n; i++) {
bool is_first = 1;
int j = 0;
for (auto P : adj[i]) {
ind++;
int pos =
lower_bound(comp.begin(), comp.end(), P.second.second) - comp.begin();
vec[pos].push_back(P.first.second);
cl.push_back(pos);
if (j + 1 != adj[i].size()) {
make_condition(m + ind + 1, P.first.second);
}
make_condition(P.first.second, var(m + ind));
if (is_first) {
is_first = 0;
j++;
continue;
}
make_condition(var(m + ind - 1), m + ind);
j++;
}
sort(cl.begin(), cl.end());
cl.resize(unique(cl.begin(), cl.end()) - cl.begin());
for (int j : cl) {
if (psb == -1) {
vec[j].clear();
continue;
}
if (vec[j].size() >= 3) {
psb = -1;
}
if (vec[j].size() <= 1) {
vec[j].clear();
continue;
}
make_condition(var(vec[j][0]), var(vec[j][1]));
vec[j].clear();
}
cl.clear();
if (psb == -1) return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
V = 3 * m;
for (int i = 0; i < m; i++) {
int u, v, c, t;
cin >> u >> v >> c >> t;
comp.push_back(c);
E.push_back({{t, c}, {u, v}});
adj[v].push_back({{u, i + 1}, {t, c}});
adj[u].push_back({{v, i + 1}, {t, c}});
}
sort(comp.begin(), comp.end());
comp.resize(unique(comp.begin(), comp.end()) - comp.begin());
int l = -1, r = mod;
while (r - l > 1) {
psb = 0;
int mid = (l + r) >> 1;
set_condition(mid);
if (psb == -1) {
l = mid;
continue;
}
if (is_posbl()) {
r = mid;
} else {
l = mid;
}
}
if (r == mod) {
cout << "No";
return 0;
}
cout << "Yes\n";
set_condition(r);
is_posbl();
for (int i = 1; i <= m; i++) {
if (bag[i] < bag[var(i)]) {
ans.push_back(i);
}
}
cout << r << " " << ans.size() << "\n";
for (int i : ans) {
cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 311111, inf = 1111111111;
int n, m, cnt, u[max_n], v[max_n], c[max_n], t[max_n], a[max_n], b[max_n],
no[max_n], res[max_n], used[max_n];
vector<int> g[max_n], p[max_n], g2[max_n], rg2[max_n], ans, tp;
vector<pair<int, int> > q[max_n];
void add_edge(int a, int b) {
g2[no[a]].push_back(b);
g2[no[b]].push_back(a);
rg2[b].push_back(no[a]);
rg2[a].push_back(no[b]);
}
void dfs1(int v) {
used[v] = 1;
for (int i = 0; i < g2[v].size(); ++i) {
if (used[g2[v][i]] == 0) {
dfs1(g2[v][i]);
}
}
tp.push_back(v);
}
void dfs2(int v, int cl) {
used[v] = cl;
for (int i = 0; i < rg2[v].size(); ++i) {
if (used[rg2[v][i]] == 0) {
dfs2(rg2[v][i], cl);
}
}
}
bool ok() {
tp.clear();
memset(used, 0, sizeof(used));
for (int i = 0; i < cnt; ++i) {
if (used[i] == 0) {
dfs1(i);
}
}
reverse(tp.begin(), tp.end());
int cl = 0;
memset(used, 0, sizeof(used));
for (int i = 0; i < tp.size(); ++i) {
if (used[tp[i]] == 0) {
++cl;
dfs2(tp[i], cl);
}
}
for (int i = 0; i < cnt; ++i) {
if (used[i] == used[no[i]]) {
return false;
}
res[i] = 0;
if (used[i] > used[no[i]]) {
res[i] = 1;
}
}
return true;
}
bool check(int tt) {
for (int i = 0; i < max_n; ++i) {
g2[i].clear();
rg2[i].clear();
}
for (int i = 0; i < m; ++i) {
if (t[i] > tt) {
add_edge(no[i], no[i]);
}
}
for (int i = 1; i <= n; ++i) {
if (a[i] != -1) {
add_edge(a[i], b[i]);
}
for (int j = 0; j < g[i].size(); ++j) {
add_edge(no[g[i][j]], p[i][j]);
if (j + 1 < g[i].size()) {
add_edge(no[p[i][j]], p[i][j + 1]);
add_edge(no[p[i][j]], no[g[i][j + 1]]);
}
}
}
return ok();
}
int main() {
scanf("%d%d", &n, &m);
int l = -1, r = 0;
for (int i = 0; i < m; ++i) {
no[i] = m + i;
no[m + i] = i;
scanf("%d%d%d%d", &u[i], &v[i], &c[i], &t[i]);
q[u[i]].push_back(make_pair(c[i], i));
q[v[i]].push_back(make_pair(c[i], i));
g[u[i]].push_back(i);
g[v[i]].push_back(i);
r = max(r, t[i]);
}
cnt = 2 * m;
for (int i = 1; i <= n; ++i) {
sort(q[i].begin(), q[i].end());
a[i] = b[i] = -1;
for (int j = 0; j < q[i].size(); ++j) {
int poz = j;
while (poz < q[i].size() && q[i][j].first == q[i][poz].first) {
++poz;
}
--poz;
if (poz - j + 1 > 2) {
printf("No\n");
return 0;
}
if (poz - j + 1 == 2) {
if (a[i] == -1) {
a[i] = q[i][j].second;
b[i] = q[i][j + 1].second;
} else {
printf("No\n");
return 0;
}
}
}
for (int j = 0; j < g[i].size(); ++j) {
p[i].push_back(cnt);
++cnt;
}
}
for (int i = 2 * m; i < cnt; ++i) {
no[i] = cnt + i - 2 * m;
no[cnt + i - 2 * m] = i;
}
int kr = r;
++r;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (r == kr) {
printf("No\n");
return 0;
}
printf("Yes\n");
check(r);
for (int i = 0; i < m; ++i) {
if (res[i]) {
ans.push_back(i + 1);
}
}
printf("%d %d\n", r, ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int v[50101], u[50101];
int c[50101], t[50101];
vector<pair<int, int>> sgr[301010][2];
map<int, int> gr[50101];
int pred[50101];
int vis[301010][2];
int ind;
int ord[301010];
int chk[301010];
const int INF = 1010101010;
int dfs(int x, int sty, int ti, int tmp = 1) {
if (vis[x][sty]) return 1;
vis[x][sty] = tmp;
if (sty) {
if (vis[(x + 3 * m) % (6 * m)][sty] == tmp) return 0;
if (x < 3 * m)
chk[x % (3 * m)] = 1;
else
chk[x % (3 * m)] = 2;
}
for (auto y : sgr[x][sty]) {
if (y.second > ti) {
if (!dfs(y.first, sty, ti, tmp)) {
return 0;
}
}
}
if (!sty) ord[ind++] = x;
return 1;
}
int check(int ti) {
for (int i = 0; i < 6 * m; i++) {
chk[i] = 0;
for (int j = 0; j < 2; j++) vis[i][j] = 0;
}
ind = 0;
for (int i = 6 * m - 1; i >= 0; i--) dfs(i, 0, ti);
for (int i = 6 * m - 1; i >= 0; i--) {
if (!dfs(ord[i], 1, ti, i + 1)) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int fail = 0;
for (int i = 0; i < m; i++) {
cin >> v[i] >> u[i] >> c[i] >> t[i];
if (gr[v[i]].count(c[i]))
gr[v[i]][c[i]]++;
else
gr[v[i]][c[i]] = 1;
if (gr[u[i]].count(c[i]))
gr[u[i]][c[i]]++;
else
gr[u[i]][c[i]] = 1;
if (max(gr[v[i]][c[i]], gr[u[i]][c[i]]) > 2) fail = 1;
}
if (fail) {
cout << "No\n";
return 0;
}
for (int i = 1; i <= n; i++) gr[i].clear();
for (int i = 0; i < m; i++) {
if (gr[v[i]].count(c[i])) {
int j = gr[v[i]][c[i]];
sgr[i + 3 * m][0].push_back(make_pair(j, INF));
sgr[j + 3 * m][0].push_back(make_pair(i, INF));
sgr[i][1].push_back(make_pair(j + 3 * m, INF));
sgr[j][1].push_back(make_pair(i + 3 * m, INF));
} else
gr[v[i]][c[i]] = i;
if (gr[u[i]].count(c[i])) {
int j = gr[u[i]][c[i]];
sgr[i + 3 * m][0].push_back(make_pair(j, INF));
sgr[j + 3 * m][0].push_back(make_pair(i, INF));
sgr[i][1].push_back(make_pair(j + 3 * m, INF));
sgr[j][1].push_back(make_pair(i + 3 * m, INF));
} else
gr[u[i]][c[i]] = i;
}
for (int i = 0; i < m; i++) {
sgr[i][0].push_back(make_pair(i + 3 * m, t[i]));
sgr[i + 3 * m][1].push_back(make_pair(i, t[i]));
int hlp = m + 2 * i;
sgr[i][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(i + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
if (pred[v[i]]) {
int j = pred[v[i]];
sgr[j][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(j + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(j, INF));
sgr[j + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
sgr[i][0].push_back(make_pair(j + 3 * m, INF));
sgr[j][0].push_back(make_pair(i + 3 * m, INF));
sgr[j + 3 * m][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(j, INF));
}
pred[v[i]] = hlp;
hlp++;
sgr[i][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(i + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
if (pred[u[i]]) {
int j = pred[u[i]];
sgr[j][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(j + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(j, INF));
sgr[j + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
sgr[i][0].push_back(make_pair(j + 3 * m, INF));
sgr[j][0].push_back(make_pair(i + 3 * m, INF));
sgr[j + 3 * m][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(j, INF));
}
pred[u[i]] = hlp;
}
int ala = 0;
int yla = INF;
while (ala < yla) {
int mid = (ala + yla) / 2;
if (check(mid))
yla = mid;
else
ala = mid + 1;
}
if (!check(yla) || yla >= INF) {
cout << "No\n";
} else {
cout << "Yes\n";
cout << yla << " ";
int cntr = 0;
for (int i = 0; i < m; i++) {
if (chk[i] == 1) cntr++;
}
cout << cntr << "\n";
for (int i = 0; i < m; i++) {
if (chk[i] == 1) cout << i + 1 << " ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
const int MXN = 6 * 50010;
const int C = 262144;
const int INF = 1000000001;
namespace SAT2 {
vector<int> G[MXN], GT[MXN];
int pre[MXN], skl[MXN];
vector<int> fu;
class SAT2 {
SAT2() {}
int n, czas, skla;
int neg(int v1) { return (v1 + n) % (2 * n); }
void addEdge(int v1, int v2) {
G[neg(v1)].push_back(v2);
GT[v2].push_back(neg(v1));
G[neg(v2)].push_back(v1);
GT[v1].push_back(neg(v2));
}
void dfs(int x) {
pre[x] = ++czas;
for (__typeof((G[x]).begin()) it = ((G[x]).begin()); it != (G[x]).end();
++it)
if (!pre[*it]) dfs(*it);
fu.push_back(x);
}
void dfs2(int x) {
skl[x] = skla;
for (__typeof((GT[x]).begin()) it = ((GT[x]).begin()); it != (GT[x]).end();
++it)
if (!skl[*it]) dfs2(*it);
}
void clear() {
fu.clear();
for (int i = (0); i <= (2 * n); i++) pre[i] = skl[i] = 0;
for (int i = (0); i <= (2 * n); i++) {
G[i].clear();
GT[i].clear();
}
}
public:
SAT2(int _n) {
czas = 0;
skla = 0;
n = _n;
}
void add(int v1, bool pos1, int v2, bool pos2) {
addEdge((pos1 ? neg(v1) : v1), (pos2 ? neg(v2) : v2));
}
pair<bool, vector<bool> > solve() {
for (int i = (0); i <= (2 * n - 1); i++)
if (!pre[i]) dfs(i);
for (int i = ((int)(fu).size() - 1); i >= (0); i--) {
int w = fu[i];
if (!skl[w]) {
skla++;
dfs2(w);
}
}
skla++;
for (int i = (0); i <= (n - 1); i++)
if (skl[i] == skl[i + n]) {
clear();
return make_pair(false, vector<bool>());
}
vector<bool> res(2 * n, 0);
for (int i = (0); i <= (n - 1); i++) {
if (skl[i] < skl[neg(i)])
res[neg(i)] = 1;
else
res[i] = 1;
}
clear();
return make_pair(true, res);
}
};
} // namespace SAT2
int n2, m;
vector<pair<int, pair<int, int> > > G2[MXN];
int c[MXN], t[MXN];
pair<bool, vector<bool> > check(int second) {
SAT2::SAT2 SAT(3 * m);
for (int i = (0); i <= (m - 1); i++)
if (t[i] > second) SAT.add(i, 1, i, 1);
for (int i = (1); i <= (n2); i++) {
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int iter = j;
while (iter < (int)(G2[i]).size() && G2[i][j].first == G2[i][iter].first)
iter++;
if (iter - j > 2)
return make_pair(false, vector<bool>());
else if (iter - j == 2)
SAT.add(G2[i][j].second.second, 0, G2[i][j + 1].second.second, 0);
j = iter - 1;
}
int last = -1;
for (int j = (0); j <= ((int)(G2[i]).size() - 1); j++) {
int ei = G2[i][j].second.second;
int pi = ei;
if (i < G2[i][j].second.first)
pi += m;
else
pi += 2 * m;
SAT.add(pi, 1, ei, 1);
if (last != -1) {
SAT.add(ei, 1, last, 0);
SAT.add(pi, 1, last, 0);
}
last = pi;
}
}
return SAT.solve();
}
void test() {
scanf("%d %d", &n2, &m);
int mx = 0;
for (int i = (1); i <= (m); i++) {
int a, b;
scanf("%d %d %d %d", &a, &b, &c[i - 1], &t[i - 1]);
mx = max(mx, t[i - 1]);
G2[a].push_back(make_pair(c[i - 1], make_pair(b, i - 1)));
G2[b].push_back(make_pair(c[i - 1], make_pair(a, i - 1)));
}
for (int i = (1); i <= (n2); i++) sort((G2[i]).begin(), (G2[i]).end());
int res = INF;
int L = 0, R = mx;
vector<bool> ans;
while (L <= R) {
int second = (L + R) / 2;
pair<bool, vector<bool> > p1 = check(second);
if (p1.first) {
if (res > second) {
res = second;
ans = p1.second;
}
R = second - 1;
} else
L = second + 1;
}
if (res != INF) {
printf("Yes\n");
int cnt = 0;
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) cnt++;
printf("%d %d\n", res, cnt);
for (int i = (0); i <= (m - 1); i++)
if (ans[i]) printf("%d ", i + 1);
printf("\n");
} else
printf("No\n");
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
long long pw(long long a, long long b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret = (ret * mul);
mul = (mul * mul);
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
const int MAXN = 5e4 + 54;
struct ed {
int s, e, c, l, st;
};
int n, m, cnt[MAXN], d2[MAXN];
ed e[MAXN];
vector<int> adj[MAXN], ce[MAXN], cs;
int par[MAXN], rnk[MAXN], pr[MAXN];
pair<int, int> get(int v) {
if (par[v] != v) {
pair<int, int> tmp = get(par[v]);
par[v] = tmp.first, pr[v] ^= tmp.second;
}
return {par[v], pr[v]};
}
bool uni(int a, int b) {
pair<int, int> aa = get(a), bb = get(b);
if (aa.first == bb.first and aa.second == bb.second) return 0;
if (aa.first == bb.first) return 1;
par[bb.first] = aa.first;
rnk[aa.first] += (rnk[aa.first] == rnk[bb.first]);
pr[bb.first] ^= aa.second ^ bb.second ^ 1;
return 1;
}
bool stst(int id, int st) {
if (st == 1) {
if (e[id].st == 0) return 0;
if (e[id].st == 1) return 1;
e[id].st = 1;
int u = e[id].s, v = e[id].e, c = e[id].c;
if (d2[u] == c) {
for (int cid : adj[u]) {
if (cid == id) continue;
if (e[cid].c == c) {
if (!stst(cid, 0)) return 0;
}
}
}
if (d2[v] == c) {
for (int cid : adj[v]) {
if (cid == id) continue;
if (e[cid].c == c) {
if (!stst(cid, 0)) return 0;
}
}
}
} else {
if (e[id].st == 1) return 0;
if (e[id].st == 0) return 1;
e[id].st = 0;
int u = e[id].s, v = e[id].e, c = e[id].c;
for (int cid : adj[u]) {
if (cid == id) continue;
if (!stst(cid, 1)) return 0;
}
for (int cid : adj[v]) {
if (cid == id) continue;
if (!stst(cid, 1)) return 0;
}
}
return 1;
}
bool chk(int M) {
for (int(i) = (0); (i) < (m); (i)++) e[i].st = -1;
for (int(i) = (0); (i) < (m); (i)++) {
if (e[i].l > M)
if (!stst(i, 1)) return 0;
}
for (int(v) = (0); (v) < (n); (v)++) {
if (d2[v]) {
for (int id : adj[v]) {
if (e[id].c != d2[v])
if (!stst(id, 1)) return 0;
}
}
}
for (int(v) = (0); (v) < (n); (v)++) {
if (d2[v]) continue;
for (int id : adj[v]) {
if (e[id].st == -1) {
if (!stst(id, 1)) return 0;
}
}
}
for (int(v) = (0); (v) < (n); (v)++) {
if (d2[v]) {
for (int id : adj[v]) {
if (e[id].c == d2[v]) {
stst(id, 1);
break;
}
}
}
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
for (int(i) = (0); (i) < (MAXN); (i)++) par[i] = i;
cin >> n >> m;
for (int(i) = (0); (i) < (m); (i)++) {
cin >> e[i].s >> e[i].e >> e[i].c >> e[i].l;
e[i].s--, e[i].e--;
cs.push_back(e[i].c);
adj[e[i].s].push_back(i), adj[e[i].e].push_back(i);
}
sort((cs).begin(), (cs).end());
cs.resize(unique((cs).begin(), (cs).end()) - cs.begin());
for (int(i) = (0); (i) < (m); (i)++)
e[i].c = lower_bound((cs).begin(), (cs).end(), e[i].c) - cs.begin() + 1,
ce[e[i].c].push_back(i);
bool fl = 1;
for (int(i) = (1); (i) < (MAXN); (i)++) {
for (int id : ce[i]) {
cnt[e[id].s]++;
cnt[e[id].e]++;
fl &= uni(e[id].s, e[id].e);
}
for (int id : ce[i]) {
par[e[id].s] = e[id].s, par[e[id].e] = e[id].e;
rnk[e[id].s] = pr[e[id].s] = rnk[e[id].e] = pr[e[id].e] = 0;
fl &= (cnt[e[id].s] <= 2) & (cnt[e[id].e] <= 2) &
(cnt[e[id].s] < 2 or !d2[e[id].s]) &
(cnt[e[id].e] < 2 or !d2[e[id].e]);
if (cnt[e[id].s] >= 2) d2[e[id].s] = i;
if (cnt[e[id].e] >= 2) d2[e[id].e] = i;
cnt[e[id].s] = cnt[e[id].e] = 0;
}
if (!fl) break;
}
if (!fl) {
cout << "No"
<< "\n";
return 0;
}
int l = -1, r = 1e9 + 19;
while (r - l > 1) {
int M = (l + r) / 2;
if (chk(M))
r = M;
else
l = M;
}
if (r >= 1e9)
cout << "No"
<< "\n";
else {
chk(r);
int ans = 0;
for (int(i) = (0); (i) < (m); (i)++) ans += (e[i].st == 0);
cout << "Yes"
<< "\n"
<< r << " " << ans << "\n";
for (int(i) = (0); (i) < (m); (i)++)
if (!e[i].st) cout << i + 1 << " ";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
int MOD = int(1e9) + 7;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void dec(int &a, int b) { a = sub(a, b); }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
using namespace std;
const int MAX = 50005;
vector<int> edges[MAX];
int from[MAX], to[MAX], color[MAX], cost[MAX];
bool cmp(int x, int y) { return (color[x] < color[y]); }
vector<pair<int, int> > bads;
vector<int> adj[8 * MAX], tmp[8 * MAX];
int n, m, sz;
void init() {
for (int i = 0; i < 8 * MAX; i++) adj[i].clear();
for (int i = 0; i < (int)bads.size(); i++) {
int id1 = bads[i].first, id2 = bads[i].second;
adj[2 * id1].push_back(2 * id2 + 1);
adj[2 * id2].push_back(2 * id1 + 1);
}
sz = m;
for (int v = 0; v < n; v++)
if (!edges[v].empty()) {
int last = edges[v][0];
for (int i = 1; i < (int)edges[v].size(); i++) {
int id = edges[v][i];
adj[2 * last + 1].push_back(2 * id);
adj[2 * id + 1].push_back(2 * last);
adj[2 * id + 1].push_back(2 * sz + 1);
adj[2 * sz].push_back(2 * id);
adj[2 * last + 1].push_back(2 * sz + 1);
adj[2 * sz].push_back(2 * last);
last = sz++;
}
}
}
vector<int> tp;
bool mark[8 * MAX];
void dfs(int v) {
mark[v] = true;
for (int i = 0; i < (int)adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) dfs(u);
}
tp.push_back(v);
}
int cc[8 * MAX];
void sfd(int v, int col) {
mark[v] = true;
cc[v] = col;
for (int i = 0; i < (int)adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) sfd(u, col);
}
}
vector<int> ans;
bool check(int lim) {
init();
sz *= 2;
for (int i = 0; i < m; i++)
if (cost[i] > lim) adj[2 * i + 1].push_back(2 * i);
memset(mark, false, sizeof(mark));
tp.clear();
for (int i = 0; i < sz; i++)
if (!mark[i]) dfs(i);
reverse(tp.begin(), tp.end());
for (int i = 0; i < sz; i++) tmp[i].clear();
for (int v = 0; v < sz; v++)
for (int i = 0; i < (int)adj[v].size(); i++) tmp[adj[v][i]].push_back(v);
for (int i = 0; i < sz; i++) adj[i] = tmp[i];
int cnt = 0;
memset(mark, false, sizeof(mark));
for (int i = 0; i < (int)tp.size(); i++)
if (!mark[tp[i]]) sfd(tp[i], cnt++);
ans.clear();
for (int i = 0; i < sz / 2; i++) {
if (cc[2 * i] == cc[2 * i + 1]) return false;
if (i < m && cc[2 * i] < cc[2 * i + 1]) ans.push_back(i);
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
vector<int> vals;
vals.push_back(0);
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i] >> color[i] >> cost[i];
vals.push_back(cost[i]);
from[i]--;
to[i]--;
edges[from[i]].push_back(i);
edges[to[i]].push_back(i);
}
for (int v = 0; v < n; v++) {
sort(edges[v].begin(), edges[v].end(), cmp);
int cnt = 0;
for (int i = 0; i < (int)edges[v].size(); i++) {
int j = i + 1;
while (j < (int)edges[v].size() &&
color[edges[v][j - 1]] == color[edges[v][j]])
j++;
if (j - i > 2) {
cout << "No\n";
return 0;
}
if (j - i == 2) {
cnt++;
if (cnt == 2) {
cout << "No\n";
return 0;
}
bads.push_back(make_pair(edges[v][i], edges[v][i + 1]));
i++;
}
}
}
sort(vals.begin(), vals.end());
vals.resize(unique(vals.begin(), vals.end()) - vals.begin());
int l = -1, r = (int)vals.size();
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(vals[mid]))
r = mid;
else
l = mid;
}
if (r == (int)vals.size()) {
cout << "No\n";
return 0;
}
check(vals[r]);
cout << "Yes\n";
cout << vals[r] << " " << ans.size() << "\n";
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] + 1 << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 100;
int n, m, U[MAXN], V[MAXN], c[MAXN], t[MAXN];
int res[MAXN];
map<int, int> mp;
vector<int> adj[MAXN], in[MAXN], out[MAXN], vec;
bool mark[MAXN], is[MAXN];
void dfs(int u) {
mark[u] = true;
for (int i = 0; i < out[u].size(); i++) {
int v = out[u][i];
if (!mark[v]) dfs(v);
}
vec.push_back(u);
}
void dfs2(int u, int cc) {
res[u] = cc;
for (int i = 0; i < in[u].size(); i++) {
int v = in[u][i];
if (res[v] == -1) dfs2(v, cc);
}
}
inline void add_e(int a, int b) {
out[a ^ 1].push_back(b);
in[b].push_back(a ^ 1);
out[b ^ 1].push_back(a);
in[a].push_back(b ^ 1);
}
bool ok(int mid) {
int C = m;
for (int i = 0; i < MAXN; i++) {
in[i].clear(), out[i].clear();
mark[i] = is[i] = 0;
res[i] = -1;
}
vec.clear();
for (int i = 0; i < n; i++) {
mp.clear();
int cur = -1;
for (int j = 0; j < adj[i].size(); j++) {
int id = adj[i][j];
if (cur == -1)
cur = id;
else {
add_e(2 * cur + 1, 2 * id + 1);
add_e(2 * cur + 1, 2 * C);
add_e(2 * id + 1, 2 * C);
cur = C;
C++;
}
if (!mp[c[id]])
mp[c[id]] = id + 1;
else if (mp[c[id]] == -1)
return false;
else
add_e(2 * (mp[c[id]] - 1), 2 * id), mp[c[id]] = -1;
}
}
for (int i = 0; i < m; i++)
if (t[i] > mid)
out[2 * i].push_back(2 * i + 1), in[2 * i + 1].push_back(2 * i);
for (int i = 0; i < 2 * C; i++)
if (!mark[i]) dfs(i);
int cnt = 0;
for (int i = 2 * C - 1; i >= 0; i--) {
if (res[vec[i]] == -1) dfs2(vec[i], cnt++);
}
for (int i = 0; i < 2 * C; i += 2) {
if (res[i] == res[i + 1])
return false;
else if (res[i] > res[i + 1])
is[i / 2] = true;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> U[i] >> V[i] >> c[i] >> t[i], V[i]--, U[i]--;
adj[V[i]].push_back(i), adj[U[i]].push_back(i);
}
int l = -1, r = INT_MAX / 2 + 10;
while (r - l > 1) {
int mid = (r + l) / 2;
if (ok(mid))
r = mid;
else
l = mid;
}
if (r >= INT_MAX / 2 + 5) return cout << "No" << endl, 0;
ok(r);
cout << "Yes" << endl;
int ans = 0;
for (int i = 0; i < m; i++)
if (is[i]) ans++;
cout << r << " " << ans << endl;
for (int i = 0; i < m; i++)
if (is[i]) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
int to, col, time, ind;
E(int to, int col, int time, int ind)
: to(to), col(col), time(time), ind(ind) {}
};
int n, m, cnt;
vector<E> g[50000];
int a[50000], b[50000], c[50000], d[50000], t[50000];
map<int, pair<int, int> > colInd;
const int INF = 1e9 + 99;
vector<int> sat[311111], rev[311111], tmp[311111], ord;
bool used[311111];
int cmp[311111], curCmp;
void dfs1(int v) {
used[v] = true;
for (int to : sat[v])
if (!used[to]) {
dfs1(to);
}
ord.push_back(v);
}
void dfs2(int v) {
cmp[v] = curCmp;
for (int to : rev[v])
if (cmp[to] == -1) {
dfs2(to);
}
}
bool solve(int bound) {
for (int i = 0; i < (int)(cnt << 1); ++i) sat[i] = tmp[i];
for (int i = 0; i < (int)(m); ++i)
if (t[i] > bound) {
sat[i << 1].push_back((i << 1) | 1);
}
for (int i = 0; i < (int)(cnt << 1); ++i) rev[i].clear();
for (int i = 0; i < (int)(cnt << 1); ++i)
for (int to : sat[i]) {
rev[to].push_back(i);
}
for (int i = 0; i < (int)(cnt << 1); ++i) used[i] = false;
ord.clear();
for (int i = 0; i < (int)(cnt << 1); ++i)
if (!used[i]) {
dfs1(i);
}
reverse(ord.begin(), ord.end());
for (int i = 0; i < (int)(cnt << 1); ++i) cmp[i] = -1;
curCmp = 0;
for (int i : ord)
if (cmp[i] == -1) {
dfs2(i);
++curCmp;
}
for (int i = 0; i < (int)(cnt); ++i)
if (cmp[i << 1] == cmp[(i << 1) | 1]) {
return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(m); ++i) {
int from, to, c, tt;
scanf("%d%d%d%d", &from, &to, &c, &tt), --from, --to;
g[from].push_back(E(to, c, tt, i));
g[to].push_back(E(from, c, tt, i));
t[i] = tt;
}
for (int i = 0; i < (int)(n); ++i) {
a[i] = -1;
for (E e : g[i]) {
auto it = colInd.find(e.col);
if (it != colInd.end()) {
if (a[i] != -1) {
printf("No\n");
return 0;
}
a[i] = it->second.first;
b[i] = e.ind;
c[i] = it->second.second;
d[i] = e.time;
} else {
colInd[e.col] = make_pair(e.ind, e.time);
}
}
colInd.clear();
}
int lo = 0, hi = 0, mid;
for (int i = 0; i < (int)(n); ++i)
if (a[i] != -1) {
lo = max(lo, min(c[i], d[i]));
hi = max(hi, max(c[i], d[i]));
}
if (hi == 0) {
printf("Yes\n0 0\n");
return 0;
}
cnt = m;
for (int i = 0; i < (int)(n); ++i)
if ((int)g[i].size() > 1) {
for (int j = 0; j < (int)((int)g[i].size() - 1); ++j) {
tmp[g[i][j].ind << 1].push_back((cnt + j) << 1);
tmp[((cnt + j) << 1) | 1].push_back((g[i][j].ind << 1) | 1);
}
for (int j = 0; j < (int)((int)g[i].size() - 2); ++j) {
tmp[(cnt + j) << 1].push_back((cnt + j + 1) << 1);
tmp[((cnt + j + 1) << 1) | 1].push_back(((cnt + j) << 1) | 1);
}
for (int j = 1; j < (int)g[i].size(); ++j) {
tmp[g[i][j].ind << 1].push_back(((cnt + j - 1) << 1) | 1);
tmp[(cnt + j - 1) << 1].push_back((g[i][j].ind << 1) | 1);
}
cnt += (int)g[i].size() - 1;
}
for (int i = 0; i < (int)(n); ++i)
if (a[i] != -1) {
tmp[(a[i] << 1) | 1].push_back(b[i] << 1);
tmp[(b[i] << 1) | 1].push_back(a[i] << 1);
}
while (lo < hi) {
mid = (lo + hi) >> 1;
if (solve(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
if (solve(lo)) {
printf("Yes\n");
vector<int> ans;
for (int i = 0; i < (int)(m); ++i)
if (cmp[(i << 1) | 1] < cmp[i << 1]) {
ans.push_back(i);
}
printf("%d %d\n", lo, (int)ans.size());
for (int x : ans) printf("%d ", x + 1);
printf("\n");
} else {
printf("No\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int V;
vector<int> G[400100];
vector<int> rG[400100];
vector<int> vs;
bool used[400100];
int cmp[400100];
void clear_graph() {
for (int i = 0; i < 400100; i++) {
G[i].clear();
rG[i].clear();
}
vs.clear();
}
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
if (!used[G[v][i]]) dfs(G[v][i]);
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (int i = 0; i < rG[v].size(); i++) {
if (!used[rG[v][i]]) rdfs(rG[v][i], k);
}
}
void scc() {
memset(cmp, -1, sizeof(cmp));
memset(used, false, sizeof(used));
for (int i = 0; i < V; i++)
if (!used[i]) dfs(i);
int k = 0;
memset(used, false, sizeof(used));
for (int i = (int)vs.size() - 1; i >= 0; i--) {
if (!used[vs[i]]) rdfs(vs[i], k++);
}
}
int n, m;
vector<int> adj[50010];
int col[50010];
int t[50010];
map<int, int> cnt;
map<int, int> cnt2[50010];
vector<int> use[50010];
int must[50010];
int ind;
bool make_graph(int limit) {
memset(must, -1, sizeof(must));
for (int i = 0; i < n; i++) use[i].clear();
for (int i = 0; i < n; i++) cnt2[i].clear();
for (int i = 0; i < n; i++) {
int c = 0;
cnt.clear();
map<int, int>::iterator it;
for (int j = 0; j < adj[i].size(); j++) {
int id = adj[i][j];
if (t[id] <= limit) {
cnt[col[id]]++;
use[i].push_back(id);
} else {
if (cnt2[i].find(col[id]) != cnt2[i].end()) return false;
cnt2[i][col[id]] = id;
}
}
for (it = cnt.begin(); it != cnt.end(); it++) {
if ((it->second) > 2) return false;
if ((it->second) == 2) {
c++;
must[i] = it->first;
}
}
if (c > 1) return false;
}
ind = 2 * m;
clear_graph();
for (int i = 0; i < n; i++) {
int num = (int)use[i].size();
int m1 = -1, m2 = -1;
for (int j = 0; j < num; j++) {
add_edge(ind + j, use[i][j] + m);
if (j < num - 1) add_edge(ind + j, ind + j + 1);
add_edge(ind + num + j, use[i][j] + m);
if (j > 0) add_edge(ind + num + j, ind + num + j - 1);
if (j < num - 1) add_edge(use[i][j], ind + j + 1);
if (j > 0) add_edge(use[i][j], ind + num + j - 1);
if (col[use[i][j]] == must[i]) {
if (m1 == -1)
m1 = use[i][j];
else
m2 = use[i][j];
}
map<int, int>::iterator it;
if ((it = cnt2[i].find(col[use[i][j]])) != cnt2[i].end())
add_edge(use[i][j] + m, use[i][j]);
}
if (m1 != -1 && m2 != -1) {
add_edge(m1 + m, m2);
add_edge(m2 + m, m1);
}
ind += 2 * num;
}
V = ind;
return true;
}
vector<int> ans;
bool check(int limit, bool recover) {
if (!make_graph(limit)) return false;
scc();
for (int i = 0; i < n; i++) {
for (int j = 0; j < use[i].size(); j++) {
int id = use[i][j];
if (cmp[id] == cmp[id + m]) return false;
if (recover && cmp[id] > cmp[id + m]) ans.push_back(id + 1);
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d %d %d", &u, &v, &col[i], &t[i]);
u--;
v--;
adj[u].push_back(i);
adj[v].push_back(i);
}
int l = -1, r = 1000000100;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid, false))
r = mid;
else
l = mid;
}
if (r == 1000000100)
printf("No\n");
else {
printf("Yes\n");
check(r, true);
sort((ans).begin(), (ans).end());
ans.erase(unique((ans).begin(), (ans).end()), ans.end());
int k = (int)ans.size();
printf("%d %d\n", r, k);
for (int i = 0; i < k; i++)
printf("%d%c", ans[i], (i == k - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50 * 1000 + 3;
int n, m, u[N], v[N], c[N], t[N], sz, col[N << 3];
vector<int> edg[N], tim, g[N << 3], tmp[N << 3], ans, vec;
vector<pair<int, int> > bad;
bool mark[N << 3];
bool cmp(int a, int b) { return c[a] < c[b]; }
void _dfs(int v) {
mark[v] = 1;
for (auto u : g[v])
if (!mark[u]) _dfs(u);
vec.push_back(v);
return;
}
void dfs(int v, int C) {
mark[v] = 1;
col[v] = C;
for (auto u : g[v])
if (!mark[u]) dfs(u, C);
return;
}
bool check(int x) {
for (int i = 0; i < (N << 3); i++) g[i].clear();
for (auto p : bad) {
int a = p.first, b = p.second;
g[a * 2].push_back(b * 2 + 1);
g[b * 2].push_back(a * 2 + 1);
}
sz = m;
for (int i = 0; i < n; i++)
if (!edg[i].empty()) {
int cur = edg[i][0];
for (int j = 1; j < (int)edg[i].size(); j++) {
int a = edg[i][j];
g[cur * 2 + 1].push_back(a * 2);
g[a * 2 + 1].push_back(cur * 2);
g[a * 2 + 1].push_back(sz * 2 + 1);
g[sz * 2].push_back(a * 2);
g[cur * 2 + 1].push_back(sz * 2 + 1);
g[sz * 2].push_back(cur * 2);
cur = sz++;
}
}
sz *= 2;
for (int i = 0; i < m; i++)
if (t[i] > x) g[i * 2 + 1].push_back(i * 2);
memset(mark, 0, sizeof mark);
vec.clear();
for (int i = 0; i < sz; i++)
if (!mark[i]) _dfs(i);
for (int i = 0; i < sz; i++) tmp[i].clear();
for (int i = 0; i < sz; i++)
for (int j = 0; j < int(g[i].size()); j++) tmp[g[i][j]].push_back(i);
for (int i = 0; i < sz; i++) g[i] = tmp[i];
int cl = 0;
memset(mark, 0, sizeof mark);
for (int i = int(vec.size()) - 1; i > -1; i--)
if (!mark[vec[i]]) dfs(vec[i], cl++);
ans.clear();
sz /= 2;
for (int i = 0; i < sz; i++) {
if (col[i * 2] == col[i * 2 + 1]) return 0;
if (i < m && col[i * 2] < col[i * 2 + 1]) ans.push_back(i);
}
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
;
tim.push_back(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i] >> c[i] >> t[i];
u[i]--;
v[i]--;
edg[v[i]].push_back(i);
edg[u[i]].push_back(i);
tim.push_back(t[i]);
}
for (int i = 0; i < n; i++) {
sort(edg[i].begin(), edg[i].end(), cmp);
int num = 0;
for (int e = 0; e < int(edg[i].size()); e++) {
int pt = e + 1;
while (pt < int(edg[i].size()) && c[edg[i][pt - 1]] == c[edg[i][pt]])
pt++;
if (pt - e > 2) return cout << "No\n", 0;
if (pt - e == 2) {
num++;
if (num == 2) return cout << "No\n", 0;
bad.push_back({edg[i][e], edg[i][e + 1]});
e++;
}
}
}
sort(tim.begin(), tim.end());
tim.resize(unique(tim.begin(), tim.end()) - tim.begin());
int l = -1, r = int(tim.size());
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(tim[mid]))
r = mid;
else
l = mid;
}
if (r == int(tim.size())) return cout << "No\n", 0;
check(tim[r]);
cout << "Yes\n" << tim[r] << ' ' << ans.size() << '\n';
for (auto a : ans) cout << a + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct gr {
int v, u, c, t;
};
const int maxn = 3e5 + 20, INF = 1e9;
int n, m, comp[maxn], sz[2 * maxn], szrev[maxn];
bool mark[maxn];
vector<int> adj[maxn];
vector<int> edges[maxn], revedges[maxn], vec, tme;
gr e[maxn];
bool cmp(int x, int y) { return (e[x].c < e[y].c); }
inline int nt(int x) { return x ^ 1; }
inline void add_edge(int x, int y) {
edges[x].push_back(y);
revedges[y].push_back(x);
}
inline void add_cl(int x, int y) {
add_edge(nt(x), y);
add_edge(nt(y), x);
}
void dfs1(int v) {
mark[v] = 1;
for (auto u : edges[v]) {
if (!mark[u]) {
dfs1(u);
}
}
vec.push_back(v);
}
void dfs2(int v, int c) {
comp[v] = c;
for (auto u : revedges[v]) {
if (!comp[u]) {
dfs2(u, c);
}
}
}
int nxt;
inline bool check(long long val) {
vec.clear();
for (int i = 0; i < nxt; ++i) {
mark[i] = 0;
comp[i] = 0;
edges[i].resize(sz[i]);
revedges[i].resize(szrev[i]);
}
for (int i = 0; i < m; ++i) {
if (e[i].t > val) {
add_cl(nt(2 * i), nt(2 * i));
}
}
for (int i = 0; i < nxt; ++i) {
if (!mark[i]) {
dfs1(i);
}
}
reverse(vec.begin(), vec.end());
int cnt = 1;
for (int i : vec) {
if (!comp[i]) {
dfs2(i, cnt);
cnt++;
}
}
for (int i = 0; i < nxt; i += 2) {
if (comp[i] == comp[nt(i)]) {
return 0;
}
}
return 1;
}
inline void setup() {
nxt = 2 * m;
for (int i = 0; i < maxn; ++i) {
edges[i].clear();
revedges[i].clear();
}
for (int i = 0; i < n; ++i) {
int prv = nxt, cnt = 0;
if (adj[i].size()) {
add_cl(nt(2 * adj[i][0]), prv);
nxt += 2;
}
for (int j = 1; j < adj[i].size(); ++j) {
int u = adj[i][j - 1], v = adj[i][j];
int curr = nxt;
nxt += 2;
if (e[u].c == e[v].c) {
cnt++;
if (cnt > 1) {
cout << "No" << endl;
exit(0);
}
add_cl(2 * u, 2 * v);
} else {
cnt = 0;
}
add_cl(nt(2 * v), curr);
add_cl(nt(prv), curr);
add_cl(nt(prv), nt(2 * v));
prv = curr;
}
}
for (int i = 0; i < maxn; ++i) {
sz[i] = edges[i].size();
szrev[i] = revedges[i].size();
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, c, t;
cin >> x >> y >> c >> t;
x--;
y--;
e[i].v = x;
e[i].u = y;
e[i].c = c;
e[i].t = t;
adj[x].push_back(i);
adj[y].push_back(i);
tme.push_back(t);
}
for (int i = 0; i < n; ++i) {
sort(adj[i].begin(), adj[i].end(), cmp);
}
tme.push_back(0);
sort(tme.begin(), tme.end());
tme.resize(unique(tme.begin(), tme.end()) - tme.begin());
setup();
long long l = -1, r = tme.size();
while (l < r - 1) {
long long m = (l + r) / 2;
if (check(tme[m])) {
r = m;
} else {
l = m;
}
}
if (r == tme.size()) {
cout << "No" << endl;
return 0;
}
check(tme[r]);
cout << "Yes" << endl;
fill(mark, mark + maxn, 0);
vector<int> ans;
for (int i = 0; i < nxt; i += 2) {
int v = comp[i], u = comp[nt(i)];
mark[min(v, u)] = 0;
mark[max(v, u)] = 1;
}
for (int i = 0; i < m; ++i) {
if (mark[comp[2 * i]]) {
ans.push_back(i + 1);
}
}
cout << tme[r] << ' ' << ans.size() << endl;
for (auto u : ans) {
cout << u << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
const int MAXV = 6 * MAXN;
const int MAXE = 20 * MAXN;
struct Graph {
struct edge {
int to;
edge *nxt;
} edges[MAXE + 5], *adj[MAXV + 5], *ecnt;
Graph() { ecnt = edges; }
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
} G1, G2;
int n, m, cnt;
struct edge {
int u, v, c, t, id;
edge() {}
edge(int _u, int _v, int _c, int _t, int _id)
: u(_u), v(_v), c(_c), t(_t), id(_id) {}
} e[MAXN + 5];
bool cmp(const edge &a, const edge &b) { return a.t < b.t; }
int dfn[MAXV + 5], low[MAXV + 5], id[MAXV + 5];
int stk[MAXV + 5], tp, dcnt, tot;
void dfs(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool check(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs(i);
for (int i = 0; i < m; i++) {
if (id[i << 1] == id[i << 1 | 1]) return false;
}
return true;
}
vector<int> v1[MAXV + 5];
void dfs2(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs2(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
v1[tot].push_back(stk[tp]);
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool tag[MAXV + 5];
vector<int> ans;
void print(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs2(i);
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < (int)v1[i].size(); j++) {
int x = v1[i][j];
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt)
if (tag[id[p->to]]) tag[i] = true;
}
if (!tag[i]) {
for (int j = 0; j < (int)v1[i].size(); j++)
if (v1[i][j] < 2 * m) tag[id[v1[i][j] ^ 1]] = true;
}
}
for (int i = 0; i < m; i++) {
if (tag[id[i << 1]]) ans.push_back(i + 1);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
}
map<int, int> mp;
vector<edge> vec[MAXN + 5];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, c, t;
scanf("%d%d%d%d", &u, &v, &c, &t);
e[i] = edge(u, v, c, t, i);
vec[u].push_back(e[i]), vec[v].push_back(e[i]);
}
cnt = 2 * m;
for (int i = 1; i <= n; i++) {
bool flag = false;
mp.clear();
for (int j = 0; j < (int)vec[i].size(); j++) {
if (mp.count(vec[i][j].c)) {
if (flag)
puts("No"), exit(0);
else
flag = true;
int x = vec[i][j].id, y = mp[vec[i][j].c];
G1.addedge(x << 1, y << 1 | 1), G1.addedge(y << 1, x << 1 | 1);
} else
mp[vec[i][j].c] = vec[i][j].id;
}
if (vec[i].size() >= 2) {
int lst = (vec[i][0].id << 1);
for (int j = 1; j < (int)vec[i].size(); j++) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j + 1 == (int)vec[i].size()) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
lst = (vec[i][vec[i].size() - 1].id << 1);
for (int j = (int)vec[i].size() - 2; j >= 0; j--) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j == 0) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
}
}
sort(e, e + m, cmp);
if (!check(m - 1))
puts("No"), exit(0);
else
puts("Yes");
int le = -1, ri = m - 1;
while (le < ri) {
int mid = (le + ri) >> 1;
if (check(mid))
ri = mid;
else
le = mid + 1;
}
printf("%d ", le == -1 ? 0 : e[le].t), print(le);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
const int sq = 316;
const long long int mod = 998244353;
const int inf = 1e9 + 100;
int n, m, com = 0;
int c[N], t[N], bl[N];
bool mark[N];
vector<int> in[N], out[N], adj[N], tp, ans;
vector<pair<int, int>> e, edge, tmp;
inline void cl() {
tp.clear();
com = 0;
for (int i = 0; i < N; i++) {
bl[i] = mark[i] = 0;
out[i].clear();
in[i].clear();
}
}
void dfs(int u) {
mark[u] = true;
for (auto x : out[u]) {
if (!mark[x]) dfs(x);
}
tp.push_back(u);
}
void rdfs(int u) {
mark[u] = true;
bl[u] = com;
for (auto x : in[u]) {
if (!mark[x]) rdfs(x);
}
}
void add(int x, int y) {
out[x].push_back(y);
in[y].push_back(x);
}
bool check(int mid) {
cl();
for (int i = 0; i < m; i++) {
if (t[i] > mid) add(2 * i + 1, 2 * i);
}
for (auto it : e) {
int x = it.first, y = it.second;
add(2 * x, 2 * y + 1);
add(2 * y, 2 * x + 1);
}
int pt = m;
for (int u = 0; u < n; u++) {
if (adj[u].size() == 0) continue;
int x = adj[u][0];
for (int i = 1; i < adj[u].size(); i++) {
int y = adj[u][i];
add(pt * 2, x * 2);
add(x * 2 + 1, pt * 2 + 1);
add(y * 2 + 1, x * 2);
add(x * 2 + 1, y * 2);
add(y * 2 + 1, pt * 2 + 1);
add(pt * 2, y * 2);
x = pt++;
}
}
pt *= 2;
for (int i = 0; i < pt; i++) {
if (!mark[i]) dfs(i);
}
for (int i = 0; i < N; i++) mark[i] = 0;
for (int i = tp.size() - 1; i >= 0; i--) {
int u = tp[i];
if (!mark[u]) {
com++;
rdfs(u);
}
}
for (int i = 0; i < pt / 2; i++) {
if (bl[i * 2 + 1] == bl[i * 2]) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y >> c[i] >> t[i];
x--;
y--;
edge.push_back({x, y});
adj[x].push_back(i);
adj[y].push_back(i);
}
bool fl = true;
for (int u = 0; u < n; u++) {
tmp.clear();
for (auto it : adj[u]) tmp.push_back({c[it], it});
sort(tmp.begin(), tmp.end());
adj[u].clear();
for (auto it : tmp) adj[u].push_back(it.second);
int sztmp = int(tmp.size());
int k = 0;
for (int i = 0; i < sztmp;) {
int cnt = 0, cl = tmp[i].first;
while (i < sztmp && tmp[i].first == cl) {
cnt++;
i++;
}
if (cnt > 2) {
cout << "No" << endl;
return 0;
}
if (cnt == 2) {
e.push_back({tmp[i - 2].second, tmp[i - 1].second});
k++;
}
}
if (k > 1) {
cout << "No" << endl;
return 0;
}
}
int l = -1, r = inf;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (r >= inf) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl << r << ' ';
check(r);
for (int i = 0; i < m; i++) {
if (bl[i * 2] < bl[i * 2 + 1]) {
ans.push_back(i + 1);
}
}
cout << ans.size() << endl;
for (auto it : ans) cout << it << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 10;
long long int cnt;
long long int tas;
queue<int> q;
map<int, int> mp[6 * maxn + 10];
bool mark[6 * maxn + 10];
bool t;
bool k;
int n;
int m;
vector<int> v[6 * maxn + 10];
vector<pair<int, pair<int, pair<int, int>>>> p;
vector<int> addclause[6 * maxn + 10];
vector<int> rev[6 * maxn + 10];
vector<int> topol;
int cmp[6 * maxn + 10];
long long int ans[6 * maxn + 10];
long long int res[6 * maxn + 10];
int NOT(int val) {
if (val < 3 * maxn) {
return val + (3 * maxn);
} else {
return val - (3 * maxn);
}
}
void pAq(int a, int b) {
addclause[NOT(a)].push_back((b));
addclause[NOT(b)].push_back((a));
rev[(a)].push_back(NOT(b));
rev[(b)].push_back(NOT(a));
}
void PQ(int a, int b) {
addclause[NOT(a)].pop_back();
addclause[NOT(b)].pop_back();
rev[(a)].pop_back();
rev[(b)].pop_back();
}
void sfd(int u, long long int tas) {
mark[u] = true;
cmp[u] = tas;
for (int i = 0; i < rev[u].size(); i++) {
if (mark[rev[u][i]] == false) {
sfd(rev[u][i], tas);
}
}
}
void dfs(int u) {
mark[u] = true;
for (int i = 0; i < addclause[u].size(); i++) {
if (mark[addclause[u][i]] == false) {
dfs(addclause[u][i]);
}
}
topol.push_back(u);
return;
}
int check(int u) {
tas = 0;
vector<pair<int, int>> o;
for (int i = 1; i <= m; i++) {
if (p[i].second.second.second > u) {
pAq(NOT(i), NOT(i));
o.push_back({NOT(i), NOT(i)});
}
}
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= 6 * maxn; i++) {
if (mark[i] == false) {
dfs(i);
}
}
reverse(topol.begin(), topol.end());
memset(mark, 0, sizeof(mark));
for (int i = 0; i < 6 * maxn; i++) {
if (mark[topol[i]] == false) {
sfd(topol[i], tas++);
}
}
topol.clear();
int w = 0;
for (int i = 1; i <= m; i++) {
if (u == 1e9 + 1) {
}
if (cmp[i] == cmp[NOT(i)]) {
w = 1;
}
}
for (int i = 0; i < o.size(); i++) {
int r = o[i].first;
int e = o[i].second;
PQ(r, e);
}
if (w == 1) {
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
p.push_back({0, {0, {0, 0}}});
for (int i = 1; i <= m; i++) {
int l;
int r;
int c;
int t;
cin >> l >> r >> c >> t;
v[l].push_back(i);
v[r].push_back(i);
p.push_back({l, {r, {c, t}}});
if (mp[l][c] == 0) {
res[l]++;
mp[l][c] = i;
} else if (mp[l][c] != 1e9) {
pAq(i, (mp[l][c]));
pAq(NOT(i), NOT(mp[l][c]));
mp[l][c] = 1e9;
}
if (mp[r][c] == 0) {
res[r]++;
mp[r][c] = i;
} else if (mp[r][c] != 1e9) {
pAq(i, (mp[r][c]));
pAq(NOT(i), NOT(mp[r][c]));
mp[r][c] = 1e9;
}
ans[l]++;
ans[r]++;
}
cnt = m + 1;
for (int i = 1; i <= n; i++) {
if (ans[i] - res[i] > 1) {
cout << "No";
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (ans[i] - res[i] == 0) {
for (int j = 0; j < v[i].size(); j++) {
if (j >= 1) {
pAq(NOT(v[i][j]), NOT(j + cnt - 1));
pAq(NOT(j + cnt - 1), j + cnt);
}
pAq(NOT(v[i][j]), j + cnt);
}
cnt += v[i].size();
} else {
for (int j = 0; j < v[i].size(); j++) {
if (mp[i][p[v[i][j]].second.second.first] != 1e9) {
pAq(NOT(v[i][j]), NOT(v[i][j]));
}
}
}
}
int r = 1e9 + 1;
int l = -1;
while (l != r - 1) {
int mid = (l + r) >> 1;
if (check(mid) == 1) {
r = mid;
} else {
l = mid;
}
}
if (check(r) == 0) {
cout << "No";
return 0;
}
cout << "Yes" << endl;
int u = 0;
vector<int> op;
for (int i = 1; i <= m; i++) {
if (cmp[i] > cmp[NOT(i)]) {
op.push_back(i);
u = max(u, p[i].second.second.second);
}
}
cout << u << " ";
cout << op.size() << endl;
for (int i = 0; i < op.size(); i++) {
cout << op[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
const int sq = 316;
const long long int mod = 998244353;
const int inf = 1e9 + 100;
int n, m, com = 0;
int c[N], t[N], bl[N];
bool mark[N];
vector<int> in[N], out[N], adj[N], tp, ans;
vector<pair<int, int>> e, edge, tmp;
inline void cl() {
tp.clear();
com = 0;
for (int i = 0; i < N; i++) {
bl[i] = mark[i] = 0;
out[i].clear();
in[i].clear();
}
}
void dfs(int u) {
mark[u] = true;
for (auto x : out[u]) {
if (!mark[x]) dfs(x);
}
tp.push_back(u);
}
void rdfs(int u) {
mark[u] = true;
bl[u] = com;
for (auto x : in[u]) {
if (!mark[x]) rdfs(x);
}
}
void add(int x, int y) {
out[x].push_back(y);
in[y].push_back(x);
}
bool check(int mid) {
cl();
for (int i = 0; i < m; i++) {
if (t[i] > mid) add(2 * i + 1, 2 * i);
}
for (auto it : e) {
int x = it.first, y = it.second;
add(2 * x, 2 * y + 1);
add(2 * y, 2 * x + 1);
}
int pt = m;
for (int u = 0; u < n; u++) {
if (adj[u].size() == 0) continue;
int x = adj[u][0];
for (int i = 1; i < adj[u].size(); i++) {
int y = adj[u][i];
add(pt * 2, x * 2);
add(x * 2 + 1, pt * 2 + 1);
add(y * 2 + 1, x * 2);
add(x * 2 + 1, y * 2);
add(y * 2 + 1, pt * 2 + 1);
add(pt * 2, y * 2);
x = pt++;
}
}
pt *= 2;
for (int i = 0; i < pt; i++) {
if (!mark[i]) dfs(i);
}
for (int i = 0; i < N; i++) mark[i] = 0;
for (int i = tp.size() - 1; i >= 0; i--) {
int u = tp[i];
if (!mark[u]) {
com++;
rdfs(u);
}
}
for (int i = 0; i < pt / 2; i++) {
if (bl[i * 2 + 1] == bl[i * 2]) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y >> c[i] >> t[i];
x--;
y--;
edge.push_back({x, y});
adj[x].push_back(i);
adj[y].push_back(i);
}
bool fl = true;
for (int u = 0; u < n; u++) {
tmp.clear();
for (auto it : adj[u]) tmp.push_back({c[it], it});
sort(tmp.begin(), tmp.end());
adj[u].clear();
for (auto it : tmp) adj[u].push_back(it.second);
int sztmp = int(tmp.size());
int k = 0;
for (int i = 0; i < sztmp;) {
int cnt = 0, cl = tmp[i].first;
while (i < sztmp && tmp[i].first == cl) {
cnt++;
i++;
}
if (cnt > 2) {
cout << "No" << endl;
return 0;
}
if (cnt == 2) {
e.push_back({tmp[i - 2].second, tmp[i - 1].second});
k++;
}
}
if (k > 1) {
cout << "No" << endl;
return 0;
}
}
int l = -1, r = inf;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
if (r >= inf) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl << r << ' ';
check(r);
for (int i = 0; i < m; i++) {
if (bl[i * 2] < bl[i * 2 + 1]) {
ans.push_back(i + 1);
}
}
cout << ans.size() << endl;
for (auto it : ans) cout << it << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
const int MAXV = 6 * MAXN;
const int MAXE = 20 * MAXN;
struct Graph {
struct edge {
int to;
edge *nxt;
} edges[MAXE + 5], *adj[MAXV + 5], *ecnt;
Graph() { ecnt = edges; }
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
} G1, G2;
int n, m, cnt;
struct edge {
int u, v, c, t, id;
edge() {}
edge(int _u, int _v, int _c, int _t, int _id)
: u(_u), v(_v), c(_c), t(_t), id(_id) {}
} e[MAXN + 5];
bool cmp(const edge &a, const edge &b) { return a.t < b.t; }
int dfn[MAXV + 5], low[MAXV + 5], id[MAXV + 5];
int stk[MAXV + 5], tp, dcnt, tot;
void dfs(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool check(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs(i);
for (int i = 0; i < m; i++) {
if (id[i << 1] == id[i << 1 | 1]) return false;
}
return true;
}
vector<int> v1[MAXV + 5];
void dfs2(int x) {
dfn[x] = low[x] = (++dcnt), stk[++tp] = x;
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt) {
if (dfn[p->to]) {
if (!id[p->to]) low[x] = min(low[x], dfn[p->to]);
} else
dfs2(p->to), low[x] = min(low[x], low[p->to]);
}
if (low[x] >= dfn[x]) {
tot++;
do {
v1[tot].push_back(stk[tp]);
id[stk[tp]] = tot;
} while (stk[tp--] != x);
}
}
bool tag[MAXV + 5];
vector<int> ans;
void print(int x) {
G2 = G1;
for (int i = x + 1; i < m; i++) G2.addedge(e[i].id << 1 | 1, e[i].id << 1);
for (int i = 0; i < cnt; i++) dfn[i] = low[i] = id[i] = 0;
dcnt = tot = 0;
for (int i = 0; i < cnt; i++)
if (!dfn[i]) dfs2(i);
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < (int)v1[i].size(); j++) {
int x = v1[i][j];
for (Graph::edge *p = G2.adj[x]; p; p = p->nxt)
if (tag[id[p->to]]) tag[i] = true;
}
if (!tag[i]) {
for (int j = 0; j < (int)v1[i].size(); j++)
if (v1[i][j] < 2 * m) tag[id[v1[i][j] ^ 1]] = true;
}
}
for (int i = 0; i < m; i++) {
if (tag[id[i << 1]]) ans.push_back(i + 1);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
}
map<int, int> mp;
vector<edge> vec[MAXN + 5];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, c, t;
scanf("%d%d%d%d", &u, &v, &c, &t);
e[i] = edge(u, v, c, t, i);
vec[u].push_back(e[i]), vec[v].push_back(e[i]);
}
cnt = 2 * m;
for (int i = 1; i <= n; i++) {
bool flag = false;
mp.clear();
for (int j = 0; j < (int)vec[i].size(); j++) {
if (mp.count(vec[i][j].c)) {
if (flag)
puts("No"), exit(0);
else
flag = true;
int x = vec[i][j].id, y = mp[vec[i][j].c];
G1.addedge(x << 1, y << 1 | 1), G1.addedge(y << 1, x << 1 | 1);
} else
mp[vec[i][j].c] = vec[i][j].id;
}
if (vec[i].size() >= 2) {
int lst = (vec[i][0].id << 1);
for (int j = 1; j < (int)vec[i].size(); j++) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j + 1 == (int)vec[i].size()) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
lst = (vec[i][vec[i].size() - 1].id << 1);
for (int j = (int)vec[i].size() - 2; j >= 0; j--) {
int x = vec[i][j].id;
G1.addedge(x << 1 | 1, lst);
if (j == 0) break;
G1.addedge(cnt, x << 1), G1.addedge(cnt, lst);
lst = cnt, cnt++;
}
}
}
sort(e, e + m, cmp);
if (!check(m - 1))
puts("No"), exit(0);
else
puts("Yes");
int le = -1, ri = m - 1;
while (le < ri) {
int mid = (le + ri) >> 1;
if (check(mid))
ri = mid;
else
le = mid + 1;
}
printf("%d ", le == -1 ? 0 : e[le].t), print(le);
}
|
#include <bits/stdc++.h>
using namespace std;
bool mask[1006][1006];
void gen(int x) {
int dl = (1 << (x - 1));
for (int i = 0; i < dl; i++)
for (int j = 0; j < dl; j++) {
mask[i + dl][j] = mask[i][j];
mask[i][j + dl] = mask[i][j];
mask[i + dl][j + dl] = !mask[i][j];
}
}
void wypisz(int k) {
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++)
if (mask[i][j])
printf("+");
else
printf("*");
puts("");
}
}
int main() {
int k;
scanf("%d", &k);
mask[0][0] = true;
for (int i = 1; i <= k; i++) gen(i);
wypisz(k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[10] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
bool vis[515][515];
void dfs(int dep) {
if (dep == 1) {
vis[1][1] = vis[2][1] = vis[2][2] = 1;
vis[1][2] = 0;
return;
}
dfs(dep - 1);
for (int i = 1; i <= num[dep - 1]; i++) {
for (int j = 1; j <= num[dep - 1]; j++)
vis[i + num[dep - 1]][j] = vis[i][j + num[dep - 1]] = vis[i][j],
vis[i + num[dep - 1]][j + num[dep - 1]] = !vis[i][j];
}
return;
}
int main() {
int n;
scanf("%d", &n);
if (!n) {
printf("+\n");
return 0;
}
dfs(n);
for (int i = 1; i <= num[n]; i++) {
for (int j = 1; j <= num[n]; j++) {
if (vis[i][j])
printf("+");
else
printf("*");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<vector<int> > numbers;
numbers.push_back(vector<int>(1, 0));
for (int i = 1; i <= n; i++) {
vector<vector<int> > new_numbers;
for (auto &n : numbers) {
vector<int> first;
vector<int> second;
for (auto &b : n) {
first.push_back(b);
second.push_back(b);
}
for (auto &b : n) {
first.push_back(b);
second.push_back(!b);
}
new_numbers.push_back(first);
new_numbers.push_back(second);
}
numbers = new_numbers;
}
for (auto &n : numbers) {
for (auto &b : n) {
if (b) {
cout << "*";
} else {
cout << "+";
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string d[10][550];
int k;
string mokh(string a) {
for (int i = 0; i < a.size(); ++i) {
if (a[i] == '*') {
a[i] = '+';
continue;
}
if (a[i] == '+') a[i] = '*';
}
return a;
}
int power(int a) {
int ans = 1;
while (a) {
ans *= 2;
a--;
}
return ans;
}
int main() {
d[0][0] = "*";
cin >> k;
string help, help1;
for (int i = 1; i < k + 1; ++i) {
for (int j = 0; j < power(i - 1); ++j) {
d[i][j] = d[i - 1][j];
help = d[i][j] + d[i - 1][j];
d[i][j] = help;
}
for (int j = power(i - 1); j < power(i); ++j) {
d[i][j] = d[i - 1][j - power(i - 1)];
help1 = mokh(d[i - 1][j - power(i - 1)]);
help = d[i][j] + help1;
d[i][j] = help;
}
}
for (int i = 0; i < power(k); ++i) cout << d[k][i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nm = 1e5 + 10;
int n;
char ans[600][600];
void go() {
ans[0][0] = '+';
int res = 1, rec = 1;
for (int k = 1; k < 10; k++) {
rec = res << 1;
int i = 0;
for (; i < res; i++) {
for (int j = res; j < rec; j++) ans[i][j] = ans[i][j - res];
}
for (; i < rec; i++) {
for (int j = 0; j < res; j++) ans[i][j] = ans[i - res][j];
for (int j = res; j < rec; j++) {
if (ans[i][j - res] == '+')
ans[i][j] = '*';
else
ans[i][j] = '+';
}
}
res = rec;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
go();
while (cin >> n) {
int m = 1 << n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
}
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > Trans(const vector<vector<int> >& first,
const vector<vector<int> >& second, int n) {
vector<vector<int> > result(2 * n, vector<int>(2 * n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
result[i][j] = first[i][j];
result[i][j + n] = second[i][j];
result[i + n][j] = first[i][j];
result[i + n][j + n] = -second[i][j];
}
}
return result;
}
void print(const vector<vector<int> >& matrix) {
for (size_t i = 0; i < matrix.size(); ++i) {
for (size_t j = 0; j < matrix[0].size(); ++j) {
if (matrix[i][j] == 1) {
cout << '+';
} else {
cout << '*';
}
}
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k;
cin >> k;
vector<vector<int> > array(1, vector<int>(1, 1));
int currentN = 1;
for (int i = 0; i < k; ++i) {
array = Trans(array, array, currentN);
currentN *= 2;
}
print(array);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[2000][2000];
int n, m;
int main() {
ios_base::sync_with_stdio(0);
int k;
cin >> k;
n = (1 << k);
m = n / 2;
for (int i = 1; i < n; i++) {
if (true) {
for (int j = 0; j < n; j++) t[i][j] = t[i - 1][j];
int block = i / 4;
int period = i % 4;
if (period == 0) {
int len = n >> (__builtin_ctz(block));
for (int j = 0; j < n; j++) {
int pos = j % len;
int inv = (j / len);
inv = min(inv, (n / len) - 1 - inv) & 1;
if (inv) pos = len - pos - 1;
int half = len / 2;
int hh = half / 2;
int hhh = hh / 2;
if (pos < half) {
if (pos >= hhh && pos - hhh < hh) t[i][j] ^= 1;
} else {
pos -= half;
if (!(pos >= hhh && pos - hhh < hh)) t[i][j] ^= 1;
}
}
} else {
int shift = (period == 2 ? m / 2 : m);
for (int j = 0; j < m; j++) t[i][j + shift] ^= 1;
}
} else {
while (true) {
bool go = false;
for (int j = 0; j < i; j++) {
int w = 0;
for (int z = 0; z < n; z++)
if (t[i][z] != t[j][z]) w++;
if (w != m) {
go = true;
break;
}
}
if (!go) break;
int j = n - 1;
while (t[i][j] == 1) {
t[i][j--] ^= 1;
}
t[i][j] ^= 1;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
int w = 0;
for (int z = 0; z < n; z++)
if (t[i][z] != t[j][z]) w++;
if (w != m) cout << "Incorrect " << i << " " << j << endl;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (t[i][j] == 0)
cout << "*";
else
cout << "+";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string answer[512];
string change(string k) {
string x = "";
for (int i = 0; i < k.length(); i++) {
x += (k[i] == '+') ? "*" : "+";
}
return x;
}
int main() {
int k;
cin >> k;
if (k == 0) {
cout << "+" << endl;
return 0;
}
int cur = 2;
answer[0] = "++";
answer[1] = "+*";
for (int j = 0; j < k - 1; j++) {
string ans2[512];
for (int i = 0; i < cur; i++) {
ans2[i] = answer[i];
ans2[i] += answer[i];
}
for (int i = cur; i < 2 * cur; i++) {
ans2[i] = answer[i - cur];
ans2[i] += change(answer[i - cur]);
}
cur *= 2;
for (int i = 0; i < cur; i++) answer[i] = ans2[i];
}
for (int i = 0; i < cur; i++) cout << answer[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
char sol[N][N];
int n;
void rewrite(int m) {
int k = m / 2;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
sol[i + k][j] = sol[i][j];
sol[i][j + k] = sol[i][j];
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
if (sol[i][j] == '*')
sol[i + k][j + k] = '+';
else
sol[i + k][j + k] = '*';
}
}
}
void finish() {
int LIM = 1 << n;
for (int i = 0; i < LIM; i++) {
for (int j = 0; j < LIM; j++) {
printf("%c", sol[i][j]);
}
printf("\n");
}
}
int main() {
scanf("%d", &n);
sol[0][0] = '+';
for (int i = 1; i <= n; i++) rewrite((int)(1 << i));
finish();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string rev(string s) {
for (int i = 0; i < s.length(); i++) s[i] = s[i] == '+' ? '*' : '+';
return s;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<string> v;
v.push_back("+");
for (int i = 0; i < n; i++) {
vector<string> w;
for (string s : v) {
w.push_back(s + s);
w.push_back(s + rev(s));
}
v = w;
}
for (string s : v) cout << s << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)5e2 + 10;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
long long a[maxN];
int n;
bool ok = false;
bool bad(int idx) {
for (int i = 0; i < idx; ++i) {
int r = 0;
for (int j = 0; j < n; ++j) {
if (((a[i] >> j) & 1) != ((a[idx] >> j) & 1)) {
r--;
} else {
r++;
}
}
if (r != 0) return true;
}
return false;
}
int cnt = 0;
void print() {
ok = 0;
for (int i = 0; i < 30; ++i) putchar('-');
putchar('\n');
char f[] = {'*', '+'};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cout << f[(a[i] >> j) & 1];
}
cout << '\n';
}
cout << '\n';
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cout << f[(a[i] >> j) & 1];
if (j == n / 2 - 1) putchar(' ');
}
cout << '\n';
if (i == n / 2 - 1) putchar('\n');
}
cout << '\n';
for (int i = 0; i < 30; ++i) putchar('-');
putchar('\n');
}
void dfs(int idx, int n) {
if (idx == n) {
print();
return;
}
for (long long mask = 0; mask < (1LL << n) && ok; ++mask) {
a[idx] = mask;
if (bad(idx)) continue;
dfs(idx + 1, n);
}
}
char rev(char x) {
if (x == '+') return '*';
return '+';
}
vector<vector<char> > build(int k) {
vector<vector<char> > ret(1 << k, vector<char>(1 << k, '?'));
if (k == 0) {
ret[0][0] = '*';
return ret;
}
vector<vector<char> > prev = build(k - 1);
int prevsz = (1 << k) / 2;
for (int i = 0; i < prevsz; ++i) {
for (int j = 0; j < prevsz; ++j) {
ret[i][2 * j] = ret[i][2 * j + 1] = prev[i][j];
}
}
for (int j = prevsz - 1; j >= 0; --j) {
for (int i = 0; i < prevsz; ++i) {
ret[prevsz + i][2 * j + 1] = prev[i][j];
ret[prevsz + i][2 * j] = rev(prev[i][j]);
}
}
return ret;
}
int main() {
int k;
cin >> k;
vector<vector<char> > answer = build(k);
for (int i = 0; i < answer.size(); ++i) {
for (int j = 0; j < answer[i].size(); ++j) {
putchar(answer[i][j]);
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<int, int> d[3] = {{0, 1}, {1, 0}, {1, 1}};
int b[550][550];
void rec(int k) {
if (k == 1) {
b[0][0] = 1;
return;
}
if (k == 2) {
b[0][0] = b[0][1] = b[1][0] = 1;
b[1][1] = 0;
return;
}
rec(k /= 2);
for (int c = 0; c < 3; c++) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
b[i + d[c].first * k][j + d[c].second * k] = !b[i][j];
}
}
}
}
int main() {
cin >> k;
n = pow(2, k);
rec(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << (b[i][j] ? '+' : '*');
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
char arr[512][513];
char sam[513];
int main(void) {
int k, y = 1, i, j, t;
scanf("%d", &k);
arr[0][0] = '+';
for (i = 0; i < k; i++, y *= 2) {
for (j = 0; j < y; j++) {
strcpy(sam, arr[j]);
strcpy(arr[j] + y, sam);
strcpy(arr[j + y], arr[j]);
for (t = y; t < 2 * y; t++) {
if (arr[j + y][t] == '+')
arr[j + y][t] = '*';
else
arr[j + y][t] = '+';
}
}
}
for (i = 0; i < y; i++) printf("%s\n", arr[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char arr[1000][1000];
int kk;
void fill(int i, int j, bool inv) {
if (inv) {
arr[i][j] = '+';
arr[i + 1][j] = '+';
arr[i][j + 1] = '+';
arr[i + 1][j + 1] = '*';
} else {
arr[i][j] = '*';
arr[i + 1][j] = '*';
arr[i][j + 1] = '*';
arr[i + 1][j + 1] = '+';
}
}
void solve(int k, int i, int j, bool inv) {
if (k == 2) {
fill(i, j, inv);
fill(i + 2, j, inv);
fill(i, j + 2, inv);
fill(i + 2, j + 2, !inv);
return;
}
int k1 = k - 1;
solve(k1, i, j, !inv);
solve(k1, i, j + (1 << k1), !inv);
solve(k1, i + (1 << k1), j, !inv);
solve(k1, i + (1 << k1), j + (1 << k1), inv);
}
void print(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) printf("%c", arr[i][j]);
printf("\n");
}
}
int main() {
int k;
cin >> k;
if (k == 0) {
printf("+\n");
return 0;
}
if (k == 1) {
fill(0, 0, false);
print(2);
return 0;
}
solve(k, 0, 0, false);
print(1 << k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1024 + 100;
bool a[maxn][maxn];
void build(int n) {
if (n == 1) {
a[1][1] = 1;
return;
}
build(n - 1);
for (int i = 0; i < (1 << (n - 1)); i++)
for (int j = (1 << (n - 1)); j < (1 << n); j++)
a[i][j] = !a[i][(1 << n) - j - 1];
for (int i = (1 << (n - 1)); i < (1 << n); i++)
for (int j = 0; j < (1 << n); j++)
if (j < (1 << (n - 1)))
a[i][j] = a[i - (1 << (n - 1))][j];
else
a[i][j] = a[i - (1 << (n - 1))][(1 << n) - 1 - j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n == 0) {
cout << "*" << endl;
return 0;
}
build(n);
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) cout << (a[i][j] ? '*' : '+');
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, k;
char a[1000][1000];
void solve(int n) {
if (n == 1) {
a[1][1] = '+';
return;
}
solve(n / 2);
int m = n / 2;
for (i = 1; i <= m; i++)
for (j = 1; j <= m; j++) {
a[j][n - i + 1] = a[i][j];
a[m + i][j] = a[i][j];
}
for (i = 1; i <= m; i++)
for (j = m + 1; j <= n; j++) a[i + m][j] = ((a[i][j] == '+') ? '*' : '+');
}
int main() {
cin >> k;
int x = 1;
for (i = 1; i <= k; i++) x *= 2;
solve(x);
for (i = 1; i <= x; i++) {
for (j = 1; j <= x; j++) cout << a[i][j];
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string a[2048];
void copy(int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i].push_back('-');
for (int i = n; i < 2 * n; i++)
for (int j = 0; j < 2 * n; j++) a[i].push_back('-');
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
a[i][j + n] = a[i][j];
a[i + n][j] = a[i][j];
if (a[i][j] == '+')
a[i + n][j + n] = '*';
else
a[i + n][j + n] = '+';
}
}
int main() {
int k;
cin >> k;
int k2 = 1;
if (k == 0) {
cout << '+';
return 0;
}
a[0] = "+*";
a[1] = "++";
for (int i = 0; i < k - 1; i++) {
k2 *= 2;
copy(k2);
}
k2 *= 2;
for (int i = 0; i < k2; i++) cout << a[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX_SZ = 2069;
int main() {
ios_base::sync_with_stdio(false);
int k;
cin >> k;
static bool arr[MX_SZ][MX_SZ];
for (int i = 0; i <= k; i++) {
for (int j = 0; j < (1 << i); j++) {
for (int k = 0; k < (1 << i); k++) {
arr[j][(1 << i) + k] = arr[j][k];
}
}
for (int j = 0; j < (1 << i); j++) {
for (int k = 0; k < (1 << i); k++) {
arr[(1 << i) + j][k] = arr[j][k];
}
}
for (int j = 0; j < (1 << i); j++) {
for (int k = 0; k < (1 << i); k++) {
arr[(1 << i) + j][(1 << i) + k] = !arr[j][k];
}
}
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (arr[i][j]) {
cout << '*';
} else {
cout << '+';
}
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
string dp[800][800];
int cnt[800];
string reverse_str(const string &base) {
string res;
for (int i = 0; i < base.size(); ++i) {
if (base[i] == '+')
res.push_back('*');
else
res.push_back('+');
}
return res;
}
void init() {
for (int x = 0; x < 9; ++x)
for (int i = 0; i < (1 << x); ++i) {
int f = cnt[x + 1]++;
dp[x + 1][f] = dp[x][i] + dp[x][i];
f = cnt[x + 1]++;
dp[x + 1][f] = dp[x][i] + reverse_str(dp[x][i]);
}
}
int main(int argc, char *argv[]) {
dp[0][0] = "+";
init();
int k;
cin >> k;
for (int i = 0; i < (1 << k); ++i) cout << dp[k][i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
volatile bool isLocalTestEnabled = 0;
bool g_isLocalPrintEnabled = (bool)(0);
template <typename T>
void UpdateMin(T& a, const T b) {
a = std::min(a, b);
}
template <typename T>
void UpdateMax(T& a, const T b) {
a = std::max(a, b);
}
const long double Pi = std::atan(1.0L) * 4.0L;
static const long double Eps = 1.0e-09;
template <typename T>
bool IsEqual(const T a, const T b) {
return std::abs(a - b) < Eps;
}
template <typename T>
bool IsGreater(const T a, const T b) {
return a > b + Eps;
}
template <typename T>
bool IsLess(const T a, const T b) {
return a + Eps < b;
}
template <typename T>
bool IsGreaterEqual(const T a, const T b) {
return !IsLess(a, b);
}
template <typename T>
bool IsLessEqual(const T a, const T b) {
return !IsGreater(a, b);
}
template <typename T>
std::string ToStr(const T& val) {
std::ostringstream ostr;
ostr << val;
return ostr.str();
}
template <typename T>
bool FromStr(const std::string& str, T& val) {
std::istringstream istr(str);
istr >> val;
return !!istr;
}
template <typename T>
std::istream& operator>>(std::istream& ist, std::vector<T>& data) {
;
for (size_t i = 0; i < data.size(); i++) {
ist >> data[i];
}
return ist;
}
template <typename T>
T Read(std::istream& ist) {
;
T val;
ist >> val;
return val;
}
template <typename T>
std::ostream& operator<<(std::ostream& ost, const std::vector<T>& data) {
for (size_t i = 0; i < data.size(); i++) {
if (i != 0) {
ost << ' ';
}
ost << data[i];
}
return ost;
}
template <size_t id>
class StopWatch {};
size_t Pow2(size_t k) { return 1U << k; }
std::vector<std::vector<int32_t> > GetAns(const size_t k) {
if (k == 0) {
return std::vector<std::vector<int32_t> >(1, std::vector<int32_t>(1, 1));
}
std::vector<std::vector<int32_t> > p = GetAns(k - 1);
const size_t ps = p.size();
std::vector<std::vector<int32_t> > v(ps * 2, std::vector<int32_t>(ps * 2));
for (size_t i = 0; i < ps; i++) {
for (size_t j = 0; j < ps; j++) {
v[i][j] = p[i][j];
v[i][ps + j] = p[i][j];
v[ps + i][j] = p[i][j];
v[ps + i][ps + j] = -p[i][j];
}
}
return v;
}
std::vector<std::string> ToString(const std::vector<std::vector<int32_t> >& v) {
std::vector<std::string> s(v.size(), std::string(v.size(), ' '));
for (size_t i = 0; i < v.size(); i++) {
for (size_t j = 0; j < v[i].size(); j++) {
if (v[i][j] == 1) {
s[i][j] = '+';
} else if (v[i][j] == -1) {
s[i][j] = '*';
} else {
s[i][j] = '?';
}
}
}
return s;
}
bool Solve(std::istream& ist, std::ostream& ost, const bool multipleTestMode) {
StopWatch<1> sw;
(void)sw;
size_t k;
ist >> k;
if (multipleTestMode && !ist) return false;
if (!g_isLocalPrintEnabled) {
} else
std::cout << std::endl << "Next test" << std::endl;
const std::vector<std::vector<int32_t> > v = GetAns(k);
const std::vector<std::string> s = ToString(v);
for (size_t i = 0; i < s.size(); i++) {
ost << s[i] << std::endl;
};
return multipleTestMode;
}
int main(int argc, const char* argv[]) {
std::ios_base::sync_with_stdio(false);
std::istream* ist = &std::cin;
std::ostream* ost = &std::cout;
std::unique_ptr<std::istream> fileInput;
if (argc > 1) {
fileInput.reset(new std::ifstream(argv[1]));
if (!(*fileInput)) {
std::cout << "File not found: " << argv[1] << std::endl;
}
ist = fileInput.get();
}
Solve(*ist, *ost, false);
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
long long w;
};
long long MOD = 1000000007;
long long _MOD = 1000000009;
double EPS = 1e-10;
int a[512][512];
int main() {
a[0][0] = 1;
for (int k = 0; k < 9; k++) {
int n = 1 << k;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
a[n + i][j] = a[i][j];
a[i][n + j] = a[i][j];
a[n + i][n + j] = -a[i][j];
}
}
int k;
cin >> k;
int n = 1 << k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << (a[i][j] == 1 ? '+' : '*');
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[10][520][520];
void construct(long long int n) {
if (n == 0) {
arr[0][0][0] = 1;
return;
} else {
construct(n - 1);
long long int d = pow(2, n - 1);
for (long long int z = 0; z < 4; z++) {
long long int c = 1, rs, cs;
if (z == 0) {
rs = 0;
cs = 0;
} else if (z == 1) {
rs = 0;
cs = d;
} else if (z == 2) {
rs = d;
cs = 0;
} else if (z == 3) {
rs = d;
cs = d;
c = -1;
}
for (long long int i = rs; i < rs + d; i++) {
for (long long int j = cs; j < d + cs; j++) {
arr[n][i][j] = arr[n - 1][i - rs][j - cs] * c;
}
}
}
}
return;
}
void print(long long int n) {
long long int d = pow(2, n);
for (long long int i = 0; i < d; i++) {
for (long long int j = 0; j < d; j++) {
if (arr[n][i][j] == -1)
printf("*");
else if (arr[n][i][j] == 1)
printf("+");
}
printf("\n");
}
}
int main() {
long long int k;
cin >> k;
construct(k);
print(k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1 << 10][1 << 10];
void disp(int k) {
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if (arr[i][j] == 1)
printf("+");
else
printf("*");
}
printf("\n");
}
}
int main() {
int k;
cin >> k;
arr[0][0] = 1;
arr[0][1] = 1;
arr[1][0] = 1;
arr[1][1] = -1;
if (k == 1) {
disp(1);
return 0;
} else {
for (int i = 2; i <= k; i += 1) {
for (int j = 0; j < (1 << (i - 1)); j++) {
for (int k = (1 << (i - 1)); k < (1 << i); k++) {
arr[j][k] = arr[j][k - (1 << (i - 1))];
}
}
for (int j = (1 << (i - 1)); j < (1 << i); j++) {
for (int k = 0; k < (1 << (i - 1)); k++) {
arr[j][k] = arr[j - (1 << (i - 1))][k];
}
}
for (int j = (1 << (i - 1)); j < (1 << i); j++) {
for (int k = (1 << (i - 1)); k < (1 << i); k++) {
arr[j][k] = -arr[j - (1 << (i - 1))][k - (1 << (i - 1))];
}
}
}
disp(k);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int run = 1 << n;
for (int i = 0; i < run; i++) {
for (int j = 0; j < run; j++) {
if (__builtin_parity(i & j))
cout << '*';
else
cout << '+';
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string a[1 << 10];
string inv(string fff) {
string re;
for (int i = 0; i < fff.size(); i++) {
if (fff[i] == '+')
re.push_back('*');
else
re.push_back('+');
}
return re;
}
int main() {
int k;
cin >> k;
ios::sync_with_stdio(false);
a[0].push_back('+');
int n;
for (int i = 0; i < k; i++) {
n = 1 << i;
for (int i = 0; i < n; i++) {
a[i + n] = a[i] + inv(a[i]);
a[i] = a[i] + a[i];
}
}
n = 1 << k;
for (int i = 0; i < n; i++) {
cout << a[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string rev(string s) {
string res = "";
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '+') {
res += '*';
} else {
res += '+';
}
}
return res;
}
void solve() {
long long int n;
cin >> n;
if (n == 0) {
cout << "+" << endl;
return;
}
vector<string> v;
v.push_back("++");
v.push_back("+*");
while (n > 1) {
vector<string> nv;
for (int i = 0; i < v.size(); ++i) {
nv.push_back(v[i]);
nv[nv.size() - 1].append(v[i]);
}
for (int i = 0; i < v.size(); ++i) {
nv.push_back(v[i]);
nv[nv.size() - 1].append(rev(v[i]));
}
v = nv;
n--;
}
for (int i = 0; i < v.size(); ++i) cout << v[i] << endl;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m = 1, a[512][512];
int main() {
a[0][0] = 1, scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++)
for (int k = m * 2 - 1; k >= 0; k--) a[j][k] = a[j][k / 2];
for (int j = m; j < m * 2; j++)
for (int k = 0; k < m * 2; k++) a[j][k] = a[j - m][k];
for (int j = m; j < m * 2; j++)
for (int k = 1; k < m * 2; k += 2) a[j][k] ^= 1;
m *= 2;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++)
if (a[i][j] == 1)
putchar('+');
else
putchar('*');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool a[600][600];
int k, x = 0;
int main() {
cin >> k;
a[0][0] = 1;
for (int i = 0; i < k; i++) {
x = 1 << i;
for (int j = 0; j < (1 << i); j++) {
for (int l = 0; l < (1 << i); l++) {
a[j + x][l] = a[j][l];
a[j][l + x] = a[j][l];
a[j + x][l + x] = abs(a[j][l] - 1);
}
}
}
for (int j = 0; j < (1 << k); j++) {
for (int l = 0; l < (1 << k); l++) {
if (a[j][l] == 0)
cout << '*';
else
cout << '+';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int a[1000][1000];
using namespace std;
int main() {
a[0][0] = 1;
int c = 1;
for (int i = 1; i <= 9; i++) {
int nc = c * 2;
for (int j = 0; j < c; j++)
for (int k = c; k < nc; k++) a[j][k] = -a[j][nc - k - 1];
for (int j = c; j < nc; j++) {
for (int k = 0; k < c; k++) a[j][k] = a[j - c][k];
for (int k = c; k < nc; k++) a[j][k] = a[j][nc - k - 1];
}
c = nc;
}
int n;
scanf("%d", &n);
int l = 1 << n;
for (int i = 0; i < l; i++, puts(""))
for (int j = 0; j < l; j++) putchar(((a[i][j] == -1) ? ('*') : ('+')));
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const long long MOD = 1e9 + 7;
int n;
int main() {
cin >> n;
int k = 0, t0 = 0, t1 = 0;
int a[1025][1025];
a[1][1] = 1;
while (k < n) {
k++;
t1 = 1 << (k);
t0 = 1 << (k - 1);
int b[t1 + 1][t1 + 1];
for (int i = 1; i <= t0; i++) {
for (int j = 1; j <= t0; j++)
b[i][j] = b[i][t0 + j] = b[i + t0][j] = a[i][j];
}
for (int i = 1; i <= t0; i++)
for (int j = 1; j <= t0; j++) b[t0 + i][j + t0] = 1 - a[i][j];
for (int i = 1; i <= t1; i++)
for (int j = 1; j <= t1; j++) a[i][j] = b[i][j];
}
for (int i = 1; i <= (1 << n); i++) {
for (int j = 1; j <= (1 << n); j++)
if (a[i][j] == 1)
cout << "+";
else
cout << "*";
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int run = 1 << n;
for (int i = 0; i < run; i++) {
for (int j = 0; j < run; j++) {
if (__builtin_parity(i & j))
cout << '*';
else
cout << '+';
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
string invert(string s) {
for (int i = 0; i < s.length(); i++) {
s[i] = (s[i] == '+' ? '*' : '+');
}
return s;
}
vector<string> solve(int x) {
if (x == 1) {
vector<string> ans(2);
ans[0] = "+*";
ans[1] = "++";
return ans;
}
vector<string> prev = solve(x - 1);
vector<string> ans(1 << x);
int half = (1 << x) / 2;
for (int i = 0; i < half; i++) {
ans[i] = prev[i] + prev[i];
ans[i + half] = prev[i] + invert(prev[i]);
}
return ans;
}
vector<string> ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> k;
if (k == 0) {
cout << "+" << endl;
return 0;
}
ans = solve(k);
for (int i = 0; i < (1 << k); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 512 + 5;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
int k;
int a[N][N];
void rec(int n, int x, int y, int v) {
if (n == 1)
a[x][y] = v;
else {
rec(n / 2, x, y, v);
rec(n / 2, x + n / 2, y, v);
rec(n / 2, x, y + n / 2, v);
rec(n / 2, x + n / 2, y + n / 2, -v);
}
}
int main() {
scanf("%d", &k);
rec(1 << k, 1, 1, 1);
int i, j;
for (i = 1; i <= (1 << k); ++i) {
for (j = 1; j <= (1 << k); ++j) {
if (a[i][j] == 1)
printf("+");
else
printf("*");
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string inv(string str) {
string res = "";
for (int i = 0; i < (str.length()); ++i) {
if (str[i] == '+')
res += "*";
else
res += "+";
}
return res;
}
bool check(string a, string b) {
int sum = 0;
for (int i = 0; i < (a.length()); ++i) {
if (a[i] != b[i])
sum--;
else
sum++;
}
return sum == 0;
}
bool verify(vector<string> stuff) {
for (int i = 0; i < (int((stuff).size())); ++i) {
for (int j = i + 1; j < int((stuff).size()); j++) {
if (!check(stuff[i], stuff[j])) return false;
}
}
return true;
}
int main() {
cin.tie(0);
cout.tie(0);
int k;
int cnt = 1;
cin >> k;
if (k == 0) {
cout << "+" << endl;
return 0;
} else if (k == 1) {
cout << "++" << endl;
cout << "+*" << endl;
return 0;
} else if (k == 2) {
cout << "++**" << endl;
cout << "+*+*" << endl;
cout << "++++" << endl;
cout << "+**+" << endl;
return 0;
}
vector<string> stuff;
stuff.push_back("++**");
stuff.push_back("+*+*");
stuff.push_back("++++");
stuff.push_back("+**+");
for (int i = 3; i <= k; i++) {
vector<string> newstuff;
for (int i = 0; i < (int((stuff).size())); ++i) {
newstuff.push_back(stuff[i] + stuff[i]);
newstuff.push_back(stuff[i] + inv(stuff[i]));
}
stuff.clear();
for (int i = 0; i < (int((newstuff).size())); ++i)
stuff.push_back(newstuff[i]);
}
for (int i = 0; i < (int((stuff).size())); ++i) {
cout << stuff[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char a[1300][1300];
void solve() {
scanf("%d", &n);
a[1][1] = '+';
int sz = 1;
for (int rnd = 1; rnd <= n; ++rnd) {
for (int i = 1; i <= sz; ++i) {
for (int j = 1; j <= sz; ++j) {
if (a[i][j] == '+') {
a[i + sz][j] = a[i][j + sz] = '+';
a[i + sz][j + sz] = '*';
} else {
a[i + sz][j] = a[i][j + sz] = '*';
a[i + sz][j + sz] = '+';
}
}
}
sz <<= 1;
}
for (int i = 1; i <= sz; ++i) {
for (int j = 1; j <= sz; ++j) {
printf("%c", a[i][j]);
}
printf("\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > har[10];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
har[0].resize(1);
har[0][0].push_back(1);
for (int i = 1; i <= 9; i++) {
har[i].resize(1 << i);
int size = (1 << i) / 2;
for (int j = 0; j < (1 << i); j++) {
har[i][j].resize(1 << i);
for (int l = 0; l < (1 << i); l++) {
har[i][j][l] = har[i - 1][j % size][l % size];
if (j >= size && l >= size) har[i][j][l] ^= 1;
}
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) {
if (har[n][i][j])
cout << "+";
else
cout << "*";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
long long int t = bigmod(p, e / 2, M);
return (T)((t * t) % M);
}
return (T)((long long int)bigmod(p, e - 1, M) * (long long int)p) % M;
}
template <class T>
inline T bigexp(T p, T e) {
if (e == 0) return 1;
if (e % 2 == 0) {
long long int t = bigexp(p, e / 2);
return (T)((t * t));
}
return (T)((long long int)bigexp(p, e - 1) * (long long int)p);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int dx4[] = {1, 0, -1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
int month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
char dp[1005][1005];
int p, q, n;
int main() {
scanf("%d", &n);
dp[0][0] = '+';
for (int i = 1; i <= n; i++) {
q = bigexp(2, i - 1);
for (__typeof(q - 1) j = (0); j <= (q - 1); j++)
for (__typeof(q - 1) k = (0); k <= (q - 1); k++) {
dp[j][k + q] = dp[j][k];
dp[j + q][k] = dp[j][k];
if (dp[j][k] == '+')
dp[j + q][q + k] = '*';
else
dp[j + q][q + k] = '+';
}
}
p = bigexp(2, n);
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) printf("%c", dp[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k;
char a[620][620];
int main() {
ios_base::sync_with_stdio(false);
cin >> k;
if (k == 1) {
cout << "++" << endl << "+*";
return 0;
}
a[1][1] = a[1][2] = a[2][1] = '+';
a[2][2] = '*';
for (int i = 2; i <= k; i++) {
int hs = (1 << (i - 1));
for (int xi = hs + 1; xi <= 2 * hs; xi++)
for (int xj = 1; xj <= hs; xj++) a[xi][xj] = a[xi - hs][xj];
for (int xi = hs + 1; xi <= 2 * hs; xi++) {
int cnt = 1;
for (int xj = 1; xj <= hs; xj++)
a[xi][2 * hs - cnt + 1] = a[xi][xj], cnt++;
}
for (int xi = 1; xi <= hs; xi++) {
int cnt = 1;
for (int xj = 1; xj <= hs; xj++)
a[xi][2 * hs - cnt + 1] = a[xi][xj], cnt++;
}
for (int xi = 1; xi <= hs; xi++) {
for (int xj = hs + 1; xj <= 2 * hs; xj++)
if (a[xi][xj] == '+')
a[xi][xj] = '*';
else
a[xi][xj] = '+';
}
}
int sl = (1 << k);
for (int i = 1; i <= sl; i++) {
for (int j = 1; j <= sl; j++) cout << a[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<bool> > a(1 << n, vector<bool>(1 << n, 0));
for (int p = 0; p < n; p++) {
int k = (1 << (p));
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
a[i][j + k] = a[i][j];
a[i + k][j] = a[i][j];
a[i + k][j + k] = !a[i][j];
}
}
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < 1 << n; j++) {
if (a[i][j])
cout << '*';
else
cout << '+';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[2000][2000];
int n;
void build(int n) {
if (n == 0)
ans[0][0] = 1;
else {
build(n - 1);
for (int i = 0; i < (1 << (n - 1)); i++)
for (int j = (1 << (n - 1)); j < (1 << (n)); j++)
ans[i][j] = ans[i][j - (1 << (n - 1))];
for (int i = (1 << (n - 1)); i < (1 << (n)); i++)
for (int j = 0; j < (1 << (n - 1)); j++)
ans[i][j] = ans[i - (1 << (n - 1))][j];
for (int i = (1 << (n - 1)); i < (1 << (n)); i++)
for (int j = (1 << (n - 1)); j < (1 << (n)); j++)
ans[i][j] = 1 - ans[i - (1 << (n - 1))][j - (1 << (n - 1))];
}
}
int main() {
cin >> n;
build(n);
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++)
if (ans[i][j])
printf("+");
else
printf("*");
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
if (k == 0) return cout << "+\n", 0;
vector<string> ats = {"++", "+*"};
while (ats.size() < (1 << k)) {
auto cp = ats;
for (auto& s : cp)
for (auto& ch : s) ch = (ch == '+' ? '*' : '+');
for (int i = 0; i < cp.size(); i++) {
ats.push_back(ats[i] + cp[i]);
ats[i] += ats[i];
}
}
for (auto& s : ats) cout << s << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
char x[1000][1000];
int main() {
int a, b = 2;
x[1][1] = '+';
x[1][2] = '+';
x[2][1] = '+';
x[2][2] = '*';
cin >> a;
if (a == 0) {
cout << "+";
return 0;
}
while (a != 1) {
for (int i = 1; i <= b; i++)
for (int j = 1; j <= b; j++) {
x[i + b][j] = x[i][j];
x[i][j + b] = x[i][j];
if (x[i][j] == '+')
x[i + b][j + b] = '*';
else
x[i + b][j + b] = '+';
}
b = b * 2;
a--;
}
for (int i = 1; i <= b; i++) {
for (int j = 1; j <= b; j++) cout << x[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int ans[2][1010][1010];
int main() {
int n;
scanf("%d", &n);
int p = 0, q = 1;
ans[q][0][0] = 0;
for (int i = 0; i < n; i++) {
swap(p, q);
for (int j = 0; j < (1 << i); j++) {
for (int k = 0; k < (1 << i); k++) {
ans[q][j * 2][k * 2] = ans[p][j][k];
ans[q][j * 2][k * 2 + 1] = ans[p][j][k];
ans[q][j * 2 + 1][k * 2] = 1 - ans[p][j][k];
ans[q][j * 2 + 1][k * 2 + 1] = ans[p][j][k];
}
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) {
if (ans[q][i][j])
printf("+");
else
printf("*");
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 9;
int k;
bool ans[MAX][MAX];
void f(int n) {
if (n == 1) {
ans[0][0] = 1;
return;
}
int m = n / 2;
f(m);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
int x = ans[i][j];
ans[i + m][j] = x;
ans[i][j + m] = x;
ans[i + m][j + m] = !x;
}
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
cin >> k;
int n = 1 << k;
f(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << (ans[i][j] ? '+' : '*');
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string inverse(string s) {
string ret(((int)(s).size()), 0);
for (int i = 0; i < ((int)(s).size()); ++i) {
ret[i] = s[i] == '*' ? '+' : '*';
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<string> ans = {"+"};
for (int i = 1; i <= n; ++i) {
vector<string> nans = ans;
int m = ((int)(ans).size());
for (int i = 0; i < m; ++i) {
string p = inverse(ans[i]);
nans.push_back(p);
}
for (int i = 2 * m - 1; i >= 0; --i) {
nans[i] += nans[i % m];
}
ans = nans;
}
for (const string& p : ans) cout << p << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 555;
int a[N][N];
int n, k;
void Work(int Line, int i, int j, int col) {
if (!Line) {
a[i][j] = col;
return;
}
Work(Line - 1, i, j, col);
Work(Line - 1, i, j + (1 << (Line - 1)), col);
Work(Line - 1, i + (1 << (Line - 1)), j, col);
Work(Line - 1, i + (1 << (Line - 1)), j + (1 << (Line - 1)), -col);
}
int main() {
scanf("%d", &k);
n = 1 << k;
Work(k, 1, 1, -1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (a[i][j] > 0)
printf("+");
else
printf("*");
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
while (b) {
T c = a % b;
a = b;
b = c;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
assert(a / gcd(a, b) <= numeric_limits<T>::max() / b);
return a * (b / gcd(a, b));
}
class out {
public:
template <typename T>
out &operator()(const T &t) {
cout << t << ' ';
return *this;
}
template <typename T1, typename T2>
out &operator()(const pair<T1, T2> &t) {
cout << '(' << t.first << ',' << t.second << ')' << ' ';
return *this;
}
};
template <typename iter>
inline void print_(iter beg, iter end) {
cout << endl;
for_each(beg, end, out());
cout << endl;
}
template <typename T>
inline void print_(const T &t) {
cout << endl << t << endl;
}
inline void print_(const char *t) { cout << endl << t << endl; }
template <typename T, unsigned int M>
inline void print_(const T (&t)[M]) {
cout << endl;
for (unsigned int i = 0; i < M; ++i) {
cout << t[i] << ' ';
}
cout << endl;
}
template <typename T, unsigned int M>
inline void print_(const T (&t)[M], unsigned int c) {
cout << endl;
for (unsigned int i = 0; i < c; ++i) {
cout << t[i] << ' ';
}
cout << endl;
}
template <typename T, unsigned int M, unsigned int N>
inline void print_(const T (&t)[M][N]) {
cout << endl;
for (unsigned int i = 0; i < M; ++i) {
for (unsigned int j = 0; j < N; ++j) {
cout << t[i][j] << ' ';
}
cout << endl;
}
}
template <typename T, unsigned int M, unsigned int N>
inline void print_(const T (&t)[M][N], unsigned int r, unsigned int c) {
cout << endl;
for (unsigned int i = 0; i < r; ++i) {
for (unsigned int j = 0; j < c; ++j) {
cout << t[i][j] << ' ';
}
cout << endl;
}
}
template <class T>
size_t BKDRHash(const T *str) {
register size_t hash = 0;
while (size_t ch = (size_t)*str++) {
hash = hash * 131 + ch;
}
return hash;
}
template <typename T>
T powxy(T x, int y) {
T r;
for (r = 1; y > 0; --y) r *= x;
return r;
}
template <typename T>
T factorial(T n) {
T r;
for (r = 1; n > 0; --n) r *= n;
return r;
}
int n;
int matrix[512][512];
void construct(int exp) {
if (!exp) {
matrix[0][0] = 1;
return;
} else {
int sz = 1 << exp;
construct(exp - 1);
for (int i = 0; i < sz / 2; ++i) {
copy(matrix[i], matrix[i] + sz / 2, matrix[i] + sz / 2);
copy(matrix[i], matrix[i] + sz / 2, matrix[i + sz / 2]);
}
for (int i = 0; i < sz / 2; ++i) {
for (int j = sz / 2; j < sz; ++j) {
matrix[i + sz / 2][j] = 1 ^ matrix[i][j];
}
}
}
}
void check() {
int sz = 1 << n;
for (int i = 0; i < sz; ++i) {
for (int ii = i + 1; ii < sz; ++ii) {
int t = 0;
for (int j = 0; j < sz; ++j) {
t += matrix[i][j] == matrix[ii][j] ? 1 : -1;
}
if (t) {
int fault[] = {i, ii, t};
(fault);
}
}
}
}
int main() {
scanf("%d", &n);
construct(n);
(matrix, 1 << n, 1 << n);
check();
for (int i = 0; i < 1 << n; ++i) {
for (int j = 0; j < 1 << n; ++j) {
putchar(matrix[i][j] ? '+' : '*');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int i, N = pow(2, n);
char **h = (char **)calloc(N, sizeof(char *));
for (i = 0; i < N; i++) {
h[i] = (char *)calloc(N, sizeof(char));
}
int ii, xx, yy;
h[0][0] = '1';
for (ii = 2; ii <= N; ii *= 2) {
for (xx = 0; xx < (ii / 2); ++xx) {
for (yy = (ii / 2); yy < ii; ++yy) {
h[xx][yy] = h[xx][yy - (ii / 2)];
}
}
for (yy = 0; yy < (ii / 2); ++yy) {
for (xx = (ii / 2); xx < ii; ++xx) {
h[xx][yy] = h[xx - (ii / 2)][yy];
}
}
for (xx = (ii / 2); xx < ii; ++xx) {
for (yy = (ii / 2); yy < ii; ++yy) {
h[xx][yy] = h[xx - (ii / 2)][yy - (ii / 2)];
if (h[xx][yy] == '1') {
h[xx][yy] = '0';
} else {
h[xx][yy] = '1';
}
}
}
}
for (xx = 0; xx < N; ++xx) {
for (yy = 0; yy < N; ++yy) {
printf("%c", h[xx][yy] == '1' ? '+' : '*');
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1050;
int k;
int a[MAX][MAX];
void mprint(int a[MAX][MAX], int M) {
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
if (a[i][j])
cout << "+";
else
cout << "*";
}
cout << "\n";
}
}
void hadam_rec(int a[MAX][MAX], int m, int M) {
if (m < M) {
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
a[i + m][j] = a[i][j];
a[i][j + m] = a[i][j];
a[i + m][j + m] = !a[i][j];
}
}
hadam_rec(a, 2 * m, M);
}
}
void solve() {
cin >> k;
int m = 1;
int M = 1 << k;
a[0][0] = 1;
hadam_rec(a, m, M);
mprint(a, M);
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.