solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 10;
string s;
int sol[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n >> s;
int last1, last2, counter1, counter2;
bool can;
for (char i = '0'; i <= '9'; ++i) {
last1 = last2 = i;
counter1 = counter2 = 0;
can = false;
for (int j = 0; j < n; ++j) sol[j] = 0;
for (int j = n - 1; j >= 0; --j)
if (s[j] <= i and !sol[j]) {
if (s[j] <= last1) {
sol[j] = 1;
last1 = s[j];
counter1++;
}
}
for (int j = 0; j < n; ++j)
if (s[j] >= i and !sol[j]) {
if (s[j] >= last2) {
sol[j] = 2;
last2 = s[j];
counter2++;
}
}
if (counter1 + counter2 == n) {
can = true;
break;
}
}
if (can) {
for (int i = 0; i < n; ++i) cout << sol[i];
cout << '\n';
} else {
cout << "-\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
char s[1000];
int main() {
while (~scanf("%s", s)) {
int sum1 = 0;
int flag = 0;
for (int i = 0; i < strlen(s); i++) {
if (flag == 0 && s[i] == '1') flag = 1;
if (flag == 1 && s[i] == '0') {
sum1++;
}
}
if (sum1 >= 6) {
printf("yes\n");
} else
printf("no\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[1003][1003];
long long dp1[1003][1003];
long long dp2[1003][1003];
long long dp3[1003][1003];
long long dp4[1003][1003];
int main() {
int i, j, k, m, n;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp1[i][j] = max(dp1[i - 1][j], dp1[i][j - 1]) + a[i][j];
}
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
dp2[i][j] = max(dp2[i + 1][j], dp2[i][j + 1]) + a[i][j];
}
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++) {
dp3[i][j] = max(dp3[i + 1][j], dp3[i][j - 1]) + a[i][j];
}
for (int i = 1; i <= n; i++)
for (int j = m; j >= 1; j--) {
dp4[i][j] = max(dp4[i - 1][j], dp4[i][j + 1]) + a[i][j];
}
long long ans = 0;
for (int i = 2; i < n; i++)
for (int j = 2; j < m; j++) {
if (dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1] > ans)
ans = dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1];
if (dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j] > ans)
ans = dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j];
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[5000 + 5];
bool dp[5000 + 5];
int lg(int n) { return n == 1 ? 0 : 1 + lg(n / 2); }
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1), k = lg(n);
dp[0] = 1;
for (int i = 1; i <= n - (1 << k) + 1; i++) {
for (int msk = 0; msk <= (1 << k) - 1; msk++)
if (dp[msk])
for (int b = 0; b <= k - 1; b++) dp[msk | (1 << b)] = 1;
char c = 'z';
for (int msk = 0; msk <= (1 << k) - 1; msk++)
if (dp[msk]) c = min(c, s[i + msk]);
for (int msk = 0; msk <= (1 << k) - 1; msk++)
if (s[i + msk] != c) dp[msk] = 0;
putchar(c);
}
puts("");
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
unsigned long long x;
string s2;
cin >> x >> s2;
unsigned long long len = s2.size();
vector<char> s;
for (char i : s2) s.push_back(i);
for (unsigned long long i = 1; i <= x; i++) {
unsigned long long v = s[i - 1] - '1';
if (s.size() < x) {
vector<char> ss(s.begin() + i, s.end());
for (unsigned long long it = 0; it < v; it++)
s.insert(s.end(), ss.begin(), ss.end());
}
len = (len + (len - i) * v + 1000000007ll) % 1000000007ll;
}
cout << ((len + 1000000007ll) % 1000000007ll + 1000000007ll) % 1000000007ll
<< endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int vis[2000];
int check(int i, int a[]) {
while (!vis[i]) {
vis[i] = 1;
i = a[i];
}
return i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
cout << check(i, a) << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, m, l, r, ar, id = 0;
cin >> n >> m;
vector<int> vc;
for (int i = 1; i <= n; i++) {
cin >> ar;
vc.push_back(ar);
}
sort(vc.begin(), vc.end());
for (int i = 1; i <= m; i++) {
cin >> ar;
l = n - (lower_bound(vc.begin(), vc.end(), i) - vc.begin());
id = max(id, (l - 1) / ar + 1);
}
l = 1;
for (int i = 0; i < n; i++) {
G[l].push_back(vc[i]);
l = (l == id) ? 1 : l + 1;
}
cout << id << endl;
for (int i = 1; i <= id; i++) {
cout << G[i].size() << " ";
for (int v : G[i]) cout << v << " ";
cout << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool happyg[110] = {};
bool happyb[110] = {};
int main() {
int N, M;
cin >> N >> M;
int B, G;
cin >> B;
int b, g;
for (int i = 0; i < B; i++) {
cin >> b;
happyb[b] = true;
}
cin >> G;
for (int i = 0; i < G; i++) {
cin >> g;
happyg[g] = true;
}
for (int i = 0; i < 1000000; i++) {
bool t = happyb[i % N] | happyg[i % M];
happyb[i % N] = t;
happyg[i % M] = t;
}
bool happy = true;
for (int i = 0; i < N; i++) {
happy &= happyb[i];
}
for (int i = 0; i < M; i++) {
happy &= happyg[i];
}
if (happy) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<int> v(4);
v[0] = 1;
v[1] = 8;
v[2] = 6;
v[3] = 9;
sort(v.begin(), v.end());
unordered_map<int, int> mp;
int n = s.length();
do {
int x = v[0] * 1000 + v[1] * 100 + v[2] * 10 + v[3];
int m = x % 7;
mp[m] = x;
} while (next_permutation(v.begin(), v.end()));
vector<int> count(10);
for (int i = 0; i < s.length(); i++) {
int x = s[i] - '0';
count[x]++;
}
s = "";
count[1]--;
count[6]--;
count[8]--;
count[9]--;
int r = 0;
for (int i = 1; i < 10; i++) {
while (count[i]--) {
r *= 10;
r += i;
r %= 7;
char ch = 48 + i;
s.push_back(ch);
}
}
int t = n - 4 - count[0];
if (t > 0) {
r *= (10000);
r %= 7;
}
int x = mp[r];
if (r != 0) x = mp[7 - r];
string temp = "";
while (x != 0) {
char ch = 48 + x % 10;
x /= 10;
temp.push_back(ch);
}
reverse(temp.begin(), temp.end());
s += temp;
while (count[0]--) {
char ch = 48;
s.push_back(ch);
}
cout << s << endl;
return;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int mod = (int)1e9 + 7;
const long long INF = 10000005;
const int N = 100005;
int a[N];
int f[N];
int main() {
int n, k, k1 = 1;
cin >> n >> k;
for (int(i) = 0; (i) < (n); ++(i)) cin >> a[i];
int r = 1, l = 1;
f[a[0]] = 1;
while (r < n && k1 < k) {
if (f[a[r]] == 0) k1++;
f[a[r]]++;
r++;
}
if (k1 == k) {
while (f[a[l - 1]] > 1) {
f[a[l - 1]]--;
l++;
}
cout << l << " " << r << endl;
} else
cout << -1 << " " << -1 << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int **b;
b = new int *[n];
for (int i = 0; i < n; i++) b[i] = new int[2];
for (int i = 0; i < n; i++) {
cin >> b[i][0];
cin >> b[i][1];
}
int max_h = b[0][1];
int max_i = 0;
int sum = 0;
int max_h_2 = 1;
for (int i = 0; i < n; i++) {
sum = sum + b[i][0];
if (max_h < b[i][1]) {
max_h = b[i][1];
max_i = i;
}
}
for (int i = 0; i < n; i++) {
if (max_h_2 <= b[i][1] && i != max_i) max_h_2 = b[i][1];
}
for (int i = 0; i < n; i++) {
int w = sum - b[i][0];
int h;
if (b[i][1] != max_h)
h = max_h;
else
h = max_h_2;
cout << w * h << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string rec(string k, string st) {
string ans = k + st;
string ans1 = st + k;
string ans2 = min(ans, ans1);
return ans2;
}
bool chfunc(string &a, string &b) {
if (a + b > b + a)
return true;
else
return false;
}
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end(), chfunc);
string st = v[0];
for (int i = 1; i < n; i++) {
st = rec(v[i], st);
}
cout << st << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x1;
int y1;
int x2;
int y2;
} l[150000], r[150000], middle[150000], a[150000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x1 >> a[i].y1 >> a[i].x2 >> a[i].y2;
}
l[0] = a[0];
for (int i = 1; i < n - 1; i++) {
l[i].x1 = max(l[i - 1].x1, a[i].x1);
l[i].y1 = max(l[i - 1].y1, a[i].y1);
l[i].x2 = min(l[i - 1].x2, a[i].x2);
l[i].y2 = min(l[i - 1].y2, a[i].y2);
}
if (l[n - 2].x1 <= l[n - 2].x2 && l[n - 2].y1 <= l[n - 2].y2) {
printf("%d %d\n", l[n - 2].x1, l[n - 2].y1);
return 0;
}
r[n - 1] = a[n - 1];
for (int i = n - 2; i > 0; i--) {
r[i].x1 = max(r[i + 1].x1, a[i].x1);
r[i].y1 = max(r[i + 1].y1, a[i].y1);
r[i].x2 = min(r[i + 1].x2, a[i].x2);
r[i].y2 = min(r[i + 1].y2, a[i].y2);
}
if (r[1].x1 <= r[1].x2 && r[1].y1 <= r[1].y2) {
printf("%d %d\n", r[1].x1, r[1].y1);
return 0;
}
for (int i = 1; i < n - 1; i++) {
middle[i].x1 = max(l[i - 1].x1, r[i + 1].x1);
middle[i].y1 = max(l[i - 1].y1, r[i + 1].y1);
middle[i].x2 = min(l[i - 1].x2, r[i + 1].x2);
middle[i].y2 = min(l[i - 1].y2, r[i + 1].y2);
if (middle[i].x1 <= middle[i].x2 && middle[i].y1 <= middle[i].y2) {
printf("%d %d\n", middle[i].x1, middle[i].y1);
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
vector<int> a(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> a[i];
int up = 30 * n + 10;
vector<vector<int>> g(up);
map<int, int> mp;
int cnt = 0;
vector<int> ok(up, 0);
vector<int> t(up, 0);
auto add = [&](int x, int y) {
if (!mp.count(x)) mp[x] = ++cnt;
if (!mp.count(y)) mp[y] = ++cnt;
g[mp[x]].push_back(mp[y]);
};
for (int i = 1; i <= n; i++) {
if (!mp.count(a[i])) mp[a[i]] = ++cnt;
t[mp[a[i]]] = i;
while (a[i] > 0) {
for (int j = 0;; j++)
if ((1 << j) >= a[i]) {
add((1 << j) - a[i], a[i]);
a[i] = (1 << j) - a[i];
break;
}
}
}
int x = -1, y = -1, m = 0;
vector<int> mx_dep(up, 0);
vector<int> id(up, 0);
function<void(int, int)> dfs = [&](int u, int d) {
if (ok[u] == 1) return;
ok[u] = 1;
mx_dep[u] = d;
id[u] = t[u];
int mx1 = -1, id1 = -1;
int mx2 = -1, id2 = -1;
for (auto v : g[u]) {
if (ok[v] == 1) continue;
dfs(v, d + 1);
if (mx_dep[v] > mx_dep[u]) {
mx_dep[u] = mx_dep[v];
id[u] = id[v];
}
if (mx_dep[v] > mx1) {
mx2 = mx1;
id2 = id1;
mx1 = mx_dep[v];
id1 = id[v];
} else if (mx_dep[v] > mx2) {
mx2 = mx_dep[v];
id2 = id[v];
}
}
if (t[u] > 0 && mx1 != -1 && mx2 == -1 && mx1 - d > m) {
x = t[u];
y = id1;
m = mx1 - d;
}
if (mx1 != -1 && mx2 != -1 && mx1 + mx2 - d * 2 > m) {
x = id1;
y = id2;
m = mx1 + mx2 - d * 2;
}
};
dfs(mp[0], 1);
cout << x << ' ' << y << ' ' << m << '\n';
return 0;
}
| 19 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int F0 = 0;
int F1 = 1;
int temp;
int F2 = 1;
int a, b, c;
if (n >= 0 && n < 1000000000) {
int target = n;
while (F2 < target) {
F2 = F1 + F0;
F0 = F1;
F1 = F2;
}
if (target == F2) {
a = F0;
temp = F1 - F0;
if (temp < 0) temp = 0;
b = a - temp;
if (b < 0) b = 0;
c = temp - b;
printf("%d %d %d", c, b, a);
} else if (target == 0) {
a = b = c = 0;
printf("%d %d %d", c, b, a);
} else {
printf("I'm too stupid to solve this problem");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long int n, m, a, b;
int main() {
cin >> n >> m >> a >> b;
if (n % m == 0) {
cout << 0 << endl;
} else {
long long int p = n % m;
long long int q = m - p;
cout << min(q * a, p * b) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7005;
int n, m, K;
int p[200000];
int L[N], R[N], C[N], V[N];
int LL[N], RR[N];
int cnt[1000005], res;
void work() {
int i, j, x, y;
scanf("%d%d", &n, &m);
for (i = 0; 1 << i < 200000; ++i) p[1 << i] = 1;
for (i = 1; i < 200000; ++i) p[i] += p[i - 1] + 1;
while (m--) {
scanf("%d", &j);
if (j == 1) {
++K;
scanf("%d%d%d%d", &C[K], &L[K], &R[K], &V[K]);
} else {
scanf("%d%d", &x, &y);
LL[x] = RR[x] = y;
for (j = x + 1; j <= n; ++j) {
LL[j] = p[LL[j - 1] - 1] + 1;
RR[j] = p[RR[j - 1]];
}
for (j = 1; j <= K; ++j) {
if (C[j] >= x) {
if (min(R[j], RR[C[j]]) >= max(L[j], LL[C[j]])) {
if (cnt[V[j]]++ == 0) ++res;
}
}
}
printf("%d\n", res);
for (j = 1; j <= K; ++j) {
if (C[j] >= x) {
if (min(R[j], RR[C[j]]) >= max(L[j], LL[C[j]])) {
if (!--cnt[V[j]]) --res;
}
}
}
}
}
}
int main() {
work();
return 0;
}
| 16 |
#include <bits/stdc++.h>
unsigned long long n, q, tmp, kt[100000], a[100000], i, j;
using namespace std;
int main() {
bool ck;
cin >> q;
while (q--) {
cin >> n;
tmp = 0;
memset(kt, 0, 15000);
for (i = 1; i <= n; i++) {
cin >> a[i];
kt[a[i]] = 1;
}
for (i = 1; i <= 1024; i++) {
ck = true;
for (j = 1; j <= n; j++) {
unsigned long long k = i ^ a[j];
if (kt[k] != 1) {
ck = false;
break;
}
}
if (ck == true && tmp == 0) {
cout << i << endl;
tmp = 1;
break;
}
}
if (tmp == 0) cout << -1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
int INF = 1000000005;
long long INFF = 1000000000000000005LL;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
long long power(long long x, long long y) {
if (y == 0) return 1;
return x * power(x, y - 1);
}
bool prime[1000005];
long long a[100005];
vector<int> ch[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= 1000004; p++)
if (prime[p] == true)
for (long long i = p * p; i <= 1000004; i += p) prime[i] = false;
long long ans = 1;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (long long j = 2; j <= a[i]; j++) {
if (prime[a[i]]) {
ch[a[i]].push_back(1);
break;
}
if (prime[j]) {
long long k = 0;
while (a[i] % j == 0) {
a[i] /= j;
k++;
}
if (k) {
ch[j].push_back(k);
}
}
}
}
for (int i = 2; i <= 200000; i++) {
if (prime[i]) {
long long second = 1e9, first = 1e9;
if (ch[i].size() == n - 1) {
for (auto u : ch[i]) {
first = min(first, (long long)u);
}
if (first != 1e9) {
ans *= power(i, first);
}
} else if (ch[i].size() == n) {
for (auto u : ch[i]) {
if (u < first) {
second = first;
first = u;
} else if (u < second)
second = u;
}
if (second != 1e9) {
ans *= power(i, second);
}
}
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
int reach[5000 + 1];
bool CHECK[5000 + 1];
list<pair<int, int> > adj[5000];
int child[5000];
vector<int> res;
void foo(int s) {
memset(reach, 0, sizeof reach);
reach[0] = 1;
int upperB = 0;
int counter = 1;
for (list<pair<int, int> >::iterator it = adj[s].begin(); it != adj[s].end();
it++) {
counter++;
for (int i = 0; i <= upperB; i++)
if (reach[i] && reach[i] < counter) {
if (reach[i + it->second])
reach[i + it->second] = min(reach[i + it->second], counter);
else
reach[i + it->second] = counter;
upperB = min(N / 2, max(upperB, i + it->second));
}
}
for (int i = 1; i <= N / 2 - (N % 2 == 0); i++)
if (reach[i] && CHECK[i] == 0) {
res.push_back(i);
if (i != N - i - 1) res.push_back(N - i - 1);
CHECK[i] = CHECK[N - i - 1] = 1;
}
}
int getSub(int s, int a) {
if (child[s] == 1) return 1;
int tot = 0;
for (list<pair<int, int> >::iterator it = adj[s].begin(); it != adj[s].end();
it++)
if (it->first != a) {
if (!it->second) it->second = getSub(it->first, s);
tot += it->second;
}
return tot + 1;
}
int main() {
scanf("%d", &N);
int i, a, b;
for (i = 0; i < N - 1; i++) {
scanf("%d %d", &a, &b);
adj[a - 1].push_back(make_pair(b - 1, 0));
adj[b - 1].push_back(make_pair(a - 1, 0));
child[a - 1]++;
child[b - 1]++;
}
for (i = 0; i < N; i++)
for (list<pair<int, int> >::iterator it = adj[i].begin();
it != adj[i].end(); it++) {
if (!it->second) it->second = getSub(it->first, i);
}
for (i = 0; i < N; i++)
if (child[i] > 1) {
foo(i);
}
printf("%d\n", res.size());
sort(res.begin(), res.end());
for (vector<int>::iterator it = res.begin(); it != res.end(); it++)
printf("%d %d\n", *it, N - 1 - *it);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long pows[51];
long long sumpows[51];
void solve() {
long long a, b, m;
cin >> a >> b >> m;
if (a == b) {
cout << 1 << " " << a << "\n";
return;
}
for (int terms = 2; terms < 51; terms++) {
if (pows[terms] >= 1e18 / a) break;
long long sum = pows[terms - 2] * a;
int extra = terms - 2;
if (sum >= 1e18 - sumpows[extra]) break;
sum += pows[extra];
if (b < sum) break;
long long b2 = b - sum;
vector<long long> ans(terms - 1, 1);
for (long long i = terms - 2; i >= 1; i--) {
long long po = pows[i - 1];
long long req = b2 / po;
long long coeff = min(m - 1, req);
ans[terms - 2 - i] += coeff;
b2 -= po * coeff;
}
if (b2 > m - 1) continue;
ans.back() = b2 + 1;
cout << terms << " ";
long long cum = a;
cout << a << " ";
for (int i = 0; i < terms - 1; i++) {
a = cum + ans[i];
cout << a << " ";
cum += a;
}
assert(a == b);
cout << "\n";
return;
}
cout << "-1\n";
;
}
int main() {
pows[0] = 1;
sumpows[0] = 1;
for (int i = 1; i < 51; i++) {
pows[i] = pows[i - 1] << 1;
sumpows[i] = pows[i] + sumpows[i - 1];
}
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
const int N = 45;
using namespace std;
int f[N][N][N][N], up[N][N];
int n, m, Q, a[N][N];
char cc;
void READ() {
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i++) {
scanf("\n");
for (int j = 1; j <= m; j++) {
scanf("%c", &cc);
a[i][j] = cc - '0';
}
}
}
void INIT() {
for (int i = 1; i <= m; i++)
if (a[1][i] == 0)
up[1][i] = 1;
else
up[1][i] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1)
up[i][j] = 0;
else {
if (a[i - 1][j] == 0)
up[i][j] = up[i - 1][j] + 1;
else
up[i][j] = 1;
}
}
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int k = 0; k <= n; k++)
for (int l = 0; l <= m; l++) f[i][j][k][l] = 0;
for (int ax = 1; ax <= n; ax++) {
for (int ay = 1; ay <= m; ay++) {
for (int bx = ax; bx <= n; bx++) {
for (int by = ay; by <= m; by++) {
f[ax][ay][bx][by] = f[ax][ay][bx - 1][by] + f[ax][ay][bx][by - 1] -
f[ax][ay][bx - 1][by - 1];
int now = bx - ax + 1;
for (int i = by; i >= ay; i--) {
now = min(up[bx][i], now);
f[ax][ay][bx][by] += now;
}
}
}
}
}
}
void SOLVE() {
int A, B, C, D;
while (Q--) {
scanf("%d%d%d%d", &A, &B, &C, &D);
printf("%d\n", f[A][B][C][D]);
}
}
int main() {
READ();
INIT();
SOLVE();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200007;
int n;
int perm[3][N];
struct fen {
int n;
int v[N];
void build(int s) {
n = s;
memset(v, 0, sizeof v);
}
void insert(int i, int x) {
for (i += 2; i <= n + 3; i += (i & -i)) v[i] += x;
}
int get(int i) {
int res = 0;
for (i += 2; i > 0; i -= (i & -i)) res += v[i];
return res;
}
};
void convert(int k, int n) {
fen bit;
bit.build(n);
for (int i = 0; i < n; i++) {
int p = bit.get(perm[k][i]);
bit.insert(perm[k][i], 1);
perm[k][i] = (perm[k][i] - p);
}
}
int getPos(fen& bit, int i) {
int lo = 0;
int hi = bit.n;
while (lo < hi) {
int mid = (hi + lo) / 2;
if (mid - bit.get(mid) >= i)
hi = mid;
else
lo = mid + 1;
}
return lo;
}
int main() {
scanf("%d", &n);
for (int k = 0; k < 2; k++) {
for (int i = 0; i < n; i++) scanf("%d", &perm[k][i]);
convert(k, n);
}
fen bit;
bit.build(n);
int car = 0;
for (int i = 1; i <= n; i++) {
perm[2][n - i] = car;
for (int k = 0; k < 2; k++) perm[2][n - i] += perm[k][n - i];
car = perm[2][n - i] / i;
perm[2][n - i] %= i;
}
for (int i = 0; i < n; i++) {
int p = getPos(bit, perm[2][i]);
bit.insert(p, 1);
printf("%d ", p);
}
printf("\n");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[1000001];
int f_len(int v) {
if (v < 0) return -1;
if (v == 0) return 0;
return dp[v].second;
}
int main() {
dp[0] = make_pair(0, 0);
int j, v, data[9], i, mxlen, mxlen_id, mn_paint = 1000000000, len[9];
scanf("%d", &v);
for (i = 0; i < 9; i++) {
scanf("%d", &data[i]);
mn_paint = min(mn_paint, data[i]);
}
for (i = 1; i <= v; i++) {
if ((i - mn_paint) < 0) {
dp[i] = make_pair(0, 0);
continue;
}
mxlen = -1;
for (j = 0; j < 9; j++) {
len[j] = f_len(i - data[j]);
mxlen = max(mxlen, len[j]);
}
for (j = 8; j >= 0; j--) {
if (len[j] == mxlen) {
dp[i].first = j + 1;
dp[i].second = len[j] + 1;
break;
}
}
}
if (dp[v].second == 0) {
printf("-1\n");
return 0;
}
while (v >= mn_paint) {
printf("%d", dp[v].first);
v -= data[dp[v].first - 1];
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, sum = 0, n, a, b, c, d, e, f;
cin >> n;
cin >> a >> b;
cin >> c >> d;
cin >> e >> f;
if (c < a && d < b) {
if (e < a && f < b) {
cout << "YES";
} else
cout << "NO";
} else if (c > a && d > b) {
if (e > a && f > b) {
cout << "YES";
} else
cout << "NO";
} else if (c < a && d > b) {
if (e < a && f > b) {
cout << "YES";
} else
cout << "NO";
} else if (c > a && d < b) {
if (e > a && f < b) {
cout << "YES";
} else
cout << "NO";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100005;
int read() {
int x = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x * flag;
}
int n, m, tp, dep[M], c[M], fa[M], st[2 * M];
map<pair<int, int>, int> mp;
vector<pair<int, int> > v[4 * M];
int find(int x) { return x == fa[x] ? x : find(fa[x]); }
int dis(int x) { return x == fa[x] ? 0 : (c[x] ^ dis(fa[x])); }
void merge(int u, int v, int ct) {
if (dep[u] < dep[v]) swap(u, v);
fa[v] = u;
c[v] = ct;
if (dep[u] == dep[v]) st[++tp] = -u, dep[u]++;
st[++tp] = v;
}
void back(int t) {
while (tp > t) {
if (st[tp] < 0)
dep[-st[tp]]--;
else
fa[st[tp]] = st[tp], c[st[tp]] = 0;
tp--;
}
}
void ins(int i, int l, int r, int L, int R, pair<int, int> x) {
if (l > R || L > r) return;
if (L <= l && r <= R) {
v[i].push_back(x);
return;
}
int mid = (l + r) >> 1;
ins(i << 1, l, mid, L, R, x);
ins(i << 1 | 1, mid + 1, r, L, R, x);
}
void ask(int i, int l, int r) {
int cur = tp;
for (int j = 0; j < v[i].size(); j++) {
int x = v[i][j].first, y = v[i][j].second;
int flag = dis(x) ^ dis(y) ^ 1;
if (find(x) == find(y)) {
if (flag) {
for (int i = l; i <= r; i++) puts("NO");
back(cur);
return;
}
} else
merge(find(x), find(y), flag);
}
if (l == r) {
puts("YES");
back(cur);
return;
}
int mid = (l + r) >> 1;
ask(i << 1, l, mid);
ask(i << 1 | 1, mid + 1, r);
back(cur);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
pair<int, int> t = make_pair(u, v);
if (mp.count(t))
ins(1, 1, m, mp[t], i - 1, t), mp.erase(t);
else
mp[t] = i;
}
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end(); it++)
ins(1, 1, m, it->second, m, it->first);
ask(1, 1, m);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, m;
scanf("%d%d", &n, &m);
int pos[300005], arr[n];
long long pairs[n + 1];
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
pos[arr[i]] = i;
pairs[i] = 300009;
}
pairs[n] = 300009;
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
int indx1 = pos[x];
int indx2 = pos[y];
if (indx1 > indx2) swap(indx1, indx2);
pairs[indx1] = min(pairs[indx1], (long long)indx2);
}
int j = 1;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (pairs[i] >= i + j)
ans += j;
else {
j = abs(pairs[i] - i);
ans += j;
}
j++;
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ans = 1, r = 0, l = 0;
char x;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x;
if (x == 'R')
++r;
else
++l;
}
cout << ans + r + l;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int x, y;
int r;
scanf("%d%d", &x, &y);
int fir = x * x + y * y;
int st = 0;
if (x == 0 || y == 0) {
st = 1;
} else {
for (r = 1; r <= 3005; r++) {
if (r * r >= fir) break;
}
if (x * y > 0)
st = 1;
else
st = 0;
if ((r - 1) % 2) st = 1 - st;
if (r * r == fir) st = 1;
}
if (st == 0)
printf("white\n");
else
printf("black\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
char s[1000][35];
int a[101];
int i, j, k;
int tmp[1000], flag[1000], l, sum_min, sum_max;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
getchar();
sort(a, a + n);
for (i = 0; i < m; i++) gets(s[i]);
for (i = 0; i < m; i++) {
flag[i] = 0;
tmp[i] = 1;
}
l = -1;
for (i = 0; i < m; i++) {
if (flag[i] == 0) {
++l;
for (j = 0; j < m; j++) {
if (i != j && flag[j] == 0)
if (!strcmp(s[i], s[j])) {
flag[i] = 1;
flag[j] = 1;
tmp[l]++;
}
}
}
}
sort(tmp, tmp + l + 1);
j = 0;
sum_min = 0;
sum_max = 0;
k = n - 1;
for (i = l; i >= 0; i--) {
sum_min += tmp[i] * a[j++];
sum_max += tmp[i] * a[k--];
}
printf("%d %d\n", sum_min, sum_max);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010];
int c = 0, n, m;
void f(int x, int y) {
if (x > n || y > n || c == m) return;
a[c] = x;
b[c] = y;
++c;
f(x, x + y);
f(y, x + y);
}
int main() {
scanf("%d%d", &n, &m);
if (m < n - 1) {
printf("Impossible\n");
return 0;
}
f(1, 2);
if (c < m)
printf("Impossible\n");
else {
printf("Possible\n");
for (int i = 0; i < m; ++i) printf("%d %d\n", a[i], b[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int da[62];
long long ans[62][32];
long long f[62];
int qe[62];
long long dfs(int s, int l, int ll, int up) {
if (!s) return 1;
if (!up && f[s] != -1) return f[s];
int stop = up ? da[s] : 1;
long long res = 0;
for (int i = 0; i <= stop; i++) {
if (s == ll && i == 0) continue;
int pos = ll - s;
qe[pos] = i;
if (pos < l)
res += dfs(s - 1, l, ll, up && i == stop);
else if (qe[pos % l] == i)
res += dfs(s - 1, l, ll, up && i == stop);
}
return up ? res : f[s] = res;
}
long long calc(long long x) {
memset(ans, 0, sizeof(ans));
int len = 0;
for (long long i = x; i; i /= 2) da[++len] = i % 2;
for (int i = 1; i <= len; i++)
for (int j = 1; j < i; j++)
if (i % j == 0) {
memset(f, -1, sizeof(f));
ans[i][j] = dfs(i, j, i, i == len);
}
for (int i = 1; i <= len; i++) {
for (int j = 1; j < i; j++)
if (i % j == 0) {
for (int k = 1; k < j; k++)
if (j % k == 0) ans[i][j] -= ans[i][k];
}
}
long long res = 0;
for (int i = 1; i <= len; i++)
for (int j = 1; j < i; j++)
if (i % j == 0) res += ans[i][j];
return res;
}
int main() {
long long a, b;
scanf("%I64d%I64d", &a, &b);
printf("%I64d\n", calc(b) - calc(a - 1));
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18;
struct MONOTONIC_QUEUE {
deque<pair<long long, long long>> D;
long long sz = 0;
long long pt = 0;
void insert(long long x) {
sz++;
while (!D.empty() && D.back().first >= x) D.pop_back();
D.push_back({x, pt++});
}
void erase() {
assert(sz);
sz--;
if (pt - D.front().second > sz) D.pop_front();
}
long long get() {
assert(sz);
return D.front().first;
}
};
const long long MAXN = 1e5 + 100;
long long N, S, L;
long long ST[MAXN * 4];
void update(long long nodo, long long l, long long r, long long x,
long long v) {
if (l == r) {
ST[nodo] = v;
return;
}
long long mid = (l + r) / 2;
if (x <= mid)
update(nodo * 2, l, mid, x, v);
else
update(nodo * 2 + 1, mid + 1, r, x, v);
ST[nodo] = min(ST[nodo * 2], ST[nodo * 2 + 1]);
}
long long query(long long nodo, long long l, long long r, long long a,
long long b) {
if (r < a || l > b) return oo;
if (a <= l && r <= b) {
return ST[nodo];
}
long long mid = (l + r) / 2;
return min(query(nodo * 2, l, mid, a, b),
query(nodo * 2 + 1, mid + 1, r, a, b));
}
long long dp[MAXN];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long i = 0; i < 4 * MAXN; i++) {
ST[i] = oo;
}
for (long long i = 0; i < MAXN; i++) {
dp[i] = oo;
}
cin >> N >> S >> L;
MONOTONIC_QUEUE q1, q2;
update(1, 0, N, 0, 0);
long long pos = 0;
for (long long i = 1; i <= N; i++) {
long long n;
cin >> n;
q1.insert(n);
q2.insert(-n);
while (-q2.get() - q1.get() > S) {
q1.erase();
q2.erase();
pos++;
}
if (i >= L) {
if (pos <= i - L) {
dp[i] = query(1, 0, N, pos, i - L) + 1;
update(1, 0, N, i, dp[i]);
}
}
}
if (dp[N] >= oo)
cout << -1 << '\n';
else
cout << dp[N] << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p;
cin >> n >> m;
if (n >= m) {
p = n - 1;
cout << p << ' ' << n + m - 1 - p;
} else if (m > n) {
p = m - 1;
cout << p << ' ' << n + m - 1 - p;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[1005], b[1005], n;
double p, m;
int main() {
cin >> n >> m;
p = m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
double f = p / (b[1] - 1);
if (a[1] == 1 || b[1] == 1) {
cout << -1 << endl;
return 0;
}
p += f;
for (int i = n; i >= 2; i--) {
if (a[i] == 1 || b[i] == 1) {
cout << -1 << endl;
return 0;
}
f = p / (a[i] - 1);
p += f;
f = p / (b[i] - 1);
p += f;
}
f = p / (a[1] - 1);
p += f;
printf("%.10f", p - m);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int MAX(int a, int b) { return (a > b) ? a : b; }
double FMAX(double a, double b) { return (a > b) ? a : b; }
int MIN(int a, int b) { return (a < b) ? a : b; }
double FMIN(double a, double b) { return (a < b) ? a : b; }
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
unsigned long long int UGCD(unsigned long long int a,
unsigned long long int b) {
return b ? GCD(b, a % b) : a;
}
int LCM(int a, int b) { return a / GCD(a, b) * b; }
unsigned long long int LCM(unsigned long long int a, unsigned long long int b) {
return a / GCD(a, b) * b;
}
void fswop(double &a, double &b) {
double c = a;
a = b;
b = c;
}
void bez_swop(int &a, int &b) {
int c = a;
a = b;
b = c;
}
void swop(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
long long int u(long long int a) {
if (a >= 0) return a;
return a * (-1);
}
int main() {
string s1, s2;
int i, c = 1;
cin >> s1;
s2 = s1[0];
for (i = 1; i < s1.size(); i++) {
if (s1[i] == 'a') {
if (c && i < s1.size() - 2 && s1[i + 1] == 't') {
i++;
s2 += '@';
c = 0;
continue;
}
}
if (s1[i] == 'd') {
if (i < s1.size() - 3 && s1[i + 1] == 'o' && s1[i + 2] == 't') {
i += 2;
s2 += '.';
continue;
}
}
s2 += s1[i];
}
cout << s2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int d[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
if (n % 2 == 0)
cout << -1;
else {
for (int i = 0; i < n; i++) cout << i << ' ';
cout << endl;
for (int i = 0; i < n; i++) cout << i << ' ';
cout << endl;
for (int i = 0; i < n; i++) cout << (2 * i) % n << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> even;
vector<int> odd;
vector<int> ev;
vector<int> od;
map<int, int> ma;
map<int, int> mm;
int arr[200005];
int brr[200005];
int main() {
int m, n;
scanf("%d %d", &m, &n);
int i, j;
for (i = 0; i < m; i++) {
scanf("%d", &arr[i]);
brr[i] = arr[i];
}
int re = m / 2;
for (i = 0; i < m; i++) {
int x = arr[i];
if (ma[x]) continue;
ma[x]++;
if (x % 2 == 0)
even.push_back(i);
else
odd.push_back(i);
mm[i]++;
}
int cou = 0;
if (even.size() > re) {
int xx = even.size();
for (i = 0; i < (xx - re); i++) {
int ind = even[even.size() - 1];
od.push_back(ind);
even.pop_back();
}
}
if (odd.size() > re) {
int xx = odd.size();
for (i = 0; i < (xx - re); i++) {
int ind = odd[odd.size() - 1];
ev.push_back(ind);
odd.pop_back();
}
}
if (even.size() + ev.size() < re) {
for (i = 0; i < m; i++) {
if (mm[i] == 0) {
ev.push_back(i);
mm[i]++;
if (ev.size() + even.size() == re) break;
}
}
}
if (odd.size() + od.size() < re) {
for (i = 0; i < m; i++) {
if (mm[i] == 0) {
od.push_back(i);
mm[i]++;
if (od.size() + odd.size() == re) break;
}
}
}
for (i = 1; i <= n; i++) {
if (ma[i]) continue;
if (ev.size() == 0 && od.size() == 0) break;
if (i % 2 == 0) {
if (ev.size() > 0) {
int ind = ev[ev.size() - 1];
brr[ind] = i;
ev.pop_back();
}
} else if (i % 2 == 1) {
if (od.size() > 0) {
int ind = od[od.size() - 1];
brr[ind] = i;
od.pop_back();
}
}
}
if (od.size() > 0 || ev.size() > 0) {
printf("-1\n");
return 0;
}
for (i = 0; i < m; i++) {
if (brr[i] != arr[i]) cou++;
}
printf("%d\n", cou);
for (i = 0; i < m; i++) printf("%d ", brr[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
vector<int> d[SIZE];
int it[SIZE];
int main() {
int n;
R(n);
int m = 0;
for (int i = 0; i < (n); ++i) {
int k, a1, x, y, mod;
R(k, a1, x, y, mod);
d[i].emplace_back(a1);
for (int j = (1); j < (k); ++j) {
a1 = ((long long)a1 * x + y) % mod;
d[i].emplace_back(a1);
}
m += k;
}
int an = -1;
vector<pair<int, int>> ans;
while (m) {
an++;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
qq;
for (int i = 0; i < (n); ++i) {
if (it[i] < ((int)(d[i]).size())) {
qq.push(make_pair(d[i][it[i]++], i));
}
}
while (!qq.empty()) {
m--;
auto me = qq.top();
qq.pop();
ans.emplace_back(make_pair(me.first, me.second + 1));
if (it[me.second] < ((int)(d[me.second]).size()) &&
d[me.second][it[me.second]] >= d[me.second][it[me.second] - 1]) {
qq.push(make_pair(d[me.second][it[me.second]++], me.second));
}
}
}
W(an);
for (auto x : ans) W(x);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long solve(long long x, long long y) {
long long a1 = x * (x + 1) / 2;
long long d = x + 1;
return (y + 1) * (2 * a1 + y * d) / 2;
}
int main() {
long long m, b;
cin >> m >> b;
long long mx = 0;
for (long long i = 0; i <= b; i++) {
mx = max(mx, solve(m * (b - i), i));
}
cout << mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, TotalTime = 0, BoringTime = 15;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x > BoringTime) {
TotalTime = BoringTime;
break;
} else if (x == BoringTime) {
TotalTime = x + 15;
BoringTime = x + 15;
} else {
BoringTime = x + 15;
TotalTime = x;
if (i == n) TotalTime += 15;
}
}
if (TotalTime < 15) TotalTime = 15;
if (TotalTime > 90) TotalTime = 90;
cout << TotalTime << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long int b;
vector<long long int> a;
int main() {
scanf("%d%d", &n, &m);
a.resize(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a.begin(), a.end());
while (m--) {
scanf("%lld", &b);
printf("%d ", upper_bound(a.begin(), a.end(), b) - a.begin());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<pair<long long int, long long int> > a;
int asdasd[N];
int main() {
int d, n, m;
cin >> d >> n >> m;
for (int i = 0; i < m; i++) {
int x, p;
cin >> x >> p;
a.push_back(make_pair(x, p));
}
a.push_back(make_pair(d, 0));
a.push_back(make_pair(0, 1000000007 + 10));
m += 2;
sort(a.begin(), a.end());
stack<int> xx;
for (int i = m - 1; i >= 0; i--) {
while (!xx.empty() && a[xx.top()].second > a[i].second) xx.pop();
if (xx.empty())
asdasd[i] = -1;
else
asdasd[i] = xx.top();
xx.push(i);
}
long long int left = n;
long long int ans = 0;
for (int i = 0; i < m - 1; i++) {
if (left < 0) {
puts("-1");
return 0;
}
int idx = asdasd[i];
long long int need = 0;
if (idx == -1)
need = max(min(1LL * n, d - a[i].first) - left, 0LL);
else
need = max(min(1LL * n, a[idx].first - a[i].first) - left, 0LL);
if (idx != -1)
;
ans += 1LL * need * a[i].second;
left = left + need - (a[i + 1].first - a[i].first);
}
if (left < 0)
puts("-1");
else
cout << ans << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p, t, idx, maxm = 0, minm = 1000000, maxRes = 0, minRes = 0;
cin >> n >> m;
t = n;
vector<int> planes;
vector<int> minPlanes;
while (m--) {
cin >> p;
planes.push_back(p);
minPlanes.push_back(p);
}
while (n--) {
maxm = 0;
for (int i = 0; i < planes.size(); i++) {
if (planes[i] == 0) continue;
if (planes[i] > maxm) {
maxm = planes[i];
idx = i;
}
}
maxRes += maxm;
planes[idx]--;
}
while (t--) {
minm = 1000000;
for (int i = 0; i < minPlanes.size(); i++) {
if (minPlanes[i] == 0) continue;
if (minPlanes[i] < minm) {
minm = minPlanes[i];
idx = i;
}
}
minRes += minm;
minPlanes[idx]--;
}
cout << maxRes << " " << minRes;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
int main() {
string s;
bool merda = false;
int ab = -1, fc = 1;
;
cin >> s;
for (int i = (0); i < (s.size()); i++) {
if (s[i] == '[' && ab == -1)
ab = i;
else if (s[i] == ']')
fc = i;
}
if (ab > fc || ab == -1 || fc == -1)
merda = true;
else {
int a = ab, b = fc;
ab = fc = -1;
for (int i = (a + 1); i < (b); i++) {
if (s[i] == ':' && ab == -1)
ab = i;
else if (s[i] == ':')
fc = i;
}
if (ab == -1 || fc == -1)
merda = true;
else {
int tam = 4;
for (int i = (ab + 1); i < (fc); i++) {
if (s[i] == '|') tam++;
}
printf("%d\n", tam);
}
}
if (merda) puts("-1");
}
| 5 |
// Author: Joe2k
#include<bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define ll long long
#define PI 3.1415926535897932384626
#define scan(x) cin>>x
#define print(x) cout<<x<<endl
#define printSpace(x) cout<<x<<" "
#define br cout<<endl
#define fo(i, n) for(i=0;i<n;i++)
#define Fo(i, k, n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define deb(x) cout << #x << " = " << x << endl;
#define deb2(x, y) cout << #x << " = " << x << ", " << #y << " = " << y << endl
#define deba(i, a, n) fo(i, n){cout << a[i] << " ";}
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define trr(it, x) for(auto it = x.rbegin(); it != x.rend(); it+)
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef unordered_map<ll,ll> um;
const int mod = 1000000007;
const int N = 3e5;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll t = 1;
scan(t);
while(t--) {
ll n,m,i,j,k,l,a,b,c,d;
um umap;
vl v;
string s;
scan(a);
scan(b);
scan(c);
ll x = 1, y = 1;
ll b2 = b;
while (--c)
{
x *= 10;
y *= 10;
a--;
b--;
}
while(--a){
x *= 10;
}
while(--b){
y *= 9;
}
int cnt = 0;
ll y2 = y;
while(y2>0){
cnt++;
y2 /= 10;
}
while(cnt<b2){
y *= 9;
y2 = y;
cnt = 0;
while(y2>0){
cnt++;
y2 /= 10;
}
//deb(cnt);
}
printSpace(x);
print(y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double x[100010], y, ans, newtag;
int n, k;
double len(int i) {
if (i <= 0) return 0;
double dx = x[n + 1] - x[i], dy = y;
return sqrt(dx * dx + dy * dy);
}
double ll(int i) {
double xi = newtag;
double xj = x[i];
if (xj < xi) {
int tmp = xi;
xi = xj;
xj = tmp;
}
return xj - xi;
}
double calc1(int l, int r) { return x[r] - x[l] + min(len(l), len(r)); }
double calc2(int l, int r) {
return x[r] - x[l] + min(len(l) + ll(r), len(r) + ll(l));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n + 1; i++) scanf("%lf", &x[i]);
scanf("%lf", &y);
newtag = x[k];
sort(x + 1, x + n + 1);
if (k == n + 1) {
ans = calc1(1, n);
} else {
ans = calc2(1, n);
for (int i = 1; i < n; i++) {
ans = min(ans, min(calc1(1, i) + calc2(i + 1, n),
calc2(1, i) + calc1(i + 1, n)));
}
}
printf("%.101lf\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAX = (long long)2e6 + 100;
long long inf = (long long)1e18;
long long mod = (long long)1e13 + 2987429;
long long n, m, ans[MAX], b[MAX];
set<long long> gr[MAX];
void solve() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
gr[a].insert(b);
gr[b].insert(a);
}
long long ok = 0;
for (int i = 1; i <= n; i++) {
if (gr[i].size() != n - 1) {
ok = 1;
ans[i] = n;
b[i] = n;
for (int j = 1; j <= n; j++) {
if (j != i && gr[i].count(j) == 0) {
ans[j] = n;
b[j] = n - 1;
break;
}
}
break;
}
}
if (ok == 0) {
cout << "NO\n";
return;
}
cout << "YES\n";
long long cur = n - 1;
for (int i = 1; i <= n; i++) {
if (ans[i] == 0) {
ans[i] = cur;
b[i] = cur - 1;
cur--;
}
}
for (int i = 1; i <= n; i++) cout << b[i] << " ";
cout << "\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long q;
ios::sync_with_stdio(0);
q = 1;
while (q--) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> dis;
set<pair<int, int> > edge;
int main() {
int x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
int n, r, L, R;
cin >> n;
while (n--) {
cin >> r >> L >> R;
for (int i = L; i <= R; i++) {
edge.insert(make_pair(r, i));
}
}
queue<pair<int, int> > q;
q.push(make_pair(x0, y0));
dis[make_pair(x0, y0)] = 0;
while (!q.empty()) {
pair<int, int> a = q.front();
int x = a.first;
int y = a.second;
int d = dis[make_pair(x, y)];
q.pop();
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int X = x + i, Y = y + j;
if (dis.count(make_pair(X, Y)) || !edge.count(make_pair(X, Y))) {
continue;
}
q.push(make_pair(X, Y));
dis[make_pair(X, Y)] = 1 + d;
}
}
}
if (!dis.count(make_pair(x1, y1))) dis[make_pair(x1, y1)] = -1;
cout << dis[make_pair(x1, y1)];
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
int main() {
int n;
cin >> n;
if (n % 4 == 2 || n % 4 == 3) return puts("NO"), 0;
puts("YES");
vector<pair<int, int> > ans;
for (int i = 1; i < n; i += 2)
for (int j = i + 2; j < n; j += 2) {
ans.push_back({i, j});
ans.push_back({i + 1, j + 1});
ans.push_back({i + 1, j});
ans.push_back({i, j + 1});
}
if (n % 4 == 0) {
for (int i = 1; i < n; i += 2) ans.push_back({i, i + 1});
} else {
for (int i = 1; i < n; i += 2) {
ans.push_back({n, i});
ans.push_back({i, i + 1});
ans.push_back({n, i + 1});
}
}
for (auto p : ans) {
if (p.first > p.second) swap(p.first, p.second);
printf("%d %d\n", p.first, p.second);
}
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long n, m;
cin >> t;
while (t--) {
cin >> n >> m;
if ((n * m) % 2)
cout << (n * m) / 2 + 1 << endl;
else
cout << (n * m) / 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int R, C;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> R >> C;
if (R == 1 && C == 1) {
cout << "0\n";
return 0;
}
if (R == 1) {
for (long long c = 0; c < C; c++) {
cout << c + 2 << " ";
}
cout << "\n";
return 0;
}
if (C == 1) {
for (long long r = 0; r < R; r++) {
cout << r + 2 << "\n";
}
return 0;
}
for (long long r = 0; r < R; r++) {
for (long long c = 0; c < C; c++) {
cout << (r + 1) * (c + R + 1) << " ";
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int a[MAXN], f[260], n, k;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
memset(f, -1, sizeof f);
for (int i = 1; i <= n; ++i) {
if (f[a[i]] == -1) {
int low = -1;
for (int j = a[i]; j >= 0 && j >= a[i] - k + 1; --j) {
if (f[j] != -1) {
if (f[j] >= a[i] - k + 1) low = f[j];
break;
}
low = j;
}
for (int j = low; j <= a[i]; ++j) f[j] = low;
}
}
for (int i = 1; i <= n; ++i) cout << f[a[i]] << ' ';
cout << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MD = 1e9 + 7;
const long long Inf = 2e16;
const long long N = 1e5 + 5;
long long arr[N], ps[N], dp[N][2];
long long sqr(long long n) {
long long l = 0, r = 1e9 + 1;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (mid * mid <= n)
l = mid;
else
r = mid;
}
return l;
}
void Main() {
long long n;
cin >> n;
long long sq = 2 * sqr(n) + 5;
for (long long i = 1; i <= n; i++) cin >> arr[i];
ps[0] = 0;
for (long long i = 1; i <= n; i++) ps[i] = arr[i] + ps[i - 1];
for (long long i = 0; i <= n + 4; i++)
for (long long j = 0; j <= 1; j++) dp[i][j] = -Inf;
dp[n][1] = arr[n];
for (long long i = n - 1; i >= 1; i--) dp[i][1] = max(arr[i], dp[i + 1][1]);
long long ans = 1;
for (long long k = 2; k <= sq; k++) {
if (ans == k - 1) {
for (long long i = 0; i <= n + 4; i++) dp[i][k % 2] = -Inf;
for (long long i = n; i >= 1; i--)
if ((i + k - 1) <= n) {
if ((ps[i + k - 1] - ps[i - 1]) < dp[i + k][(k - 1) % 2]) {
dp[i][k % 2] = ps[i + k - 1] - ps[i - 1];
}
dp[i][k % 2] = max(dp[i][k % 2], dp[i + 1][k % 2]);
if (dp[i][k % 2] != -Inf) ans = k;
}
}
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long T;
cin >> T;
while (T--) {
Main();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int seg[maxn * 5];
int n;
int a[maxn];
void modify(int node, int l, int r, int x, int v) {
if (l == r) {
seg[node] = v;
return;
}
int m = (l + r) >> 1;
if (x <= m)
modify(node * 2, l, m, x, v);
else
modify(node * 2 + 1, m + 1, r, x, v);
seg[node] = max(seg[node * 2], seg[node * 2 + 1]);
}
int query(int node, int l, int r, int ql, int qr) {
if (qr < l || ql > r)
return -inf;
else if (l >= ql && r <= qr)
return seg[node];
int m = (l + r) >> 1;
return max(query(node * 2, l, m, ql, qr),
query(node * 2 + 1, m + 1, r, ql, qr));
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
a[0] = inf;
vector<int> v;
v.push_back(0);
int ans = 0;
for (int i = 1; i <= n; i++) {
while (a[i] > a[v.back()]) v.pop_back();
int kill = v.back();
v.push_back(i);
if (kill == 0) continue;
int now = query(1, 1, n, kill + 1, i);
ans = max(ans, now + 1);
modify(1, 1, n, i, now + 1);
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, sq, maxm = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
sq = min(a[i], (n - i));
if (sq > maxm) {
maxm = sq;
}
}
cout << maxm << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100001];
int n, m, k;
bool vol[100001];
int source, target;
bool solve(int q) {
vector<bool> in(n + 1, false);
vector<int> dist(n + 1, 0);
queue<int> Q;
Q.push(source);
dist[source] = q;
in[source] = true;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
in[u] = false;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == target) return true;
int d = dist[u] - 1;
if (vol[v]) d = q;
if (dist[v] < d) {
dist[v] = d;
if (!in[v]) {
Q.push(v);
in[v] = true;
}
}
}
}
return false;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int v;
cin >> v;
vol[v] = true;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
cin >> source >> target;
int lo = 0, hi = n;
while (lo + 1 < hi) {
int mi = (lo + hi) >> 1;
if (solve(mi))
hi = mi;
else
lo = mi;
}
if (hi == n)
cout << "-1" << endl;
else
cout << hi << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1010100], fa[1010100], id[10010001];
int n, limit = 10000000;
int ok(int x) {
if (fa[x] == x) return x;
fa[x] = ok(fa[x]);
return fa[x];
}
void merge(int x, int y) {
x = id[x], y = id[y];
x = ok(x);
y = ok(y);
fa[x] = y;
}
int gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
int main() {
scanf("%d", &n);
memset(id, 0, sizeof(id));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
id[a[i]] = i;
fa[i] = i;
}
for (int p = 1; p * p <= limit; p++)
for (int q = 2;; q += 2) {
int x = ((p) * (p)) + p * q;
int y = ((q) * (q)) / 2 + p * q;
int z = x + y - p * q;
if (x > limit || y > limit) break;
if (id[x] && id[y] && gcd(x, y) == 1) merge(x, y);
if (z <= limit && id[x] && id[z] && gcd(x, z) == 1) merge(x, z);
if (z <= limit && id[y] && id[z] && gcd(y, z) == 1) merge(y, z);
}
for (int i = 1; i <= n; i++) fa[i] = ok(i);
memset(id, 0, sizeof(id));
int ans = 0;
for (int i = 1; i <= n; i++)
if (!id[fa[i]]) id[fa[i]] = 1, ans++;
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 3e3 + 5;
int n, a[N], h[N], x, y, cur, m;
vector<int> ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int cur = n;
for (int i = 1; i <= n; i++) {
if (h[i]) continue;
h[i] = 1;
for (int j = a[i]; j != i; j = a[j]) h[j] = 1;
cur--;
}
scanf("%d", &m);
while (cur != m) {
int x = 0, y = 0;
if (cur > m) {
for (int i = 1; i <= n; i++)
if (a[i] != i) {
x = i;
break;
}
cur--;
y = inf;
for (int j = a[x]; j != x; j = a[j]) y = min(y, j);
} else {
x = 1;
memset(h, 0, sizeof h);
h[x] = 1;
for (int j = a[x]; j != x; j = a[j]) h[j] = 1;
for (int i = 1; i <= n; i++)
if (!h[i]) {
y = i;
break;
}
cur++;
}
swap(a[x], a[y]);
ans.push_back(x);
ans.push_back(y);
}
cout << ans.size() / 2 << '\n';
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++)
cout << *it << ' ';
cout << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, P = 1000000007;
using ll = long long;
struct TNode {
int l, r, mid, s1, s2, s3, t1, t2;
} t[N << 2];
inline int lc(int pos) { return pos << 1; }
inline int rc(int pos) { return pos << 1 | 1; }
inline void pushup(int pos) {
t[pos].s1 = (t[lc(pos)].s1 + t[rc(pos)].s1) % P;
t[pos].s2 = (t[lc(pos)].s2 + t[rc(pos)].s2) % P;
t[pos].s3 = (t[lc(pos)].s3 + t[rc(pos)].s3) % P;
}
inline void push(int pos, ll val, int tp) {
if (tp == 1) {
t[pos].t1 = (t[pos].t1 + val) % P;
t[pos].s1 = (t[pos].s1 + val * (t[pos].r - t[pos].l + 1)) % P;
t[pos].s3 = (t[pos].s3 + val * t[pos].s2) % P;
} else {
t[pos].t2 = (t[pos].t2 + val) % P;
t[pos].s2 = (t[pos].s2 + val * (t[pos].r - t[pos].l + 1)) % P;
t[pos].s3 = (t[pos].s3 + val * t[pos].s1) % P;
}
}
inline void pushdown(int pos) {
if (t[pos].t1)
push(lc(pos), t[pos].t1, 1), push(rc(pos), t[pos].t1, 1), t[pos].t1 = 0;
if (t[pos].t2)
push(lc(pos), t[pos].t2, 2), push(rc(pos), t[pos].t2, 2), t[pos].t2 = 0;
}
void build(int pos, int l, int r) {
t[pos] = {l, r, (l + r) >> 1, 0, 0, 0, 0, 0};
if (l == r) {
t[pos].s1 = l - 1;
return;
}
build(lc(pos), l, t[pos].mid);
build(rc(pos), t[pos].mid + 1, r);
pushup(pos);
}
void modify(int pos, int l, int r, int v, int tp) {
if (t[pos].l == l && t[pos].r == r) return push(pos, v, tp);
pushdown(pos);
if (r <= t[pos].mid)
modify(lc(pos), l, r, v, tp);
else if (l > t[pos].mid)
modify(rc(pos), l, r, v, tp);
else
modify(lc(pos), l, t[pos].mid, v, tp),
modify(rc(pos), t[pos].mid + 1, r, v, tp);
pushup(pos);
}
int query(int pos, int l, int r, ll v) {
if (t[pos].l == l && t[pos].r == r) return (t[pos].s3 + v * t[pos].s1) % P;
pushdown(pos);
if (r <= t[pos].mid)
return query(lc(pos), l, r, v);
else if (l > t[pos].mid)
return query(rc(pos), l, r, v);
else
return (query(lc(pos), l, t[pos].mid, v) +
query(rc(pos), t[pos].mid + 1, r, v)) %
P;
}
int n, a[N], b[N], aa[N], stk1[N], top1, stk2[N], top2, ans;
map<int, int> mp;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> aa[i], a[i] = mp[aa[i]], mp[aa[i]] = i;
for (auto &i : mp) i.second = n + 1;
for (int i = n; i > 0; --i) b[i] = mp[aa[i]], mp[aa[i]] = i;
build(1, 1, n);
int j = 1, p1 = 1, p2 = 1;
for (int i = 1; i <= n; i++) {
while (top1 && a[stk1[top1]] < a[i])
modify(1, stk1[top1 - 1] + 1, stk1[top1], a[stk1[top1]], 1), --top1;
modify(1, stk1[top1] + 1, i, P - a[i], 1);
stk1[++top1] = i;
p1 = min(p1, top1);
while (top2 && b[stk2[top2]] > b[i])
modify(1, stk2[top2 - 1] + 1, stk2[top2], P - b[stk2[top2]], 2), --top2;
modify(1, stk2[top2] + 1, i, b[i], 2);
stk2[++top2] = i;
p2 = min(p2, top2);
while (j <= i) {
while (stk1[p1] < j) ++p1;
while (stk2[p2] < j) ++p2;
if (a[stk1[p1]] < j - 1 && i + 1 < b[stk2[p2]]) break;
++j;
}
if (j <= i) ans = (ans + query(1, j, i, P - i - 1)) % P;
}
cout << ans << endl;
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long _x = 0;
int _ch = getchar(), _f = 1;
for (; !isdigit(_ch) && (_ch != '-') && (_ch != EOF); _ch = getchar())
;
if (_ch == '-') {
_f = 0;
_ch = getchar();
}
for (; isdigit(_ch); _ch = getchar()) _x = _x * 10 + _ch - '0';
return _f ? _x : -_x;
}
void write(long long _x) {
if (_x >= 10)
write(_x / 10), putchar(_x % 10 + '0');
else
putchar(_x + '0');
}
inline void wrt(long long _x, char _p) {
if (_x < 0) putchar('-'), _x = -_x;
write(_x);
if (_p) putchar(_p);
}
int nx[200005], to[200005], hd[200005], id[200005], cnt;
inline void add(int u, int v, int Id) {
nx[++cnt] = hd[u], to[cnt] = v, id[cnt] = Id, hd[u] = cnt;
}
int n;
int ans[200005], res[200005];
int f[200005][21], F[200005], dep[200005];
void dfs(int u, int fa) {
f[u][0] = fa, dep[u] = dep[fa] + 1;
for (int i = int(1); i <= (int)(19); i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = hd[u]; i; i = nx[i])
if (to[i] != fa) {
F[to[i]] = id[i];
dfs(to[i], u);
}
}
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = int(19); i >= (int)(0); i--)
if (dep[f[u][i]] >= dep[v]) u = f[u][i];
if (u == v) return u;
for (int i = int(19); i >= (int)(0); i--)
if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
void DFS(int u, int fa) {
for (int i = hd[u]; i; i = nx[i])
if (to[i] != fa) {
DFS(to[i], u);
ans[u] += ans[to[i]];
}
res[F[u]] = ans[u];
}
int main() {
n = rd();
for (int i = int(2); i <= (int)(n); i++) {
int x = rd(), y = rd();
add(x, y, i - 1), add(y, x, i - 1);
}
dfs(1, 0);
int m = rd();
for (int i = int(1); i <= (int)(m); i++) {
int x = rd(), y = rd();
ans[x]++, ans[y]++, ans[lca(x, y)] -= 2;
}
DFS(1, 0);
for (int i = int(1); i <= (int)(n - 1); i++) wrt(res[i], ' ');
putchar('\n');
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int y;
edge* next;
};
edge* new_edge() {
static edge a[200005];
static int top = 0;
return &a[top++];
}
edge* li[100005];
void insert_edge(int x, int y) {
edge* t = new_edge();
t->y = y;
t->next = li[x];
li[x] = t;
}
bool vis[100005][2];
int pre[100005][2];
void dfs(int x, int y) {
if (x == -1) return;
dfs(pre[x][y], !y);
printf("%d ", x + 1);
}
bool bfs(int s) {
static int que[200005];
int front = 0, rail = 1;
que[0] = s * 2;
vis[s][0] = true;
pre[s][0] = -1;
for (; front < rail; front++) {
int nowx = que[front] / 2;
int nowy = que[front] % 2;
edge* t;
for (t = li[nowx]; t != 0; t = t->next) {
if (!vis[t->y][!nowy]) {
vis[t->y][!nowy] = true;
pre[t->y][!nowy] = nowx;
que[rail++] = (t->y) * 2 + (!nowy);
}
}
if ((li[nowx] == 0) && (nowy == 1)) {
puts("Win");
dfs(nowx, nowy);
return true;
}
}
return false;
}
bool inque[100005];
bool vis2[100005];
bool dfs(int x) {
vis2[x] = true;
inque[x] = true;
edge* t;
for (t = li[x]; t != 0; t = t->next) {
if (inque[t->y]) {
return true;
} else if (vis2[t->y]) {
continue;
} else {
if (dfs(t->y)) {
return true;
}
}
}
inque[x] = false;
return false;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i;
for (i = 0; i < n; i++) {
int s;
scanf("%d", &s);
int j;
for (j = 0; j < s; j++) {
int x;
scanf("%d", &x);
x--;
insert_edge(i, x);
}
}
int s;
scanf("%d", &s);
s--;
if (bfs(s)) return 0;
if (dfs(s)) {
puts("Draw");
} else {
puts("Lose");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6;
struct Line {
long long k, b;
Line(long long _k, long long _b) { k = _k, b = _b; }
long long get_val(long long x) { return k * x + b; }
long long intersect_x(Line rhs) { return (b - rhs.b) / (rhs.k - k); }
};
struct Rect {
int x, y;
long long val;
bool operator<(const Rect rhs) const { return x < rhs.x; }
};
int N;
Rect A[Maxn + 5];
deque<Line> q;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d %d %lld", &A[i].x, &A[i].y, &A[i].val);
sort(A + 1, A + N + 1);
q.push_back(Line(0, 0));
long long ans = 0;
for (int i = 1; i <= N; i++) {
while (q.size() >= 2 &&
q.back().get_val(A[i].y) <= q[q.size() - 2].get_val(A[i].y))
q.pop_back();
long long tmp = q.back().get_val(A[i].y) + 1LL * A[i].x * A[i].y - A[i].val;
ans = max(ans, tmp);
Line cur(-A[i].x, tmp);
while (q.size() >= 2 && cur.intersect_x(q[0]) >= q[0].intersect_x(q[1]))
q.pop_front();
q.push_front(cur);
}
printf("%lld\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int cnt = 0;
int t = 0;
int j = 1;
for (int i = 0; i < k; ++i) {
int len;
cin >> len;
vector<int> ab;
for (int k = 0; k < len; ++k) {
int y;
cin >> y;
ab.push_back(y);
}
if (ab[0] == 1) {
for (; j < len; j++) {
if (ab[j] != j + 1) break;
}
t += len - j;
} else
t += len - 1;
}
cout << t + n - j << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[105], vis[105], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
ans++;
for (int j = 1; j <= n; j++)
if (a[j] % a[i] == 0) vis[j] = 1;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n[10] = {0, 52, 52, 52, 52, 53, 53, 52};
int a, l, h;
string b1, b2;
cin >> a >> b1 >> b2;
l = b2.length();
if (l == 4)
printf("%d\n", n[a]);
else if (l == 5) {
if (a <= 29) h = 12;
if (a == 30) h = 11;
if (a == 31) h = 7;
printf("%d\n", h);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int c = 0;
for (int i = 1; i < n; i++) {
c += arr[i] - arr[i - 1] - 1;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> stk;
int inp;
int mx = 0;
while (n--) {
cin >> inp;
while (stk.size() && stk.back() <= inp) {
mx = max(mx, stk.back() ^ inp);
stk.pop_back();
}
if (stk.size()) mx = max(mx, stk.back() ^ inp);
stk.push_back(inp);
}
cout << mx << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[8] = {0};
int n, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
a[m]++;
}
if (!a[5] && !a[7] && 3 * a[1] == n && a[2] + a[3] == a[4] + a[6] &&
a[4] <= a[2]) {
int u = a[3];
int v = a[4];
int s = n / 3 - u - v;
while (u--) cout << 1 << " " << 3 << " " << 6 << endl;
while (v--) cout << 1 << " " << 2 << " " << 4 << endl;
while (s--) cout << 1 << " " << 2 << " " << 6 << endl;
} else
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int inv2 = (mod + 1) >> 1;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int n, m, dfn[N], low[N], tim, st[N], tp, tt, ibin[N], s1[N], fa[N], f[N],
id[N], ans, sum, sf[N], tot[110][110], tot2[110][110];
vector<int> E[N], T[N], cnt1[N], cnt2[N];
bool G[110][110];
void dfs(int u, int fa) {
dfn[u] = low[u] = ++tim;
st[++tp] = u;
for (auto v : E[u]) {
if (v == fa) continue;
if (!dfn[v]) {
dfs(v, u), low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
int x;
++tt;
do x = st[tp--], T[tt].push_back(x), ::fa[x] = tt;
while (x != v);
T[u].push_back(tt);
::fa[tt] = u;
}
} else
low[u] = min(low[u], dfn[v]);
}
}
int cal(const vector<int> &a) {
int s1 = 0, s2 = 0;
for (auto x : a) s2 = (s2 + 1ll * s1 * x) % mod, s1 = (s1 + x) % mod;
return s2;
}
int F(int x, int y) { return (1ll * x * x - y + mod) % mod * inv2 % mod; }
bool isroot(int x) {
if (x == 1) return 1;
if (G[x][fa[fa[x]]]) return 0;
if (id[x] && G[x][T[fa[x]][id[x] - 1]]) return 0;
return 1;
}
int main() {
cin >> n >> m;
ibin[0] = 1;
for (int i = 1; i <= n; i++)
ibin[i] = 1ll * ibin[i - 1] * inv2 % mod,
s1[i] = (s1[i - 1] + mod + 1 - ibin[i]) % mod;
for (int i = 1, u, v; i <= m; i++)
u = gi(), v = gi(), E[u].push_back(v), E[v].push_back(u);
tt = n;
dfs(1, 0);
f[1] = inv2;
for (int i = n + 1; i <= tt; i++)
for (int j = 0; j < int(T[i].size()); j++) id[T[i][j]] = j;
for (int i = 2; i <= n; i++) {
int all = int(T[fa[i]].size());
f[i] = 1ll * ibin[2] * (id[i] ? mod + 1 - ibin[all - id[i]] : 1) % mod;
}
for (int i = n + 1; i <= tt; i++) {
int all = int(T[i].size());
cnt1[i].resize(all + 1);
cnt2[i].resize(all + 1);
cnt1[i][0] = (f[fa[i]] + 1ll * ibin[2] * (all > 1 ? s1[all - 2] : 0)) % mod;
cnt2[i][0] =
(cnt1[i][0] +
(all > 1 ? 1ll * inv2 * (mod + 1 - ibin[all - 1]) % mod : 0)) %
mod;
cnt1[i][all] = 1ll * ibin[2] * (all > 1 ? s1[all - 2] : 0) % mod;
cnt2[i][all] = (inv2 + 1ll * (all - 1) * ibin[2]) % mod;
for (int j = 1; j < all; j++) {
int tmp1 = (2ll * f[fa[i]] +
1ll * ibin[2] *
(s1[max(all - 3, 0)] - s1[max(all - j - 2, 0)] + mod)) %
mod;
if (all - j - 3 >= 0)
tmp1 = (tmp1 + 1ll * ibin[2] * s1[all - j - 3]) % mod;
int tmp2 = (inv2 + 1ll * ibin[2] * (j - 1)) % mod;
if (j + 2 <= all - 1)
tmp2 = (tmp2 + 1ll * (all - 1 - (j + 2) + 1) * ibin[2]) % mod;
cnt1[i][j] = 1ll * inv2 * (tmp1 + tmp2) % mod;
tmp1 = (2ll * f[fa[i]] + 1ll * ibin[2] * (j - 1)) % mod;
if (all - j - 3 >= 0)
tmp1 = (tmp1 + 1ll * ibin[2] * s1[all - j - 3]) % mod;
if (all - j - 2 >= 0)
tmp1 = (tmp1 + 1ll * inv2 * (mod + 1 - ibin[all - j - 2])) % mod;
tmp2 = (1ll * (all - 2) * ibin[2] + inv2) % mod;
if (j < all - 1) tmp2 = (tmp2 + ibin[2]) % mod;
cnt2[i][j] = 1ll * inv2 * (tmp1 + tmp2) % mod;
}
}
vector<int> tmp;
int sum = 0;
for (int i = 1; i <= n; i++) tmp.push_back(f[i]), sum = (sum + f[i]) % mod;
int ans = cal(tmp);
for (int i = n + 1; i <= tt; i++) {
int all = int(T[i].size()), s2 = 0;
for (auto x : T[i])
sf[i] = (sf[i] + f[x]) % mod, s2 = (s2 + 1ll * f[x] * f[x]) % mod;
sf[i] = (sf[i] + f[fa[i]]) % mod;
s2 = (s2 + 1ll * f[fa[i]] * f[fa[i]]) % mod;
ans = (ans - F(sf[i], s2) + mod) % mod;
for (int j = 1; j < all - 1; j++)
ans = (ans +
1ll * ibin[2] * f[fa[i]] % mod * (mod + 1 - ibin[all - 1 - j])) %
mod;
for (int j = 2; j < all; j++) ans = (ans + ibin[4]) % mod;
for (int j = 3; j < all; j++) {
ans = (ans + 1ll * ibin[4] * (j - 2) % mod * (mod + 1 - ibin[all - j])) %
mod;
}
}
for (int i = 1; i <= n; i++) {
tmp.clear();
for (auto x : T[i]) tmp.push_back((sf[x] - f[i] + mod) % mod);
if (fa[i]) tmp.push_back((sf[fa[i]] - f[i] + mod) % mod);
ans = (ans - cal(tmp) + mod) % mod;
tmp.clear();
for (auto x : T[i]) tmp.push_back(cnt1[x][int(T[x].size())]);
if (fa[i]) tmp.push_back(cnt1[fa[i]][id[i]]);
ans = (ans + 1ll * inv2 * cal(tmp)) % mod;
tmp.clear();
for (auto x : T[i]) tmp.push_back(cnt2[x][int(T[x].size())]);
if (fa[i]) tmp.push_back(cnt2[fa[i]][id[i]]);
ans = (ans + 1ll * inv2 * cal(tmp)) % mod;
}
ans = (2ll * ans + sum) % mod;
ans = (ans - 1ll * sum * sum % mod + mod) % mod;
cout << ans;
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
double const pi = acos(-1.0);
double cal(int n, double a) {
double arc = 360 / n;
double half = arc / 2;
double r = 0.5 * a / tan(half * pi / 180);
double R = 0.5 * a / sin(half * pi / 180);
double h = sqrt(a * a - R * R);
double s = 0.5 * n * a * r;
return s * h / 3;
}
int main() {
double a, b, c;
cin >> a >> b >> c;
double s1 = cal(3, a);
double s2 = cal(4, b);
double s3 = cal(5, c);
printf("%.10lf\n", s1 + s2 + s3);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
ios::sync_with_stdio(false);
long long int T, a, b, i, t, k;
cin >> T;
while (T--) {
cin >> s;
t = 0;
k = 0;
for (i = 0; i < s.size(); i++) {
if (k == 0 && s[i] == '-') {
t = t + i + 1;
} else if (s[i] == '-') {
k--;
} else {
k++;
}
}
cout << t + s.size() << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void ONLINE__JUDGE();
pair<long long, long long> swapii(pair<long long, long long> pr) {
return {pr.second, pr.first};
}
int dx[] = {0, 0, -1, +1, -1, +1, -1, +1};
int dy[] = {-1, +1, 0, 0, -1, +1, +1, -1};
const int mod = 7901;
const int MAX = 1e3 + 9;
map<char, long long> mp;
long long q;
string s;
int main() {
ios::sync_with_stdio(NULL);
cin.tie(NULL);
ONLINE__JUDGE();
cin >> q;
while (q--) cin >> s, mp[s.front()]++;
long long cnt = 0;
for (auto it : mp) {
long long a = it.second / 2, b = it.second - a;
cnt += (a * (a - 1) / 2);
cnt += (b * (b - 1) / 2);
}
cout << cnt;
return 0;
}
void ONLINE__JUDGE() {}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, W = 300000;
vector<int> cc[301000];
int n, fac[301000], ivf[301000], coef[301000];
inline int calc(int n, int k) {
if (n < k) return 0;
return 1ll * fac[n] * ivf[k] % mod * ivf[n - k] % mod;
}
int pr(int a, int z) {
int s = 1;
do {
if (z & 1) s = 1ll * s * a % mod;
a = 1ll * a * a % mod;
} while (z >>= 1);
return s;
}
int main() {
scanf("%d", &n);
int ta, ans = 0;
fac[0] = ivf[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
ivf[n] = pr(fac[n], mod - 2);
for (int i = n - 1; i >= 1; --i) ivf[i] = 1ll * ivf[i + 1] * (i + 1) % mod;
coef[0] = 1;
for (int i = 1; i <= n - 1; ++i) coef[0] = (coef[0] << 1) % mod;
coef[0] = (coef[0] + mod - 1) % mod;
for (int i = 1; i <= n - 1; ++i)
coef[i] =
(0ll + coef[i - 1] - calc(n - 1, i - 1) - calc(n - 1, i) + mod + mod) %
mod;
for (int i = 1; i <= n; ++i) {
scanf("%d", &ta);
for (int j = 2; j * j <= ta; ++j)
if (ta % j == 0) {
int c = 0;
while (ta % j == 0) ta /= j, ++c;
cc[j].push_back(c);
}
if (ta != 1) cc[ta].push_back(1);
}
for (int i = 1; i <= W; ++i)
if (cc[i].size()) {
sort(cc[i].begin(), cc[i].end());
int len = cc[i].size();
for (int j = 0; j < len; ++j)
ans = (ans + 1ll * cc[i][j] * coef[len - j - 1]) % mod;
}
printf("%d\n", ans);
return 0;
}
| 23 |
#include <bits/stdc++.h>
int a[22], b[22], f[22];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
f[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (a[f[i]] < a[f[j]]) {
int t = f[i];
f[i] = f[j];
f[j] = t;
}
}
}
for (int i = 0; i < n; i++) b[f[i]] = a[f[(i + 1) % n]];
for (int i = 0; i < n; i++) printf("%d ", b[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
if (k == 0) {
long long ans = v[0] - 1;
if (ans <= 0) {
cout << -1 << endl;
return;
} else {
cout << ans << endl;
return;
}
}
long long x = v[k - 1];
if (x != v[k]) {
cout << x << endl;
return;
} else
cout << -1 << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, ans = 0;
void calc(long long int a) {
if (n < a) return;
if (n >= a) ans++;
calc(a * 10 + 1);
calc(a * 10);
}
int main(void) {
cin >> n;
calc(1);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool valid(char a) { return a != '.'; }
bool add(char &a, char &b) {
if (valid(a) && a != b) return false;
a = b;
return true;
}
string s[6];
vector<string> ans;
int main() {
for (int i = 0; i < 6; i++) cin >> s[i];
sort(s, s + 6);
do {
vector<string> v(s[0].size(), string(s[1].size(), '.'));
if (s[0].size() != s[4].size() + s[3].size() - 1) continue;
if (s[1].size() != s[2].size() + s[5].size() - 1) continue;
bool ok = true;
for (int i = 0; i < s[0].size(); i++)
ok &= add(v[i][s[2].size() - 1], s[0][i]);
for (int i = 0; i < s[1].size(); i++)
ok &= add(v[s[3].size() - 1][i], s[1][i]);
for (int i = 0; i < s[2].size(); i++) ok &= add(v[0][i], s[2][i]);
for (int i = 0; i < s[3].size(); i++) ok &= add(v[i][0], s[3][i]);
for (int i = 0; i < s[4].size(); i++)
ok &= add(v[s[3].size() - 1 + i][s[1].size() - 1], s[4][i]);
for (int i = 0; i < s[5].size(); i++)
ok &= add(v[s[0].size() - 1][s[2].size() - 1 + i], s[5][i]);
if (!ok) continue;
if (ans.empty() || v < ans) ans = v;
} while (next_permutation(s, s + 6));
if (ans.empty())
cout << "Impossible" << endl;
else
for (auto i : ans) cout << i << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int m, n;
cin >> m >> n;
vector<int> p;
for (int i = 0; i < n; ++i) {
cout << 1 << endl;
fflush(stdout);
int cur;
cin >> cur;
if (cur > 0)
p.push_back(1);
else if (cur < 0)
p.push_back(0);
else
return 0;
}
int cnt = 0;
int l = 1, r = m;
while (l <= r) {
int mid = l + (r - l) / 2;
cout << mid << endl;
fflush(stdout);
int cur;
cin >> cur;
if (!p[cnt]) cur = -cur;
if (cur == 0) return 0;
if (cur < 0)
r = mid - 1;
else
l = mid + 1;
cnt++;
cnt %= n;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[501];
set<int> s;
int n;
long long ans = 998244353998244347;
void check(int x) {
int i;
long long cnt = 0;
for (i = 1; i <= n; i++) {
if (a[i] % (x + 1) == 0) {
cnt += a[i] / (x + 1);
continue;
}
if (x - a[i] % (x + 1) > a[i] / (x + 1)) return;
cnt += a[i] / (x + 1) + 1;
}
ans = min(ans, cnt);
}
int main() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int S = sqrt(a[1]);
for (i = 1; i <= S; i++) {
s.insert(a[1] / i);
if (a[1] / i - a[1] / (i + 1) >= 1) s.insert(i);
if (a[1] % i == 0) s.insert(a[1] / i - 1), s.insert(i - 1);
}
set<int>::iterator it;
for (it = s.begin(); it != s.end(); it++) {
if (!*it) continue;
check(*it);
}
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int f(pair<int, int> a) { return a.second - a.first - 1; }
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
set<pair<int, int> > A;
int len = 0;
s += "~";
long long sum = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.') {
len++;
} else {
if (len > 0) A.insert({i - len, i}), sum += len - 1;
len = 0;
}
}
A.insert({-1e9, -1e9});
A.insert({1e9, 1e9});
for (int i = 0; i < m; i++) {
int x;
char c[2];
scanf("%d%s", &x, c);
--x;
if (c[0] != '.') {
auto it = A.upper_bound({x + 1, -1e9});
it--;
if (it->first <= x && x < it->second) {
pair<int, int> X = {it->first, x};
pair<int, int> Y = {x + 1, it->second};
sum -= f(*it);
if (f(X) >= 0) A.insert(X), sum += f(X);
if (f(Y) >= 0) A.insert(Y), sum += f(Y);
A.erase(*it);
}
} else if (c[0] == '.') {
auto it = A.upper_bound({x + 1, -1e9});
it--;
if (!(it->first <= x && x < it->second)) {
A.insert({x, x + 1});
auto it2 = A.lower_bound({x, x + 1});
auto le = it2;
auto ri = it2;
le--;
ri++;
if (le->second == x && ri->first == x + 1) {
sum -= f(*le);
sum -= f(*ri);
sum -= f(*it2);
A.erase(*le);
A.erase(*ri);
A.erase(*it2);
pair<int, int> ne = {le->first, ri->second};
A.insert(ne);
sum += f(ne);
} else if (le->second == x) {
sum -= f(*le);
sum -= f(*it2);
A.erase(*le);
A.erase(*it2);
pair<int, int> ne = {le->first, le->second + 1};
A.insert(ne);
sum += f(ne);
} else if (ri->first == x + 1) {
sum -= f(*ri);
sum -= f(*it2);
A.erase(*ri);
A.erase(*it2);
pair<int, int> ne = {ri->first - 1, ri->second};
A.insert(ne);
sum += f(ne);
}
}
}
cout << sum << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
struct point {
double x, y;
};
int t;
double cross(point a, point b, point c) {
b.x -= a.x;
b.y -= a.y;
c.x -= a.x;
c.y -= a.y;
return b.x * c.y - b.y * c.x;
}
bool check(point a, point b, point c) {
double kx1 = 2.0 * (b.x - a.x), ky1 = 2.0 * (b.y - a.y),
s1 = b.x * b.x + b.y * b.y - a.x * a.x - a.y * a.y;
double kx2 = -2.0 * (b.x - c.x), ky2 = -2.0 * (b.y - c.y),
s2 = b.x * b.x + b.y * b.y - c.x * c.x - c.y * c.y -
4.0 * b.x * (b.x - c.x) - 4.0 * b.y * (b.y - c.y);
double kx = kx1 * ky2 - kx2 * ky1, s = s1 * ky2 - s2 * ky1;
if (kx > -eps && kx < eps) return false;
double x = s / kx, y;
if (ky1 <= -eps || ky1 >= eps)
y = (s1 - kx1 * x) / ky1;
else if (ky2 <= -eps || ky2 >= eps)
y = (s2 - kx2 * x) / ky2;
else
return false;
point va, vb, vc, vd;
va.x = x;
va.y = y;
vb.x = b.x + b.x - va.x;
vb.y = b.y + b.y - va.y;
vc.x = c.x + c.x - vb.x;
vc.y = c.y + c.y - vb.y;
vd.x = a.x + a.x - va.x;
vd.y = a.y + a.y - va.y;
double ca = cross(va, vb, vc), cb = cross(vb, vc, vd), cc = cross(vc, vd, va),
cd = cross(vd, va, vb);
if ((ca > 0 && cb > 0 && cc > 0 && cd > 0) ||
(ca < 0 && cb < 0 && cc < 0 && cd < 0)) {
puts("YES");
printf("%.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf %.9lf\n", va.x, va.y,
vb.x, vb.y, vc.x, vc.y, vd.x, vd.y);
return true;
}
return false;
}
point a, b, c;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%lf%lf%lf%lf%lf%lf", &a.x, &a.y, &b.x, &b.y, &c.x, &c.y);
if (!check(a, b, c) && !check(b, a, c) && !check(a, c, b)) {
puts("NO");
puts("");
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
const long long MOD = 1e9 + 7;
long long power(long long x, long long y, long long m) {
long long ans = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) ans = (ans * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return ans;
}
long long mod_inv(long long a, long long m) { return power(a, m - 2, m); }
long long mod_(long long a, long long m) { return (a + m) % m; }
long long add(long long a, long long b, long long m) {
return (((a + b) % m) + m) % m;
}
long long sub(long long a, long long b, long long m) {
return (((a - b) % m) + m) % m;
}
long long mul(long long a, long long b, long long m) {
return (((a * b) % m) + m) % m;
}
long long div_(long long a, long long b, long long m) {
return mul(a, mod_inv(b, m), m);
}
const long long N1 = 1;
long long f[N1], invf[N1];
void fact(long long M) {
f[0] = f[1] = 1;
for (int i = 2; i < N1; i++) f[i] = mod_(f[i - 1] * i, M);
invf[N1 - 1] = power(f[N1 - 1], M - 2, M);
for (int i = N1 - 1; i > 0; i--) invf[i - 1] = mod_(invf[i] * i, M);
}
long long nCr(long long n, long long r, long long M) {
if (r > n) return 0;
long long ans = f[n];
ans = mod_(ans * invf[n - r], M);
ans = mod_(ans * invf[r], M);
return ans;
}
void fastIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << std::fixed << setprecision(25);
cerr << std::fixed << setprecision(10);
}
string reverse(string s) {
int n = s.size();
string ans = "";
for (int i = n - 1; i >= 0; i--) {
ans.push_back(s[i]);
}
return ans;
}
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
if (a > b) return gcd(b, a - b);
return gcd(a, b - a);
}
int main() {
int n;
cin >> n;
string s = to_string(n);
int mx = 0;
int ind = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] - '0' > mx) {
mx = s[i] - '0';
ind = i;
}
}
cout << mx;
cout << "\n";
char mat[mx][s.size()];
for (int i = 0; i < mx; i++) {
for (int j = 0; j < s.size(); j++) {
mat[i][j] = '0';
}
}
for (int i = 0; i < s.size(); i++) {
int d = s[i] - '0';
for (int j = 0; j < d; j++) {
mat[j][i] = '1';
}
}
for (int i = 0; i < mx; i++) {
bool flag = false;
for (int j = 0; j < s.size(); j++) {
if (!flag && mat[i][j] == '1') {
flag = true;
cout << mat[i][j];
continue;
}
if (!flag) continue;
cout << mat[i][j];
}
cout << " ";
}
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 6;
long long int t[N], w[N];
vector<long long int> v;
priority_queue<pair<long long int, long long int> > v2;
int main() {
int n;
cin >> n;
int best_place = 0;
for (int i = 1; i <= n; i++) {
cin >> t[i] >> w[i];
if (i > 1) {
if (t[i] > t[1]) best_place++;
}
}
multiset<long long int> ms;
for (int i = 2; i <= n; i++) {
if (t[i] > t[1]) {
ms.insert((w[i] - t[i] + 1));
} else {
v2.push(make_pair(t[i], w[i]));
}
}
while (1) {
if (ms.size() == 0) break;
long long int cur = *(ms.begin());
ms.erase(ms.begin());
if (t[1] >= cur) {
t[1] -= cur;
} else
break;
while (1) {
if (v2.empty()) break;
pair<long long int, long long int> x = v2.top();
if (x.first <= t[1]) break;
v2.pop();
ms.insert(abs(x.first - x.second) + 1);
}
best_place = min(best_place, (int)(ms.size()));
}
cout << best_place + 1;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int LEN = (int)1e3;
struct rect {
pair<int, int> x, y;
};
bool comp1(rect a, rect b) { return a.x < b.x; };
bool comp2(rect a, rect b) { return a.y < b.y; };
int n;
rect a[LEN];
bool solve(int i, int I, bool m) {
if (i == I) return true;
bool res = true;
bool is_fir = true;
sort(a + i, a + I + 1, (m ? comp1 : comp2));
while (i <= I && res) {
int j = i;
if (m) {
int mx = a[j].x.second;
while (j + 1 <= I && mx > a[j + 1].x.first) {
j++;
mx = max(mx, a[j].x.second);
}
} else {
int mx = a[j].y.second;
while (j + 1 <= I && mx > a[j + 1].y.first) {
j++;
mx = max(mx, a[j].y.second);
}
}
if (j == I && is_fir) {
return false;
}
res = res && solve(i, j, !m);
i = j + 1;
is_fir = false;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x.first >> a[i].y.first >> a[i].x.second >> a[i].y.second;
}
cout << (solve(0, n - 1, true) || solve(0, n - 1, false) ? "YES\n" : "NO\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long l, r, sg;
Node() {}
Node(long long a, long long b, long long c) {
l = a;
r = b;
sg = c;
}
} cover[10];
int main() {
int n;
long long x;
cover[0] = Node(1LL, 3LL, 0LL);
cover[1] = Node(4LL, 15LL, 1LL);
cover[2] = Node(16LL, 81LL, 2LL);
cover[3] = Node(82LL, 6723LL, 0LL);
cover[4] = Node(6724LL, 50625LL, 3LL);
cover[5] = Node(50626LL, 2562991875LL, 1LL);
cover[6] = Node(2562991876LL, 777777777777LL, 2LL);
scanf("%d", &n);
long long sg = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &x);
for (int i = 0; i < 7; i++) {
if (cover[i].l <= x && cover[i].r >= x) {
sg ^= cover[i].sg;
break;
}
}
}
if (sg)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N_MAX = 100002;
int n;
struct Segment {
int la, ra;
int lb, rb;
int index;
long long h1;
long long h2;
};
Segment v[N_MAX];
bool fa(const Segment &a, const Segment &b) { return a.ra < b.ra; }
long long p[N_MAX];
long long sp[N_MAX];
long long mars[N_MAX];
void f() {
sort(v + 1, v + n + 1, fa);
for (int i = 1; i <= n; i++) sp[i] = (sp[i - 1] + p[v[i].index]) % MOD;
for (int i = 1; i <= n; i++) mars[i] = 0;
for (int i = 1; i <= n; i++) {
int l = 1, r = i;
while (l < r) {
int mid = ((l + r) >> 1);
if (v[mid].ra < v[i].la)
l = mid + 1;
else
r = mid;
}
v[i].h1 = (v[i].h1 + sp[i - 1] - sp[l - 1] + MOD) % MOD;
mars[l] = (mars[l] + p[v[i].index]) % MOD;
mars[i] = (mars[i] - p[v[i].index] + MOD) % MOD;
}
for (int i = 1; i <= n; i++) {
mars[i] = (mars[i] + mars[i - 1]) % MOD;
v[i].h1 = (v[i].h1 + mars[i]) % MOD;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i].la >> v[i].ra >> v[i].lb >> v[i].rb;
v[i].index = i;
}
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = 2 * p[i - 1] % MOD;
f();
for (int i = 1; i <= n; i++) {
swap(v[i].la, v[i].lb);
swap(v[i].ra, v[i].rb);
swap(v[i].h1, v[i].h2);
}
f();
for (int i = 1; i <= n; i++)
if (v[i].h1 != v[i].h2) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
int main() {
long long int test;
cin >> test;
while (test--) {
long long int l, r;
cin >> l >> r;
if (l * 2 <= r)
cout << l << " " << (l)*2 << "\n";
else
cout << "-1 -1\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1000 * 100 + 100;
long long n, a[maxn], dp[maxn], sum;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
dp[1] = 0;
if (a[1]) sum++;
for (int i = 2; i <= n; i++) {
if (!a[i]) {
dp[i] = dp[i - 1] + sum;
} else {
sum++;
dp[i] = dp[i - 1];
}
}
cout << dp[n] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int64_t n, p[100005], s[100005], i, A;
int main() {
cin >> n;
for (i = 2; i <= n; ++i) cin >> p[i];
for (i = 1; i <= n; ++i) cin >> s[i];
for (i = 2; i <= n; ++i)
(~s[i]) ? s[p[i]] = min(s[i], s[p[i]]) : s[i] = 1e9 + 1;
for (i = 1; i <= n; ++i)
if (s[i] < s[p[i]])
return puts("-1"), 0;
else
A += s[i] > 1e9 ? 0 : s[i] - s[p[i]];
cout << A;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100001];
string lexeme;
cin.getline(s, sizeof(s) / sizeof(s[0]));
char* p = s;
bool quote(false);
while (*p != 0) {
if (quote) {
if (*p != '\"') {
lexeme.push_back(*p);
} else {
cout << "<" << lexeme << ">" << endl;
lexeme.clear();
quote = false;
}
} else {
if (*p == '\"') {
quote = true;
} else if (*p == ' ') {
if (!lexeme.empty()) {
cout << "<" << lexeme << ">" << endl;
lexeme.clear();
}
} else {
lexeme.push_back(*p);
}
}
++p;
}
if (!lexeme.empty()) {
cout << "<" << lexeme << ">" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 1e5 + 10;
const int maxm = 4.1e7 + 10;
const int mod = 1e9 + 7;
int dp[4005], ans[4005];
int a[4005][4005], c[4005][4005];
inline void read(int &x) {
x = 0;
char c;
for (c = getchar(); c > '9' || c < '0'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ 48);
}
inline void solve(int l, int r, int L, int R) {
int m = (l + r) >> 1;
int mx = L;
ans[m] = dp[L - 1] + c[L][m];
for (int i = L, n = min(m, R); i <= n; i++) {
if (ans[m] > dp[i - 1] + c[i][m]) {
ans[m] = dp[i - 1] + c[i][m];
mx = i;
}
}
if (l < r) {
solve(l, m - 1, L, mx);
solve(m + 1, r, mx, R);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
read(n);
read(k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
read(a[i][j]);
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
c[i][j] = (a[j][j] - a[i - 1][j] - a[j][i - 1] + a[i - 1][i - 1]) >> 1;
}
}
for (int i = 1; i <= n; i++) ans[i] = c[1][i];
for (int i = 2; i <= k; i++) {
for (int j = 1; j <= n; j++) dp[j] = ans[j];
solve(1, n, 1, n);
}
printf("%d\n", ans[n]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long MOD = 1e9 + 7;
const int OO = 1e9;
const long long N = 1e5 + 5;
int f[N];
int joy[11];
int fav[505];
int k, n;
int mem[505][5005];
int dp(int idx, int rem) {
if (!idx) return 0;
int mn = min(k, rem);
int &ret = mem[idx][rem];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i <= mn; ++i)
if (i)
ret = max(ret, dp(idx - 1, rem - i) + joy[i - 1]);
else
ret = max(ret, dp(idx - 1, rem - i));
return ret;
}
int freq[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int c;
cin >> n >> k;
for (int i = 0; i < n * k; ++i) {
cin >> c;
f[c]++;
}
for (int i = 0; i < n; ++i) {
cin >> fav[i];
freq[fav[i]]++;
}
for (int i = 0; i < k; ++i) cin >> joy[i];
int ans = 0;
for (int i = 0; i < n; ++i) {
if (freq[fav[i]]) {
memset(mem, -1, sizeof mem);
ans += dp(freq[fav[i]], f[fav[i]]);
freq[fav[i]] = 0;
}
}
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
namespace Vectors {
struct Vector {
long long x, y;
inline Vector(long long _x = 0, long long _y = 0) { x = _x, y = _y; }
};
inline Vector operator+(const Vector& a, const Vector& b) {
return Vector(a.x + b.x, a.y + b.y);
}
inline Vector operator-(const Vector& a, const Vector& b) {
return Vector(a.x - b.x, a.y - b.y);
}
inline long long operator*(const Vector& a, const Vector& b) {
return a.x * b.x + a.y * b.y;
}
inline long long cross(const Vector& a, const Vector& b) {
return a.x * b.y - a.y * b.x;
}
} // namespace Vectors
using namespace Vectors;
Vector a[4005];
char str[4005];
bool mark[4005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
cin >> str + 1;
str[0] = 'L';
int i = 1;
for (int k = 2; k <= n; k++)
if (a[k].x > a[i].x) i = k;
cout << i << ' ';
mark[i] = 1;
for (int t = 1; t < n - 1; t++) {
int j = 1;
while (mark[j]) j++;
if (str[t] == 'L') {
for (int k = 1; k <= n; k++)
if (!mark[k] && cross(a[j] - a[i], a[k] - a[i]) < 0) j = k;
} else {
for (int k = 1; k <= n; k++)
if (!mark[k] && cross(a[j] - a[i], a[k] - a[i]) > 0) j = k;
}
mark[i = j] = 1;
cout << i << ' ';
}
i = 1;
while (mark[i]) i++;
cout << i << ' ';
return 0;
}
| 18 |
#include "bits/stdc++.h"
#define debug(...) 0
#ifdef LOCAL
#include "../../_library/cc/debug.h"
#endif
using namespace std;
void solve();
//#define FILE "family"
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
#if defined(FILE) && !defined(LOCAL)
freopen(FILE ".in", "r", stdin), freopen(FILE ".out", "w", stdout);
#endif
solve();
}
void solve() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> bits(N);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
char c;
cin >> c;
if (c == '1') {
bits[i].push_back(j);
}
}
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<int> order(N);
iota(order.begin(), order.end(), 0);
shuffle(order.begin(), order.end(), rng);
int best = 0;
string ans(M, '0');
for (int it = 0; it < min(N, 10); ++it) {
auto &cur_bits = bits[order[it]];
int sz = cur_bits.size();
vector<int> cnt(1 << sz);
for (int i = 0; i < N; ++i) {
int cur_mapped_mask = 0;
int friend_idx = 0;
for (int j = 0; j < sz; ++j) {
for (; friend_idx < bits[i].size() && bits[i][friend_idx] < cur_bits[j];
++friend_idx)
;
if (friend_idx == bits[i].size())
break;
if (bits[i][friend_idx] == cur_bits[j]) {
cur_mapped_mask |= 1 << j;
}
}
cnt[cur_mapped_mask]++;
}
for (int i = 0; i < (1 << sz); ++i) {
for (int j = (i - 1) & i; j; j = (j - 1) & i) {
cnt[j] += cnt[i];
}
}
for (int i = 0; i < (1 << sz); ++i) {
if (cnt[i] * 2 >= N && __builtin_popcount(i) > best) {
best = __builtin_popcount(i);
ans = string(M, '0');
for (int j = 0; j < sz; ++j) {
if ((i >> j) & 1) {
ans[cur_bits[j]] = '1';
}
}
}
}
}
cout << ans;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, L;
char S[200010][21];
int a[200010];
int dp[200010], *g[22], pool[(1 << 22) + 10], *p = pool;
inline int mask(int i) { return (1 << i) - 1; }
int common(int S1, int S2) {
for (int i = L; i >= 0; i--)
if ((S1 & mask(i)) == (S2 >> (L - i))) return i;
}
const int inf = 0x0f0f0f0f;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", S[i]);
L = strlen(S[1]);
for (int i = 1; i <= n; i++)
for (int j = 0; j < L; j++) a[i] <<= 1, a[i] += S[i][j] -= '0';
int base = 0;
memset(pool, 0x0f, sizeof(pool));
for (int i = 0; i <= L; i++) g[i] = p, p += 1 << i;
dp[0] = L;
g[0][0] = L;
for (int i = 2; i <= n; i++) {
int x = inf;
for (int j = 0; j <= L; j++) x = min(x, L - j + g[j][a[i] >> (L - j)]);
int d = L - common(a[i - 1], a[i]);
base += d;
dp[i - 1] = x - d;
for (int j = 0; j <= L; j++) {
int t = (a[i - 1] & mask(j));
g[j][t] = min(g[j][t], x - d);
}
}
int ans = inf;
for (int i = 0; i < n; i++) ans = min(ans, base + dp[i]);
printf("%d\n", ans);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int n, m, vis[101][101], cnt;
string s[101];
int dfs(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] || s[x][y] == '.')
return 0;
vis[x][y] = 1;
for (int i = 0; i < 4; i++) dfs(x + dx[i], y + dy[i]);
return 1;
}
void code() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') continue;
cnt++;
memset(vis, 0, sizeof(vis));
int tmp = 0;
s[i][j] = '.';
for (int k = 0; k < 4; k++) tmp += dfs(i + dx[k], j + dy[k]);
if (tmp > 1) {
cout << 1 << '\n';
return;
}
s[i][j] = '#';
}
}
cout << ((cnt < 3) ? -1 : 2) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
code();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 600005;
int vec[N], pre[N], base[N], c[N], tot;
int p[N];
int vis[N];
int ev[N];
void link(int x, int y) {
vec[++tot] = y;
pre[tot] = base[x];
base[x] = tot;
}
int dfs1(int u) {
int ret = 1;
vis[u] = 1;
for (int now = base[u]; now; now = pre[now]) {
int v = vec[now];
if (vis[v] || ev[now]) continue;
ev[now] = 1;
ev[p[now]] = 2;
ret += dfs1(v);
}
return ret;
}
int dfs2(int u) {
int ret = 1;
vis[u] = 1;
for (int now = base[u]; now; now = pre[now]) {
int v = vec[now];
if (vis[v] || ev[now]) continue;
if (p[now]) {
ev[now] = 2;
ev[p[now]] = 1;
} else
ret += dfs2(v);
}
return ret;
}
int main() {
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
for (int i = 1; i <= m; i++) {
int tp, x, y;
scanf("%d%d%d", &tp, &x, &y);
if (tp == 1)
link(x, y);
else {
link(x, y);
link(y, x);
p[tot] = tot - 1;
p[tot - 1] = tot;
}
}
memset(vis, 0, sizeof(vis));
memset(ev, 0, sizeof(ev));
printf("%d\n", dfs1(s));
for (int i = 1; i <= tot; i++)
if (p[i] && p[i] > i) printf(ev[i] == 1 ? "+" : "-");
printf("\n");
memset(vis, 0, sizeof(vis));
memset(ev, 0, sizeof(ev));
printf("%d\n", dfs2(s));
for (int i = 1; i <= tot; i++)
if (p[i] && p[i] > i) printf(ev[i] == 1 ? "+" : "-");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 123;
int mark[maxn];
vector<int> Res;
int n, x, maxd = 1000000, t;
int main() {
cin >> n;
while (n--) {
cin >> x;
mark[x] = 1;
}
for (int i = 1; i <= maxd; i++)
if (mark[i] == 1 && mark[maxd - i + 1] == 0) {
mark[maxd - i + 1] = 2;
Res.push_back(maxd - i + 1);
} else if (mark[i] == 1 && mark[maxd - i + 1] == 1)
t++, mark[maxd - i + 1] = 2;
for (int i = 1; i <= maxd; i++)
if (t > 0 && mark[i] == 0 && mark[maxd - i + 1] == 0) {
Res.push_back(i);
Res.push_back(maxd - i + 1);
t--;
}
cout << Res.size() << endl;
for (__typeof(Res.begin()) i = Res.begin(); i != Res.end(); ++i)
cout << (*i) << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int l;
char s[(1 << 20)];
char z[(1 << 20)];
int go(int f, int k, int eq) {
int t = l - k;
if (!t) return !f;
if (t < f) return 0;
if (!eq) {
if (f) {
z[k] = '4';
return go(f - 1, k + 1, 0);
} else {
z[k] = '7';
return go(f, k + 1, 0);
}
}
if (s[k] < '4') {
if (f) {
z[k] = '4';
return go(f - 1, k + 1, 0);
}
z[k] = '7';
return go(f, k + 1, 0);
} else if (s[k] == '4') {
if (f > 0 && go(f - 1, k + 1, 1)) {
z[k] = '4';
return 1;
}
if (go(f, k + 1, 0)) {
z[k] = '7';
return 1;
}
return 0;
} else if (s[k] < '7') {
if (go(f, k + 1, 0)) {
z[k] = '7';
return 1;
}
} else if (s[k] == '7') {
if (go(f, k + 1, 1)) {
z[k] = '7';
return 1;
}
return 0;
}
return 0;
}
int main(void) {
int i, j, k;
scanf("%s", s);
l = strlen(s);
if (l & 1) {
l++;
e:
int n = l >> 1;
for (i = 0; i < n; i++) putchar('4');
for (i = 0; i < n; i++) putchar('7');
printf("\n");
return 0;
}
int r = go(l >> 1, 0, 1);
if (r) {
for (i = 0; i < l; i++) putchar(z[i]);
printf("\n");
return 0;
}
l += 2;
goto e;
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.