solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int ans, t;
int A[5], B[5], C[5], D[5], st;
bool p;
char str[105][105];
bool mark[105][105];
bool hei[5];
int L, R, U, Di;
int main() {
int n, m, i, j, x = -1, y, k;
L = 1000000000;
R = -1;
U = 1000000000;
Di = -1;
for (i = 1; i <= 3; i++) {
scanf("%d %d", &A[i], &B[i]);
if (A[i] > B[i]) swap(A[i], B[i]);
ans += A[i] * B[i];
}
int q = sqrt(ans);
if (q * q != ans) {
puts("-1");
return 0;
}
for (i = 1; i <= 3; i++) {
if (B[i] != q) continue;
x = q - A[i];
st = A[i] + 1;
y = i;
for (j = 1; j <= A[i]; j++) {
for (k = 1; k <= q; k++) {
str[j][k] = 'A' + i - 1;
}
}
hei[i] = 1;
break;
}
if (x == -1) {
puts("-1");
return 0;
}
for (i = 1; i <= 3; i++) {
if (hei[i]) continue;
if (A[i] == x) {
for (j = st; j <= q; j++) {
for (k = 1; k <= B[i]; k++) {
str[j][k] = 'A' + i - 1;
}
}
hei[i] = 1;
break;
} else if (B[i] == q) {
for (j = st; j <= st + A[i] - 1; j++) {
for (k = 1; k <= q; k++) {
str[j][k] = 'A' + i - 1;
}
}
hei[i] = 1;
break;
} else if (B[i] == x) {
for (j = st; j <= q; j++) {
for (k = 1; k <= A[i]; k++) {
str[j][k] = 'A' + i - 1;
}
}
hei[i] = 1;
break;
} else {
puts("-1");
return 0;
}
}
for (k = 1; k <= 3; k++) {
if (!hei[k]) break;
}
for (i = 1; i <= q; i++) {
for (j = 1; j <= q; j++) {
if (str[i][j] <= 64 || str[i][j] >= 70) {
L = min(L, j);
R = max(R, j);
U = min(U, i);
Di = max(Di, i);
str[i][j] = 'A' + k - 1;
}
}
}
int h = Di - U + 1, w = R - L + 1;
if (h > w) swap(h, w);
if (h != A[k] || w != B[k]) {
puts("-1");
return 0;
}
printf("%d\n", q);
for (i = 1; i <= q; i++) {
printf("%s", str[i] + 1);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int inf_int = 1e9;
long long inf_ll = 1e16;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 3e5 + 100;
int mod = 1e9 + 7;
char used[MAXN];
void solve() {
int n;
cin >> n;
vector<pair<int, int> > a;
int x;
cin >> x;
for (int i = 2; i <= n; ++i) {
int x;
cin >> x;
a.push_back({x, i});
}
sort(a.rbegin(), a.rend());
queue<pair<int, int> > q;
int l = 0;
q.push({x, 1});
vector<pair<int, int> > ans;
while (!q.empty() && l < a.size()) {
int v = q.front().second, k = q.front().first;
q.pop();
used[v] = 1;
while (k-- && l < a.size()) {
q.push(a[l]);
ans.push_back({v, a[l].second});
++l;
}
}
if (ans.size() < n - 1) {
cout << -1;
} else {
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
}
int main() {
if (!debug) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int sum = 0, ct = 0;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
sum += arr[i];
}
if (sum / n == 5) {
cout << 0;
} else {
sort(arr, arr + n);
while (round((float)sum / (float)n) < 5) {
sum += (5 - arr[ct]);
ct++;
}
cout << ct;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
using namespace std;
const int MAXN = 2000 + 5;
const int MOD = 20071027;
int main() {
long long n, i, j;
cin >> n;
long long ans = 0;
for (i = 1;; i++) {
long long temp = (((1 + i) * i) >> 1) * 3 - i;
if (temp > n) break;
if ((n - temp) % 3 == 0) ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
V<lint> a(n), mask(n);
for (int i = 0; i < n; ++i) cin >> a[i] >> mask[i];
if (accumulate(begin(a), end(a), 0LL) < 0) {
for (auto&& e : a) e = -e;
}
V<bool> o(n, true);
lint res = 0;
for (int k = 61; k >= 0; --k) {
lint s = 0, t = 0;
for (int i = 0; i < n; ++i)
if (mask[i] == 1LL << k) {
if (o[i])
s += a[i];
else
t += a[i];
}
if (s > t) {
res |= 1LL << k;
for (int i = 0; i < n; ++i)
if (mask[i] >> k & 1) {
o[i] = !o[i];
}
}
for (int i = 0; i < n; ++i) {
mask[i] &= ~(1LL << k);
}
}
cout << res << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x;
cin >> n >> x;
long long int arr[2 * n], cnt[2 * n], dnt[2 * n];
cin >> arr[0];
cnt[0] = (arr[0] * (arr[0] + 1)) / 2;
dnt[0] = arr[0];
vector<long long int> v;
v.push_back(dnt[0]);
for (long long int i = 1; i < 2 * n; i++) {
if (i < n)
cin >> arr[i];
else
arr[i] = arr[i - n];
cnt[i] = cnt[i - 1] + (arr[i] * (arr[i] + 1)) / 2;
dnt[i] = dnt[i - 1] + arr[i];
v.push_back(dnt[i]);
}
long long int mx = 0;
for (long long int i = 0; i < 2 * n; i++) {
long long int a = dnt[i] - x;
if (a >= 0) {
long long int b = lower_bound(v.begin(), v.end(), a) - v.begin();
long long int remain = x - (dnt[i] - dnt[b]);
long long int sum = cnt[i] - cnt[b];
sum += (remain * (2 * arr[b] - remain + 1)) / 2;
mx = max(mx, sum);
}
}
cout << mx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int abs(int x) { return (x > 0 ? x : -x); }
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
int sum1 = 0, sum2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
sum1 += a[i];
sum2 += b[i];
}
if ((sum1 % 2 == 0) && (sum2 % 2 == 0)) {
cout << 0 << endl;
return 0;
}
if ((sum1 + sum2) % 2 == 1) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++)
if (abs(a[i] - b[i]) % 2 == 1) {
cout << 1 << endl;
return 0;
}
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x[3], k;
while (scanf("%d%d%d%d", &x[0], &x[1], &x[2], &k) != EOF) {
sort(x, x + 3);
long long ans = 1, tmp = k / 3;
for (int i = 0; i < 3; ++i) {
tmp = k / (3 - i);
if (x[i] - 1 < tmp) {
ans *= x[i];
k -= x[i] - 1;
} else {
ans *= tmp + 1;
k -= tmp;
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char str[300005];
long long dp[300005][4];
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
dp[i][(str[i] - '0') % 4]++;
for (int j = 0; j <= 3; j++) {
dp[i][(j * 10 + str[i] - '0') % 4] += dp[i - 1][j];
}
}
long long ans = 0;
for (int i = 1; i <= len; i++) ans += dp[i][0];
printf("%I64d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int A[10005];
int main() {
int n, i;
cin >> A[0] >> A[1] >> n;
for (i = 2; i <= n; i++) {
A[i] = A[i - 1] + A[i - 2];
}
cout << A[n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d;
scanf("%d %d", &a, &b);
if (a > b) {
c = b;
d = (a - b) / 2;
} else if (b > a) {
c = a;
d = (b - a) / 2;
} else if (a == b) {
c = a;
d = 0;
}
printf("%d %d\n", c, d);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 30005;
vector<int> ans1, ans2;
int a[MAX], n;
bool mark[MAX];
bool isgood(vector<int> v) {
if (v.size() <= 2) return true;
int d = a[v[1]] - a[v[0]];
for (int i = 2; i < v.size(); i++)
if (a[v[i]] != a[v[i - 1]] + d) return false;
return true;
}
bool check(int p1, int p2) {
memset(mark, false, sizeof(mark));
mark[p1] = mark[p2] = true;
ans1.clear();
ans2.clear();
ans1.push_back(p1);
ans1.push_back(p2);
int d = a[ans1[1]] - a[ans1[0]];
for (int i = p2 + 1; i < n; i++)
if (a[i] == a[ans1.back()] + d) {
ans1.push_back(i);
mark[i] = true;
}
for (int i = 0; i < 100 && ans1.size(); i++) {
for (int i = 0; i < n; i++)
if (!mark[i]) ans2.push_back(i);
if (isgood(ans2)) return true;
mark[ans1.back()] = false;
ans1.pop_back();
ans2.clear();
}
return false;
}
void print() {
if (ans1.size() == n) {
ans2.push_back(ans1.back());
ans1.pop_back();
}
if (ans2.size() == n) {
ans1.push_back(ans2.back());
ans2.pop_back();
}
for (int i = 0; i < ans1.size(); i++) cout << a[ans1[i]] << " ";
cout << endl;
for (int i = 0; i < ans2.size(); i++) cout << a[ans2[i]] << " ";
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (check(0, 1)) {
print();
return 0;
}
if (check(0, 2)) {
print();
return 0;
}
if (check(1, 2)) {
print();
return 0;
}
cout << "No solution";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int lg = 22;
const int maxn = 1 << lg;
int n;
int ANS;
int u[maxn];
int v[maxn];
int felan = 1;
int deg[maxn];
bool mark[maxn];
int madude[maxn];
vector<pair<int, int>> adj[maxn], ans;
vector<pair<int, pair<int, int>>> newbois[maxn];
void in();
void solve();
void gofor(int x);
void MAKE(int ID, int u);
void make(int ID, int u);
bool has(int x);
void dfs(int u);
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n;
for (int i = 0; i < n; i++) cin >> u[i] >> v[i];
}
void solve() {
int l = 0;
int r = 21;
while (r - l != 1) {
int mid = (l + r) >> 1;
if (has(mid))
l = mid;
else
r = mid;
}
ANS = l;
gofor(l);
}
void gofor(int x) {
for (int i = 0; i < maxn; i++) {
adj[i].clear();
mark[i] = 0;
}
int mask = (1 << x) - 1;
for (int i = 0; i < n; i++) {
adj[u[i] & mask].push_back({i * 2 + 1, v[i] & mask});
adj[v[i] & mask].push_back({i * 2, u[i] & mask});
deg[u[i] & mask]++;
deg[v[i] & mask]++;
}
for (int i = 0; i < (1 << x); i++)
if (deg[i]) MAKE(0, i);
}
void MAKE(int ID, int u) {
make(ID, u);
int now = u;
for (auto i : newbois[ID]) {
if (deg[now]) MAKE(felan++, now);
ans.push_back(i.second);
now = i.first;
}
if (deg[now]) MAKE(felan++, now);
}
void make(int ID, int u) {
for (; madude[u] < adj[u].size(); madude[u]++) {
auto v = adj[u][madude[u]];
if (!mark[v.first / 2]) {
newbois[ID].push_back({v.second, {v.first ^ 1, v.first}});
mark[v.first / 2] = 1;
deg[u]--;
deg[v.second]--;
make(ID, v.second);
return;
}
}
}
bool has(int x) {
for (int i = 0; i < (1 << x); i++) {
adj[i].clear();
mark[i] = 0;
}
int mask = (1 << x) - 1;
for (int i = 0; i < n; i++) {
adj[u[i] & mask].push_back({i * 2 + 1, v[i] & mask});
adj[v[i] & mask].push_back({i * 2, u[i] & mask});
}
int boi = 0;
for (int i = 0; i < (1 << x); i++) {
if (adj[i].size() % 2) return 0;
if (adj[i].size() != 0 && !mark[i]) {
dfs(i);
boi++;
}
}
if (boi <= 1) return 1;
return 0;
}
void dfs(int u) {
mark[u] = 1;
for (auto v : adj[u])
if (!mark[v.second]) dfs(v.second);
}
void out() {
cout << ANS << '\n';
for (auto i : ans) cout << i.first + 1 << ' ' << i.second + 1 << ' ';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int length, operations;
cin >> length >> operations;
string enter;
getline(cin, enter);
string strOfLength;
getline(cin, strOfLength);
for (int i = 1; i <= operations; i++) {
int l, r;
char c1, c2;
cin >> l >> r >> c1 >> c2;
for (int j = l - 1; j <= r - 1; j++) {
if (strOfLength[j] == c1) {
strOfLength[j] = c2;
}
}
}
cout << strOfLength;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define UNmap unordered_map
#define UNset unordered_set
#define endl "\n"
#define speedup \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
bool ans(string s1, char a, char b, char c)
{
string s=s1;
for (int i=0;i<s.size();i++)
{
if (s[i] == 'A')
{
s[i] = a;
}
else if (s[i] == 'B')
{
s[i] = b;
}
else
{
s[i] = c;
}
}
stack<char> st;
for(int i = 0;i < s.size();i++)
{
if (s[i] == '(')
{
st.push(s[i]);
}
else
{
if (st.size() == 0)
{
return false;
}
if (st.top() == '(')
{
st.pop();
}
else
{
return false;
}
}
}
return st.size() == 0;
}
signed main()
{
int t;
cin >> t;
while (t--)
{
string s;
cin >> s;
bool f = ans(s, ')', ')', '(');
bool g = ans(s, ')', '(', ')');
bool h = ans(s, ')', ')', ')');
bool a = ans(s, '(', '(', '(');
bool b = ans(s, '(', '(', ')');
double ans1=1234.12;
int pp=1;
bool c = ans(s, '(', ')', '(');
int j=1;
int res=2;
bool d = ans(s, ')', '(', '(');
bool e = ans(s, '(', ')', ')');
if (a || b || c || d || e || f || g || h) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[200005], b[200005], k = 0, m1 = 0;
map<long long, long long> x;
long long sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> b[i];
if (b[i] == 0) m1++;
sum += b[i];
}
m -= m1;
long long ans = 0, ans1 = 1e18, startpos = 0;
for (int i = 0; i < n; i++) {
x[a[i]]++;
ans++;
if (x[a[i]] == b[a[i]]) k++;
if (k >= m) {
while (x[a[startpos]] > b[a[startpos]]) {
x[a[startpos]]--;
ans--;
startpos++;
}
ans1 = min(ans1, ans);
}
}
if (ans1 == 1e18)
cout << -1;
else
cout << ans1 - sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long T00B1G = 9223372036854775807LL;
const int maskl = 5;
bool mask[64][5];
template <class TEl>
using TTable = std::vector<std::vector<TEl>>;
template <class TEl>
void spacecreator(long long first, long long second, TTable<TEl>& vec) {
vec.resize(first);
for (auto& sub : vec) {
sub.resize(second);
}
}
template <class T>
void makemask(long long nn, T& mask) {
long long ulim = 1 << nn;
for (long long st = 0; st < ulim; st++) {
for (auto pos = 0; pos < nn; pos++) {
mask[st][pos] = (st >> pos) & 1;
}
}
}
int main() {
long long nn, mm;
TTable<long long> dp;
TTable<long long> left, down;
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cin >> nn >> mm;
spacecreator(mm + 5, 64, dp);
spacecreator(maskl, mm + 5, left);
spacecreator(maskl, mm + 5, down);
for (auto col = 1; col < mm; col++) {
for (auto row = 0; row < nn; row++) {
std::cin >> left[row][col];
}
}
for (auto col = 0; col < mm; col++) {
for (auto row = 0; row < nn; row++) {
std::cin >> down[row][col];
}
}
makemask(nn, mask);
long long ulim = 1 << nn, fix, t1;
for (auto col = 1; col < mm; col++) {
for (long long st = 0; st < ulim; st++) {
fix = 0;
dp[col][st] = T00B1G;
for (auto row = 0; row < nn - 1; row++) {
long long next = row + 1;
if ((mask[st][row] ^ mask[st][next]) == 1) {
fix += down[row][col];
}
}
if ((mask[st][nn - 1] ^ mask[st][0]) == 1) {
fix += down[nn - 1][col];
}
for (long long prev = 0; prev < ulim; prev++) {
if (col == 1 && prev != 0) {
break;
}
t1 = 0;
for (long long row = 0; row < nn; row++) {
if ((mask[st][row] ^ mask[prev][row]) == 1) {
t1 += left[row][col];
}
}
dp[col][st] = std::min(dp[col][st], dp[col - 1][prev] + t1 + fix);
}
}
}
std::cout << dp[mm - 1][ulim - 1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 10;
int n;
vector<int> G[maxn];
int fa[3010][3010], siz[3010][3010];
void dfs1(int u, int _fa, int rt) {
fa[rt][u] = _fa;
siz[rt][u] = 1;
for (int v : G[u]) {
if (v == _fa) continue;
dfs1(v, u, rt);
siz[rt][u] += siz[rt][v];
}
}
long long dp[3010][3010];
long long dfs2(int u, int v) {
if (u == v) return 0;
if (dp[u][v] != -1) return dp[u][v];
return dp[u][v] = 1ll * siz[v][u] * siz[u][v] +
1ll * max(dfs2(u, fa[u][v]), dfs2(v, fa[v][u]));
}
long long ans;
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
dfs1(i, 0, i);
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans = max(dfs2(i, j), ans);
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char Tab[505][505];
long long T = 0;
int R, C, K, CNT[505][505], MAT[505][505];
bool HaveAnStar(int rr, int cc) {
return (5 == MAT[rr][cc] + MAT[rr + 1][cc] + MAT[rr - 1][cc] +
MAT[rr][cc + 1] + MAT[rr][cc - 1]);
}
int ContingStars(int r, int c, int rr, int cc) {
int SUM = CNT[rr][cc] - CNT[rr][c + 1] - CNT[r + 1][cc] + CNT[r + 1][c + 1];
return SUM;
}
int BinarySearch(int r, int c, int rr) {
if (K > ContingStars(r, c, rr, C)) return 1 + C;
int cc, izq = c + 2, der = C;
while (1) {
if (izq == der) return izq;
cc = (izq + der) >> 1;
if (K > ContingStars(r, c, rr, cc))
izq = cc + 1;
else
der = cc;
}
}
int main() {
scanf("%d%d%d", &R, &C, &K);
for (int r = (1); r <= (R); r += (1)) scanf("%s", &Tab[r]);
for (int r = (1); r <= (R); r += (1))
for (int c = (1); c <= (C); c += (1)) MAT[r][c] = Tab[r][c - 1] - '0';
for (int r = (2); r <= (R - 1); r += (1))
for (int c = (2); c <= (C - 1); c += (1))
if (HaveAnStar(r, c)) CNT[r + 1][c + 1] = 1;
for (int r = (2); r <= (R - 0); r += (1))
for (int c = (2); c <= (C - 0); c += (1))
CNT[r][c] += (CNT[r - 1][c] + CNT[r][c - 1] - CNT[r - 1][c - 1]);
for (int r = (1); r <= (R - 2); r += (1))
for (int c = (1); c <= (C - 2); c += (1))
for (int rr = (r + 2); rr <= (R); rr += (1))
T += (1 + C - BinarySearch(r, c, rr));
cout << T << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
struct centroid {
int c, s;
vector<vector<int>> adj;
vector<bool> vis;
vector<int> sz;
centroid(int n) : adj(n), vis(n, 0), sz(n) {}
centroid(vector<vector<int>> _adj)
: adj(_adj), vis(_adj.size(), 0), sz(_adj.size()) {}
void edge(int i, int j) {
adj[i].push_back(j);
adj[j].push_back(i);
}
void dfs1(int i, int p) {
sz[i] = 1;
for (int j : adj[i])
if (j != p && !vis[j]) {
dfs1(j, i);
sz[i] += sz[j];
}
}
void dfs2(int i, int p) {
bool v = sz[i] >= s;
for (int j : adj[i])
if (j != p && !vis[j]) {
dfs2(j, i);
v &= sz[j] <= s;
}
if (v) c = i;
}
int find(int r) {
dfs1(r, r);
s = sz[r] / 2;
dfs2(r, r);
return c;
}
vector<int> list() {
vector<int> out, stk = {0};
while (!stk.empty()) {
int i = find(stk.back());
stk.pop_back();
out.push_back(i);
vis[i] = 1;
for (int j : adj[i])
if (!vis[j]) stk.push_back(j);
}
return out;
}
pair<int, vector<vector<int>>> tree() {
int root = find(0);
vector<vector<int>> out(adj.size());
vector<int> stk = {root};
while (!stk.empty()) {
int i = stk.back();
stk.pop_back();
vis[i] = 1;
for (int j : adj[i])
if (!vis[j]) {
int r = find(j);
out[i].push_back(r);
stk.push_back(r);
}
}
return {root, out};
}
};
vector<vector<int>> adj;
vector<ll> s, val;
ll r, b, t1, t2;
void dfs(int i, int k) {
s[i] = 1;
for (int j : adj[i])
if (j != k) dfs(j, i), s[i] += s[j];
}
void dfs2(int i, int k, bool small) {
if (small) {
t1 += 1;
val[i] = t1;
} else {
t2 += b;
val[i] = t2;
}
cout << i + 1 << " " << k + 1 << " " << val[i] - val[k] << "\n";
for (int j : adj[i])
if (j != k) dfs2(j, i, small);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
adj.resize(n);
s.resize(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y), adj[y].push_back(x);
}
r = centroid(adj).find(0);
dfs(r, r);
0;
for (int i : adj[r]) 0;
vector<bool> dp(n + 1, 0), ch(n, 0);
vector<int> nxt(n + 1);
dp[0] = 1;
nxt[0] = -1;
for (int i : adj[r])
for (int j = n; j >= s[i]; j--)
if (dp[j - s[i]] && !dp[j]) dp[j] = 1, nxt[j] = i;
for (int i = 0; i <= n; i++)
if (dp[i] && 3 * i >= n && 3 * i <= 2 * n) b = i + 1;
0;
ll y = b - 1;
val.resize(n);
while (y > 0) {
int i = nxt[y];
0;
y -= s[i], ch[i] = 1;
}
for (int i : adj[r]) dfs2(i, r, ch[i]);
0;
if (n != 1) {
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int aux = n / k;
printf("%d\n", k * (aux + 1));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int base;
int conv(char c) {
if (c >= '0' && c <= '9') return c - '0';
return c - 'A' + 10;
}
int solve(string s) {
int ret = 0;
for (int i = 0; i < s.size(); i++) {
int t = conv(s[i]);
if (t >= base) return 1 << 30;
ret = ret * base + t;
if (ret > 100) return 1 << 30;
}
return ret;
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ':') s[i] = ' ';
}
stringstream ss(s);
string a, b;
ss >> a >> b;
vector<int> v;
for (base = 2; base <= 1000; base++) {
if (solve(a) < 24 && solve(b) < 60) v.push_back(base);
}
if (v.size() > 100) {
cout << -1;
return 0;
}
if (v.size() == 0) {
cout << 0;
return 0;
}
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[100010];
vector<int> points[10];
int dis[100010][10];
int dch[10][10];
int cnt[10][300];
int mask[100010];
int ans;
long long ans2;
void update(int x, int tot) {
if (x == ans) ans2 += tot;
if (x > ans) {
ans = x;
ans2 = tot;
}
}
void bfs(int ch) {
queue<int> q;
for (vector<int>::iterator i = points[ch].begin(); i != points[ch].end(); i++)
q.push(*i);
for (int i = 1; i <= n; i++)
if (a[i] == ch + 96)
dis[i][ch] = 0;
else
dis[i][ch] = 0x3f3f3f3f;
while (!q.empty()) {
int x = q.front();
q.pop();
if (dis[x - 1][ch] == 0x3f3f3f3f) {
dis[x - 1][ch] = dis[x][ch] + 1;
q.push(x - 1);
}
if (dis[x + 1][ch] == 0x3f3f3f3f) {
dis[x + 1][ch] = dis[x][ch] + 1;
q.push(x + 1);
}
}
}
void add(int pos) { cnt[a[pos] - 96][mask[pos]]++; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf(" %c", &a[i]);
points[a[i] - 96].push_back(i);
}
for (int ch = 1; ch <= 8; ch++) bfs(ch);
memset(dch, 0x3f, sizeof(dch));
for (int i = 1; i <= 8; i++) dch[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= 8; i++)
for (int j = 1; j <= 8; j++)
dch[i][j] = min(dch[i][j], dis[k][i] + dis[k][j]);
for (int k = 1; k <= 8; k++)
for (int i = 1; i <= 8; i++)
for (int j = 1; j <= 8; j++)
dch[i][j] = min(dch[i][j], dch[i][k] + dch[k][j] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 8; j++)
for (int ch = 1; ch <= 8; ch++)
dis[i][ch] = min(dis[i][ch], dis[i][j] + dch[j][ch] + 1);
for (int i = 1; i <= n; i++)
for (int ch = 1; ch <= 8; ch++)
mask[i] |= (dis[i][ch] - dch[a[i] - 96][ch]) << (ch - 1);
for (int r = 1; r <= n; r++)
for (int l = max(1, r - 15); l < r; l++) {
int minf = r - l;
for (int ch = 1; ch <= 8; ch++)
minf = min(minf, dis[l][ch] + dis[r][ch] + 1);
update(minf, 1);
}
for (int i = 17, j = 1; i <= n; i++, j++) {
add(j);
for (int ch = 1; ch <= 8; ch++)
for (int st = 0; st <= 255; st++) {
if (cnt[ch][st]) {
int fuck = 0x3f3f3f3f;
for (int sb = 1; sb <= 8; sb++)
fuck = min(fuck,
dch[ch][sb] + dis[i][sb] + (((st) >> (sb - 1)) & 1) + 1);
update(fuck, cnt[ch][st]);
}
}
}
printf("%d %lld\n", ans, ans2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, x, y, n;
cin >> a >> b >> x >> y >> n;
long long ans = 0;
long long l1 = 1e18 + 10, l2 = 1e18 + 10, l3 = 1e18 + 10, l4 = 1e18 + 10;
long long diff1 = a - x, diff2 = b - y;
if (diff1 + diff2 < n) {
ans = x * y;
cout << ans << endl;
continue;
}
if (a - x >= n) {
l1 = (a - n) * (b);
}
if (b - y >= n) {
l2 = (b - n) * a;
}
if (a - x < n) {
if (n - diff1 <= (diff2)) l3 = x * (b - (n - diff1));
}
if (b - y < n) {
if (n - diff2 <= diff1) l4 = y * (a - (n - diff2));
}
ans = (min(l4, min(l3, min(l1, l2))));
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 110;
int day[NN], n, m;
int main() {
fill(day, day + NN, 0);
cin >> n >> m;
for (int a, b, i = 1; i <= m; i++) {
cin >> a >> b;
for (int j = a; j <= b; j++) day[j]++;
}
for (int i = 1; i <= n; i++)
if (day[i] == 0 || day[i] > 1) {
cout << i << ' ' << day[i] << endl;
return 0;
}
cout << "OK\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double dp[105][105000];
int a[105];
int judge(int x) {
if (x < 0)
return 0;
else
return x;
}
int main() {
int n, m;
cin >> n >> m;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 1; i <= n * m; i++) {
if (a[1] == i)
dp[1][i] = dp[1][i - 1];
else {
dp[1][i] = dp[1][i - 1] + 1.0 / (m - 1);
}
if (dp[1][i] > 1) dp[1][i] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = i; j <= n * m; j++) {
dp[i][j] =
(dp[i - 1][judge(j - 1)] - dp[i - 1][judge(j - 1 - m)] -
(dp[i - 1][judge(j - a[i])] - dp[i - 1][judge(j - a[i] - 1)])) /
(m - 1);
dp[i][j] += dp[i][j - 1];
}
}
printf("%.12lf\n", dp[n][sum - 1] * (m - 1) + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
srand(chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
map<int, int> z;
for (int i = 0; i < n; ++i) {
int val;
cin >> val;
z[val] = 1;
}
int found = -1;
for (int j = 0; j < m; ++j) {
int val;
cin >> val;
if (z[val]) found = val;
}
if (found == -1) {
cout << "NO\n";
} else {
cout << "YES\n" << 1 << ' ' << found << '\n';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long N, M;
int main(void) {
long i, j, u, v, Icase, k = 0;
scanf("%ld%ld", &N, &M);
set<pair<long, long> > s;
for (i = 1; i <= M; i++) {
scanf("%ld%ld", &u, &v);
s.insert(make_pair(u, v));
s.insert(make_pair(v, u));
}
vector<long> Vec;
for (i = 1; i <= N; i++) {
Vec.push_back(i);
}
long Cnt = 100;
do {
random_shuffle(Vec.begin(), Vec.end());
for (i = 0; i < M; i++) {
u = Vec[i];
v = Vec[(i + 1) % N];
if (s.find(make_pair(u, v)) != s.end()) break;
}
if (i == M) {
for (i = 0; i < M; i++) {
u = Vec[i];
v = Vec[(i + 1) % N];
printf("%ld %ld\n", u, v);
}
return 0;
}
Cnt--;
if (!Cnt) break;
} while (next_permutation(Vec.begin(), Vec.end()));
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void Make_tree(int n, int d, int k) {
if (d > n - 1) {
cout << "NO";
return;
}
vector<int> deg(n);
vector<pair<int, int> > ans;
set<pair<int, int> > q;
for (int i = 0; i < d; ++i) {
++deg[i];
++deg[i + 1];
if (deg[i] > k || deg[i + 1] > k) {
cout << "NO" << endl;
return;
}
ans.push_back(make_pair(i, i + 1));
}
for (int i = 1; i < d; ++i) q.insert(make_pair(max(i, d - i), i));
for (int i = d + 1; i < n; ++i) {
while (!q.empty() && deg[q.begin()->second] == k) q.erase(q.begin());
if (q.empty() || q.begin()->first == d) {
cout << "NO";
return;
}
++deg[i];
++deg[q.begin()->second];
ans.push_back(make_pair(i, q.begin()->second));
q.insert(make_pair(q.begin()->first + 1, i));
}
cout << "YES" << endl;
for (int i = 0; i < n - 1; ++i)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
int main() {
int n, d, k;
cin >> n >> d >> k;
Make_tree(n, d, k);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int n, long long int m);
long long int power(long long int a, long long int n, long long int m) {
if (n == 0) return 1;
long long int x = power(a, n / 2, m);
if (n % 2 != 0)
return (((a * x) % m) * (x) % m) % m;
else
return (x * x) % m;
}
map<long long int, long long int>::iterator it;
int32_t main() {
long long int n, i, j, x, y, m, k, t, sum, count, cnt, b, c, d, j1, z, a, o,
temp;
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> x >> y;
if (x == 0) {
cout << "Bob\n";
continue;
}
if (x <= 2 || x == y) {
cout << "Alice\n";
continue;
}
if (y == 3) {
if (x == 4) {
cout << "Bob\n";
continue;
}
if ((x) % 4 != 0) {
cout << "Alice\n";
continue;
} else {
cout << "Bob\n";
continue;
}
} else {
if (y % 3 != 0) {
if (x % 3 == 0)
cout << "Bob\n";
else
cout << "Alice\n";
} else if (x < y) {
if (x % 3 == 0)
cout << "Bob\n";
else
cout << "Alice\n";
} else if (x % (y + 1) == 0)
cout << "Bob\n";
else if (x % (y + 1) == y)
cout << "Alice\n";
else if ((x % (y + 1)) % 3 == 0)
cout << "Bob\n";
else
cout << "Alice\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5;
const long long int mod = 1e9 + 7;
void solve() {
long long int n, idx;
string a;
set<string> grps;
vector<string> trans;
cin >> n;
for (long long int i = 0; i < n; i++) {
trans.clear();
cin >> a;
idx = a.size() - 1;
while (idx >= 0) {
if (a[idx] == 'u') {
trans.push_back("oo");
idx--;
} else if (a[idx] == 'h') {
idx = idx - 1;
while (idx >= 0 && a[idx] == 'k') idx--;
trans.push_back("h");
} else {
string str = "";
str += a[idx];
trans.push_back(str);
idx--;
}
}
grps.insert(accumulate(trans.rbegin(), trans.rend(), string("")));
}
cout << grps.size();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t t1, t2;
t1 = clock();
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 210000;
const long long base = 1e9 + 7;
struct Node {
int ns[3];
};
int pos[MAX][5];
Node stree[MAX * 4];
string sss;
int gstart = 0;
int gend = 1111;
static int count_tn = 0;
struct TNode {
int root, nstart, nend, mid;
TNode() {}
TNode(int r, int ns, int ne) {
root = r;
nstart = ns;
nend = ne;
mid = (ns + ne) / 2;
}
TNode getLeft() const { return TNode(root * 2 + 1, nstart, mid); }
TNode getRight() const { return TNode(root * 2 + 2, mid + 1, nend); }
};
TNode superRoot;
void refresh(Node& n0, Node& n1, Node& n2) {
for (int i = 0; i < 3; ++i) {
n0.ns[i] = n1.ns[i] + n2.ns[i];
}
}
void refresh(int root, int left, int right) {
refresh(stree[root], stree[left], stree[right]);
}
void init(int root, int nstart) {
for (int i = 0; i < 3; ++i) {
stree[root].ns[i] = 0;
}
char c = sss[nstart];
int t;
if (c == 'R')
t = 0;
else if (c == 'P')
t = 1;
else if (c == 'S')
t = 2;
stree[root].ns[t] = 1;
return;
}
void buildt(const TNode& tn) {
if (tn.nstart == tn.nend) {
init(tn.root, tn.nstart);
return;
}
auto tn0 = tn.getLeft();
auto tn1 = tn.getRight();
buildt(tn0);
buildt(tn1);
refresh(tn.root, tn0.root, tn1.root);
}
void update(const TNode& tn, int change) {
if (change < tn.nstart || change > tn.nend) return;
if (tn.nstart == tn.nend) {
init(tn.root, tn.nstart);
return;
}
auto tn0 = tn.getLeft();
auto tn1 = tn.getRight();
update(tn0, change);
update(tn1, change);
refresh(tn.root, tn0.root, tn1.root);
}
int query1(const TNode& tn, int s, bool le) {
if (stree[tn.root].ns[s] == 0) return -1;
if (tn.nstart == tn.nend) {
return tn.nstart;
}
auto tn0 = tn.getLeft();
auto tn1 = tn.getRight();
if (le) {
auto r1 = query1(tn0, s, le);
if (r1 >= 0) return r1;
auto r2 = query1(tn1, s, le);
return r2;
} else {
auto r2 = query1(tn1, s, le);
if (r2 >= 0) return r2;
auto r1 = query1(tn0, s, le);
return r1;
}
}
int query0(const TNode& tn, int b1, int b2, int s) {
if (b2 < tn.nstart || b1 > tn.nend) return 0;
if (b1 <= tn.nstart && tn.nend <= b2) {
return stree[tn.root].ns[s];
}
auto tn0 = tn.getLeft();
auto tn1 = tn.getRight();
auto r1 = query0(tn0, b1, b2, s);
auto r2 = query0(tn1, b1, b2, s);
return r1 + r2;
}
int n, q;
void work() {
int tot = 0;
bool mis = false;
for (int i = 0; i < 3; ++i) {
if (stree[0].ns[(i + 1) % 3] == 0) {
tot += stree[0].ns[i];
mis = true;
}
}
if (mis) {
cout << tot << '\n';
return;
}
int tb[3], te[3];
for (int i = 0; i < 3; ++i) {
tb[i] = query1(superRoot, i, true);
te[i] = query1(superRoot, i, false);
}
tot = n;
for (int i = 0; i < 3; ++i) {
int a = te[(i + 2) % 3];
int b = te[(i + 1) % 3];
if (a < b) {
tot -= query0(superRoot, a, b, i);
}
a = tb[(i + 1) % 3];
b = tb[(i + 2) % 3];
if (a < b) {
tot -= query0(superRoot, a, b, i);
}
}
cout << tot << '\n';
}
void solve() {
long long result = 0;
cin >> n >> q;
cin >> sss;
superRoot = {0, 0, n - 1};
buildt(superRoot);
work();
for (int i = 0; i < q; ++i) {
int k;
string s;
cin >> k >> s;
sss[k - 1] = s[0];
update(superRoot, k - 1);
work();
}
int ttt = count_tn;
int x = 1;
}
int main() {
const int inId = 0;
const int outId = 0;
if (inId > 0) {
cerr << "redirect stdin to input " << inId << endl;
string s = "input";
s += to_string(inId);
s += ".txt";
auto r = freopen(s.c_str(), "r", stdin);
if (r == nullptr) {
cerr << "invalid input file " << s;
}
}
if (outId > 0) {
cerr << "redirect stdout to stdout " << outId << endl;
string s = "stdout";
s += to_string(outId);
s += ".txt";
auto r = freopen(s.c_str(), "w", stdout);
if (r == nullptr) {
cerr << "invalid output file " << s;
}
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(10);
solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1, inf = 1e9 + 100;
bool solve(long long a, long long n, long long p, long long h) {
if (h == 0) {
return false;
}
a %= p;
if (a * n < p) {
return h >= a;
}
long long a1 = min(p % a, a - p % a);
long long n1 = (n * a / p);
if ((n * a) % p + a < p / a * a) {
--n1;
}
long long p1 = a;
if (a1 * n1 < p1) {
return h >= max(a1, p1 - a1 * n1);
}
return solve(a1, n1, p1, h);
}
int main() {
int T;
cin >> T;
while (T--) {
int a, n, p, h;
cin >> a >> n >> p >> h;
cout << (solve(a, n, p, h) ? "YES" : "NO") << "\n";
}
return 0;
}
| 11 |
#include<bits/stdc++.h>
#define ll long long int
#define pb push_back
using namespace std;
int main(){
ll t;
cin >> t;
while (t--)
{
ll n;
cin >> n;
vector<double>v1;
vector<double>v2;
ll x, y;
for (ll i = 0; i < 2 * n; i++)
{
cin >> x >> y;
if (x == 0)
v1.pb(abs(y));
else
v2.pb(abs(x));
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
double sum = 0;
for (ll i = 0; i < n; i++)
{
sum = sum + sqrt(v1[i] * v1[i] + v2[i] * v2[i]);
}
cout << fixed << setprecision(9) << sum << endl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
template <typename T>
T gcd(T a, T b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
namespace Problem {
using namespace std;
class Solver2 {
public:
LL n, m;
vector<vector<LL>> to;
vector<pair<LL, LL>> dist;
Solver2(LL n, LL m) : n(n), m(m), to(n), dist(n){};
pair<LL, LL> calc(int x) {
pair<LL, LL> ret = {0ll, LINF};
ret.first = to[x].size();
for (LL y : to[x]) {
ret.second = min(ret.second, ((y - x + n) % n));
}
if (ret.first == 0) ret.second = 0;
return ret;
}
void solve() {
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
}
for (int i = 0; i < n; ++i) {
dist[i] = calc(i);
;
}
vector<LL> ans(n);
for (int s = 0; s < n; ++s) {
LL tmp = 0;
for (int i = 0; i < n; ++i) {
tmp = max(tmp,
n * (dist[i].first - 1) + (i - s + n) % n + dist[i].second);
}
ans[s] = tmp;
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << ' ';
}
cout << "\n";
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
long long n = 0, m;
std::cin >> n >> m;
Problem::Solver2 sol(n, m);
sol.solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class segm_tree {
vector<int> tr;
vector<int> xs;
int off;
int xoff, mod;
int init;
int _get(int l, int r) {
l = lower_bound(xs.begin(), xs.end(), l) - xs.begin() + off;
r = upper_bound(xs.begin(), xs.end(), r) - xs.begin() - 1 + off;
int res = init;
while (l <= r) {
if (l & 1) res = min(res, tr[l++]);
if (!(r & 1)) res = min(res, tr[r--]);
l >>= 1;
r >>= 1;
}
return res;
}
public:
segm_tree(int n, int _init, const vector<int> &_xs)
: xs(_xs), mod(n), init(_init) {
off = 1;
while (off < ((int)(xs).size())) off <<= 1;
tr = vector<int>(2 * off, init);
xoff = 0;
}
void addToX(int diff) {
diff %= mod;
if (diff < 0) diff += mod;
xoff += diff;
if (xoff >= mod) xoff -= mod;
}
void relax(int x, int v) {
x = (x + mod - xoff) % mod;
assert(binary_search(xs.begin(), xs.end(), x));
x = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
for (x += off; x >= 1; x >>= 1) tr[x] = min(tr[x], v);
}
int get(int l, int r) {
l = (l + mod - xoff) % mod;
r = (r + mod - xoff) % mod;
if (l <= r)
return _get(l, r);
else
return min(_get(l, mod - 1), _get(0, r));
}
};
int main() {
int n, g, r;
while (scanf("%d%d%d", &n, &g, &r) >= 1) {
int l0;
vector<int> ls(n);
scanf("%d", &l0);
for (int i = 0; i < n; i++) scanf("%d", &ls[i]);
int mod = g + r;
vector<long long> saz(n + 1);
saz[n] = 0;
vector<long long> poses(n + 1);
for (int i = 0; i < n; i++) poses[i + 1] = poses[i] + ls[i];
vector<int> xs;
{
int csum = 0;
for (int i = n - 1;; i--) {
xs.push_back(csum);
if (i < 0) break;
csum -= ls[i];
csum %= mod;
if (csum < 0) csum += mod;
}
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
}
segm_tree tr(mod, n, xs);
tr.relax(0, n);
for (int i = n - 1; i >= 0; i--) {
tr.addToX(ls[i]);
int ne = tr.get(g, g + r - 1);
long long timTo = poses[ne] - poses[i];
if (ne != n) {
assert(timTo % mod >= g);
timTo += mod - timTo % mod;
}
saz[i] = timTo + saz[ne];
tr.relax(0, i);
}
int q;
scanf("%d", &q);
while (q-- > 0) {
long long t;
scanf("%I64d", &t);
t += l0;
tr.addToX(t);
int ne = tr.get(g, g + r - 1);
long long timTo = t + poses[ne];
if (ne != n) {
assert(timTo % mod >= g);
timTo += mod - timTo % mod;
}
printf("%I64d\n", timTo + saz[ne]);
tr.addToX(-t);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int16_t min(int16_t x, int16_t y) {
if (x >= y)
return y;
else
return x;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int16_t n;
cin >> n;
vector<int16_t> v;
int16_t a[n];
for (int16_t i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1) v.push_back(i);
}
if (v.size() == 0) {
for (int16_t i = 0; i <= n * (n - 1) / 2; ++i) cout << 0 << ' ';
return 0;
}
int16_t dp[n + 1][n * (n + 1) / 6 + 10][v.size() + 1];
for (int16_t i = 0; i <= n; ++i)
for (int16_t j = 0; j <= n * (n + 1) / 6 + 9; ++j)
for (int16_t l1 = 0; l1 <= v.size(); ++l1) dp[i][j][l1] = 5000;
for (int16_t i = 1; i <= n; ++i) {
for (int16_t j = 0; j <= n * (n + 1) / 6 + 9; ++j) {
for (int16_t k = 0; k <= v.size(); ++k) {
if (k == 1) {
if (j >= abs(i - 1 - v[0]))
dp[i][j][k] = ((i - 1) * (i - 2)) / 2;
else {
}
continue;
}
for (int16_t t = 0; t < i; ++t) {
if (j >= abs(i - 1 - v[k - 1]))
dp[i][j][k] =
min(dp[i][j][k], dp[t][j - abs(i - 1 - v[k - 1])][k - 1] +
(i - t - 1) * (i - t - 2) / 2);
}
}
}
}
for (int16_t j = 0; j <= n * (n - 1) / 2; ++j) {
int16_t i = min(j, n * (n + 1) / 6 + 9);
int16_t ans1 = 5000;
for (int16_t l1 = 0; l1 <= n; ++l1) {
ans1 = min(ans1, dp[l1][i][v.size()] + ((n - l1) * (n - l1 - 1)) / 2);
}
cout << (int16_t)((n - v.size()) * (n - v.size() - 1)) / 2 - ans1 << ' ';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool gde[200100];
vector<int> v[200100];
int n, m, k, ss, tt;
int r[200100], inf = 200000000;
vector<int> pusk, bfs;
int b[200100];
bool check(int q) {
for (int i = 1; i <= n; i++) {
r[i] = inf;
b[i] = 0;
}
pusk.clear();
pusk.push_back(ss);
b[ss] = 5;
r[ss] = 0;
bool ans = 1;
int w = 0, to;
bfs = pusk;
int sl = 0;
while (pusk.size() > 0) {
sl++;
if (b[tt] > 0 || b[tt] == -1) {
break;
}
w = 0;
bfs = pusk;
for (int i = 0; i < bfs.size(); i++) {
r[bfs[i]] = 0;
b[bfs[i]] = -1;
}
pusk.clear();
while (w < bfs.size()) {
int e = bfs[w];
w++;
if (r[e] == q) break;
for (int i = 0; i < v[e].size(); i++) {
to = v[e][i];
if (b[to] < sl && b[to] != -1) {
bfs.push_back(to);
r[to] = min(r[e] + 1, r[to]);
b[to] = sl;
if (gde[to] == 1) {
b[to] = -1;
pusk.push_back(to);
}
}
}
}
}
if (b[tt] == 0) ans = 0;
return ans;
}
int bin(int st, int fin) {
if (st == fin) return st;
int med = (st + fin) / 2;
if (check(med))
return bin(st, med);
else
return bin(med + 1, fin);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
gde[x] = 1;
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cin >> ss >> tt;
int ll = bin(0, m + 10);
if (ll == m + 10)
cout << "-1\n";
else
cout << ll << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 7;
const int M = 1e6 + 7;
int read() {
char c;
int x = 0, f = 1;
while (!isdigit(c = getchar())) f -= 2 * (c == '-');
while (isdigit(c)) {
x = x * 10 + f * (c - 48);
c = getchar();
}
return x;
}
struct Q {
int x, y, i;
Q(int x = 0, int y = 0, int i = 0) : x(x), y(y), i(i) {}
};
bitset<N> b[N][N];
char s[N][N];
vector<Q> v[N][N];
int n, m, q, sx, sy, tx, ty, res[M];
int main() {
clock_t t1 = clock();
n = read();
m = read();
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
q = read();
for (int i = 1; i <= q; ++i) {
sx = read();
sy = read();
tx = read();
ty = read();
v[sx][sy].push_back(Q(tx, ty, i));
}
for (int i = n; i; --i)
for (int j = m; j; --j) {
if (s[i][j] == '#') {
for (int k = i; k <= n; ++k) b[j][k].reset();
} else {
b[j][i][j] = 1;
if (j < m && s[i][j + 1] == '.') {
for (int k = i; k <= n; ++k) b[j][k] |= b[j + 1][k];
}
for (auto x : v[i][j]) res[x.i] = b[j][x.x][x.y];
}
}
for (int i = 1; i <= q; ++i) {
if (res[i])
puts("Yes");
else
puts("No");
}
fprintf(stderr, "%0.3lfs", 1.0 * (clock() - t1) / CLOCKS_PER_SEC);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int tt = 0;
cin >> tt;
while (tt--) {
long long int n;
cin >> n;
long long int ans = 1;
for (int i = 1; i <= 2 * n; i++) {
if (i != 2) {
ans = (ans * i) % 1000000007;
}
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[100010];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int wh = 0;
long long sumi = 0;
for (int i = 0; i < 2 * n; i++) {
string s;
cin >> s;
A[i] = stoll(s.substr(s.length() - 3, 3));
if (!A[i]) wh++;
sumi += A[i];
}
long long cur = abs(1000 * n - sumi);
for (int i = 0; i <= min(wh, n); i++)
cur = min(cur, abs(n * 1000 - sumi - 1000 * i));
int x = cur % 1000;
cout << cur / 1000 << "." << x / 100 << (x % 100) / 10 << (x % 100) % 10
<< '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min1(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs1(a - b) < eps) return 0;
if (a < b) return -1;
return 1;
}
template <class t>
inline int find(int val, t *a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 1) return 0;
int be = 0, en = na - 1;
if (a[0] <= a[na - 1]) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(a[mid], val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(a[mid], val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && a[be] > val && be != 0) be--;
if (!f_small && a[be] < val && be != na - 1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(a[mid], val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(a[mid], val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && a[be] < val && be != 0) be--;
if (f_small && a[be] > val && be != na - 1) be++;
}
return be;
}
inline int bitnum(unsigned long long nValue) {
nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
(0x5555555555555555ull & nValue);
nValue = ((0xccccccccccccccccull & nValue) >> 2) +
(0x3333333333333333ull & nValue);
nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
(0x0f0f0f0f0f0f0f0full & nValue);
nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
(0x00ff00ff00ff00ffull & nValue);
nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
(0x0000ffff0000ffffull & nValue);
nValue = ((0xffffffff00000000ull & nValue) >> 32) +
(0x00000000ffffffffull & nValue);
return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 200100;
template <class t>
struct segment_node {
int be, en;
t maxv, sum;
};
template <class t>
struct segment_tree {
int l;
segment_node<t> tree[maxn * 4 + 100];
inline int gleft(int no) { return no << 1; }
inline int gright(int no) { return (no << 1) + 1; }
inline int gfa(int no) { return no >> 1; }
inline segment_tree() { l = 0; }
void build(int no, int l, int r, t orig = 0, t *a = NULL) {
if (l == r) {
tree[no].be = tree[no].en = l;
if (a == NULL)
tree[no].maxv = orig;
else
tree[no].maxv = a[l];
tree[no].sum = tree[no].maxv;
return;
}
tree[no].be = l;
tree[no].en = r;
int mid = (l + r) / 2;
build(gleft(no), l, mid, orig, a);
build(gright(no), mid + 1, r, orig, a);
tree[no].sum = tree[gleft(no)].sum + tree[gright(no)].sum;
tree[no].maxv = max1(tree[gleft(no)].maxv, tree[gright(no)].maxv);
}
void down(int l, int r, int no, t ranadd, int f) {
if (l <= tree[no].be && r >= tree[no].en) {
if (f > 0) {
tree[no].sum += 1;
tree[no].maxv = ranadd;
} else if (f < 0) {
tree[no].sum -= 1;
tree[no].maxv = 0;
} else
tree[no].maxv = max1(ranadd, tree[no].maxv);
return;
}
int mid = (tree[no].be + tree[no].en) / 2;
if (r >= tree[no].be && l <= mid) down(l, r, gleft(no), ranadd, f);
if (r >= mid + 1 && l <= tree[no].en) down(l, r, gright(no), ranadd, f);
tree[no].sum = tree[gleft(no)].sum + tree[gright(no)].sum;
tree[no].maxv = max1(tree[gleft(no)].maxv, tree[gright(no)].maxv);
}
t getmax(int l, int r, int no1) {
if (l > r) return 0;
if (l <= tree[no1].be && r >= tree[no1].en) return tree[no1].maxv;
t ans = 0;
int mid = (tree[no1].be + tree[no1].en) / 2;
if (r >= tree[no1].be && l <= mid)
ans = max1(getmax(max1(l, tree[no1].be), min1(r, mid), gleft(no1)), ans);
if (r >= mid + 1 && l <= tree[no1].en)
ans = max1(getmax(max1(l, mid + 1), min1(r, tree[no1].en), gright(no1)),
ans);
return ans;
}
int getrank(int rank, int no) {
if (rank > tree[no].sum) return -1;
if (tree[no].be == tree[no].en) return tree[no].be;
if (rank <= tree[gleft(no)].sum) return getrank(rank, gleft(no));
return getrank(rank - (tree[gleft(no)].sum), gright(no));
}
};
segment_tree<int> sgt, sgth;
int h[maxn], no[maxn];
bool ff[maxn];
int arr[maxn][12];
int n, nq;
int dp[12];
int main() {
scanf("%d%d", &n, &nq);
sgt.build(1, 0, n);
sgth.build(1, 0, maxn + 11);
memset(no, -1, sizeof(no));
for (int i = 0; i < nq; i++) {
int cate;
scanf("%d", &cate);
if (cate == 1) {
int hh, no1;
scanf("%d%d", &no1, &hh);
no1--;
h[no1] = hh - i;
no[i] = no1;
memset(arr[no1], -1, sizeof(arr[no1]));
for (int j = max1(i - 9, 0); j < i; j++)
if (!ff[no[j]]) arr[no1][j - i + 9] = no[j];
arr[no1][9] = n;
arr[no1][10] = no1;
sort(arr[no1], arr[no1] + 11);
int mid = 0;
while (mid < 10 && arr[no1][mid] <= no1) mid++;
int rans = 0;
for (int j = mid; j <= 10; j++) {
rans = max1(sgt.getmax(arr[no1][j - 1] + 1, arr[no1][j] - 1, 1), rans);
if (arr[no1][j] != n && h[arr[no1][j]] > h[no1])
rans = max1(sgt.getmax(arr[no1][j], arr[no1][j], 1), rans);
}
rans++;
sgt.down(no1, no1, 1, rans, 1);
sgth.down(h[no1] + maxn, h[no1] + maxn, 1, rans, 1);
memset(dp, 0, sizeof(dp));
dp[mid - 1] = rans;
for (int j = mid - 2; j >= 0; j--) {
if (arr[no1][j] == -1) break;
for (int k = j + 1; k < mid; k++)
if (h[arr[no1][j]] < h[arr[no1][k]]) dp[j] = max1(dp[k] + 1, dp[j]);
}
for (int j = 0; j < mid - 1; j++) {
if (arr[no1][j] == -1) continue;
sgt.down(arr[no1][j], arr[no1][j], 1, dp[j], 0);
sgth.down(h[arr[no1][j]] + maxn, h[arr[no1][j]] + maxn, 1, dp[j], 0);
}
} else {
int no1;
scanf("%d", &no1);
int ranno[10];
for (int j = 1; j <= no1; j++) {
ranno[j] = sgt.getrank(1, 1);
sgt.down(ranno[j], ranno[j], 1, 0, -1);
sgth.down(h[ranno[j]] + maxn, h[ranno[j]] + maxn, 1, 0, -1);
}
for (int j = no1 - 1; j >= 1; j--) {
int rans = sgth.getmax(h[ranno[j]] + 1 + maxn, maxn + 10, 1);
sgth.down(h[ranno[j]] + maxn, h[ranno[j]] + maxn, 1, rans + 1, 1);
sgt.down(ranno[j], ranno[j], 1, rans + 1, 1);
}
ff[ranno[no1]] = 1;
}
printf("%d\n", sgt.getmax(0, n, 1));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int t;
long long n;
using namespace std;
int main() {
cin >> t;
while (t--) {
cin >> n;
if (n % 3 == 0)
cout << n / 3 << ' ' << n / 3 << endl;
else if (n % 3 == 1)
cout << n / 3 + 1 << ' ' << n / 3 << endl;
else
cout << n / 3 << ' ' << n / 3 + 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
char a[100];
int temp, len, i, j;
gets(a);
len = strlen(a);
for (i = 0; i < len; i += 2) {
for (j = i + 2; j < len; j += 2) {
if (a[i] >= a[j]) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
printf("%s", a);
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long inf = 1e17 + 10;
vector<long long> adj[N];
vector<long long> dist1(N, inf);
vector<long long> dist2(N, inf);
long long arr[N];
vector<long long> ans(N, -1);
long long n;
void bfs1(vector<long long> &src) {
queue<long long> q;
long long sz = src.size();
vector<long long> vis(n + 1, 0);
for (long long x : src) q.push(x), vis[x] = 1, dist1[x] = 0;
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long v : adj[u]) {
if (vis[v]) continue;
dist1[v] = dist1[u] + 1;
vis[v] = 1;
q.push(v);
}
}
for (long long i = 1; i <= n; i++)
if (arr[i] == 0 && vis[i]) ans[i] = dist1[i];
}
void bfs2(vector<long long> &src) {
queue<long long> q;
long long sz = src.size();
vector<long long> vis(n + 1, 0);
for (long long x : src) q.push(x), vis[x] = 1, dist2[x] = 0;
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long v : adj[u]) {
if (vis[v]) continue;
dist2[v] = dist2[u] + 1;
vis[v] = 1;
q.push(v);
}
}
for (long long i = 1; i <= n; i++)
if (arr[i] == 1 && vis[i]) ans[i] = dist2[i];
}
int32_t main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> arr[i];
for (long long i = 1; i <= n; i++) {
if (i - arr[i] >= 1) {
adj[i - arr[i]].push_back(i);
}
if (i + arr[i] <= n) {
adj[i + arr[i]].push_back(i);
}
}
vector<long long> odd, even;
for (long long i = 1; i <= n; i++) {
arr[i] = (arr[i] & 1);
if (arr[i]) {
odd.push_back(i);
} else
even.push_back(i);
}
bfs1(odd);
bfs2(even);
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long int fast_input(void) {
char t;
long long int x = 0;
long long int neg = 0;
t = getchar();
while ((t < 48 || t > 57) && t != '-') t = getchar();
if (t == '-') {
neg = 1;
t = getchar();
}
while (t >= 48 && t <= 57) {
x = (x << 3) + (x << 1) + t - 48;
t = getchar();
}
if (neg) x = -x;
return x;
}
inline void fast_output(long long int x) {
char a[20];
long long int i = 0, j;
a[0] = '0';
if (x < 0) {
putchar('-');
x = -x;
}
if (x == 0) putchar('0');
while (x) {
a[i++] = x % 10 + 48;
x /= 10;
}
for (j = i - 1; j >= 0; j--) {
putchar(a[j]);
}
putchar('\n');
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b % 2) ans = ans * a;
b /= 2;
a *= a;
if (a > 1000000007) a %= 1000000007;
if (ans > 1000000007) ans %= 1000000007;
}
return ans;
}
long long int k, c[1001], i, ans, fac[1000005], invfac[1000005], sum, bot;
int main() {
k = fast_input();
fac[0] = 1, invfac[0] = 1;
sum = 0;
for (i = 0; i < k; i++) {
c[i] = fast_input();
sum += c[i];
}
for (i = 1; i <= sum; i++) {
fac[i] = fac[i - 1] * i;
if (fac[i] > 1000000007) fac[i] %= 1000000007;
invfac[i] = invfac[i - 1] * power(i, 1000000007 - 2);
if (invfac[i] > 1000000007) invfac[i] %= 1000000007;
}
ans = fac[sum];
ans *= invfac[c[0]];
ans %= 1000000007;
bot = c[0];
for (i = 1; i < k; i++) {
ans = ans * invfac[c[i]];
if (ans > 1000000007) ans %= 1000000007;
bot += c[i];
ans *= c[i];
if (ans > 1000000007) ans %= 1000000007;
ans = ans * invfac[bot];
if (ans > 1000000007) ans %= 1000000007;
ans = ans * fac[bot - 1];
if (ans > 1000000007) ans %= 1000000007;
}
fast_output(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
long long x[105], y[105];
long long ans;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
for (long long i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
}
for (long long i = 1; i <= n; ++i) {
swap(x[i], y[i]);
for (long long j = 1; j <= n; ++j) {
if (i == j) continue;
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
}
swap(x[i], y[i]);
for (long long j = 1; j <= n; ++j) {
if (i == j) continue;
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
swap(x[j], y[j]);
if (max(x[i], x[j]) <= a && y[i] + y[j] <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
if (x[i] + x[j] <= a && max(y[i], y[j]) <= b) {
ans = max(ans, x[i] * y[i] + x[j] * y[j]);
}
}
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long skipped = 0;
string a;
cin >> a;
reverse(a.begin(), a.end());
for (int i = a.size() - 1; i >= 0; i--) {
if (i > 0) skipped += 2 * pow(2, i - 1);
if (a[i] == '7') skipped += pow(2, i);
}
cout << skipped + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> ar(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]);
vector<int> visited(n + 1, 0);
vector<vector<int> > chains;
int flag = -1;
for (int i = 1; i <= n; i++) {
if (ar[i] == i) {
flag = i;
break;
}
}
if (flag != -1) {
printf("YES\n");
for (int i = 1; i <= n; i++) {
if (i == flag) continue;
printf("%d %d\n", flag, i);
}
return 0;
}
bool found = false;
int pos2 = -1;
for (int i = 1; i <= n; i++) {
if (visited[i] == 0) {
vector<int> vec;
int x = i;
do {
vec.push_back(ar[x]);
visited[x] = 1;
x = ar[x];
} while (visited[x] == 0);
if (vec.size() % 2 == 1) {
cout << "NO";
return 0;
}
if (found == false && vec.size() == 2) {
pos2 = i;
}
if (vec.size() > 2 || found == true) chains.push_back(vec);
if (pos2 != -1) found = true;
}
}
if (pos2 == -1) {
cout << "NO";
return 0;
}
printf("YES\n");
int dp[2];
dp[0] = pos2;
dp[1] = ar[pos2];
for (int i = 0; i < chains.size(); i++) {
int z = 0;
for (int j = 0; j < chains[i].size(); j++) {
z = z ^ 1;
printf("%d %d\n", dp[z], chains[i][j]);
}
}
printf("%d %d\n", dp[0], dp[1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int main() {
int t;
cin >> t;
while (t--) {
cin >> a >> b;
long long now = 0, ti = 0;
while (now <= b) now = now * 10 + 9, ti++;
printf("%lld\n", a * ti - a);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<pair<long long, long long> > ans;
set<long long> h;
long long prime[100005];
void sieve() {
for (long long i = 0; i <= 100000; i++) prime[i] = 1;
prime[0] = 0;
prime[1] = 0;
for (long long i = 2; i <= 100000; i++) {
if (prime[i] == 0) continue;
for (long long j = i + i; j <= 100000; j += i) prime[j] = 0;
}
}
bool nei(long long x, long long y) {
if (x > y) swap(x, y);
long long yy = abs(x - y);
if (yy <= 1) return true;
if (x == 1 && y == n) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sieve();
cin >> n;
for (long long i = 1; i < n; i++) ans.push_back(make_pair(i, i + 1));
ans.push_back(make_pair(n, 1));
for (long long i = 1; i <= n; i++) h.insert(i);
long long ed = n;
while (prime[ed] == 0) {
long long t = *h.begin();
for (long long j = 1; j <= n; j++) {
if (!nei(t, j) && (h.find(j) != h.end())) {
ans.push_back(make_pair(t, j));
ed++;
h.erase(h.find(j));
h.erase(h.find(t));
break;
}
}
}
cout << ans.size() << "\n";
for (auto &i : ans) cout << i.first << " " << i.second << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
set<pair<int, int>, greater<pair<int, int> > > s;
int n;
int arr[21][21] = {};
bool fill(int i, int j) {
auto it = s.begin();
int count = it->first;
int elem = it->second;
if (count < 4) {
return false;
}
s.erase(it);
count -= 4;
if (count) {
s.insert({count, elem});
}
arr[i][j] = elem;
arr[n - i + 1][j] = elem;
arr[n - i + 1][n - j + 1] = elem;
arr[i][n - j + 1] = elem;
return true;
}
int main() {
cin >> n;
int temp;
for (int i = 0; i < n * n; i++) {
cin >> temp;
m[temp]++;
}
for (auto &it : m) {
s.insert({it.second, it.first});
}
bool flag = true;
for (int i = 1; i <= n / 2; i++) {
for (int j = 1; j <= n / 2; j++) {
if (!fill(i, j)) {
flag = false;
cout << "NO\n";
return 0;
}
}
}
if (flag && (n & 1)) {
int mid = (n + 1) / 2;
auto it = s.begin();
int elem, count;
for (int i = 1; i <= n / 2; i++) {
it = s.begin();
elem = it->second;
count = it->first;
if (count < 2) {
flag = false;
cout << "NO\n";
return 0;
}
count -= 2;
s.erase(it);
if (count) {
s.insert({count, elem});
}
arr[i][mid] = elem;
arr[n - i + 1][mid] = elem;
}
for (int i = 1; i <= n / 2; i++) {
it = s.begin();
elem = it->second;
count = it->first;
if (count < 2) {
flag = false;
cout << "NO\n";
return 0;
}
count -= 2;
s.erase(it);
if (count) {
s.insert({count, elem});
}
arr[mid][i] = elem;
arr[mid][n - i + 1] = elem;
}
it = s.begin();
arr[mid][mid] = it->second;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << arr[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> ke[1000010];
bool cx[1000010], visited[1000010];
void dfs(int u) {
visited[u] = true;
for (int v : ke[u])
if (!visited[v]) dfs(v);
}
long long c2(int x) { return (1LL * x * (x - 1)) >> 1; }
int main() {
if (fopen("a.txt", "r")) {
freopen("a.txt", "r", stdin);
} else
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int own = 0;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
cx[u] = true;
cx[v] = true;
if (u != v) {
ke[u].push_back(v);
ke[v].push_back(u);
} else
own++;
}
int cnt = 0;
for (int u = 1; u <= n; u++)
if (cx[u] && !visited[u]) {
dfs(u);
cnt++;
}
if (cnt != 1) {
cout << 0;
exit(0);
};
long long res = 0;
for (int i = 1; i <= n; i++) res += c2(int(ke[i].size()));
res += c2(own);
res += 1LL * own * (m - own);
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
int t, k, i, j, n, m, x, y, q, c;
cin >> n >> k;
if ((n - 1) % k >= 2) {
printf("%d\n", 2 * ((n - 1) / k) + 2);
} else if ((n - 1) % k == 1) {
printf("%d\n", 2 * ((n - 1) / k) + 1);
} else {
printf("%d\n", 2 * ((n - 1) / k));
}
for (i = 0; i < k; i++) a[i] = 1;
for (i = 2; i <= n; i++) {
j = (i - 2) % k;
printf("%d %d\n", i, a[j]);
a[j] = i;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
vector<int> G[200005];
int n, a, b, zzzz;
int maxn[200005];
int minn[200005];
int d[200005];
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
struct node {
int index;
int maxn;
};
struct cmp {
bool operator()(const node& a, const node& b) const {
return a.maxn > b.maxn;
}
};
int main() {
cin >> n;
memset(minn, 0x3f, sizeof(minn));
for (int i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
G[a].push_back(b);
maxn[a] = max(maxn[a], b);
minn[a] = min(minn[a], b);
}
set<node, cmp> s;
for (int i = 1; i <= n; i++) {
if (G[i].size()) {
node tmp;
tmp.index = i;
tmp.maxn = maxn[i];
s.insert(tmp);
}
}
int T, x;
cin >> T;
for (int i = 0; i < T; i++) {
scanf("%d", &x);
for (int j = 0; j < x; j++) {
scanf("%d", &d[j]);
node t;
t.index = d[j];
t.maxn = maxn[d[j]];
s.erase(t);
}
if (s.size() == 0) {
puts("0 0");
} else if (s.size() == 1) {
printf("%d %d\n", s.begin()->index, minn[s.begin()->index]);
} else {
set<node, cmp>::iterator t = s.begin();
node y;
y.index = t->index;
y.maxn = t->maxn;
s.erase(s.begin());
set<node, cmp>::iterator t2 = s.begin();
vector<int>::iterator it;
it = upper_bound(G[t->index].begin(), G[t->index].end(), t2->maxn);
if (it != G[t->index].end()) {
printf("%d %d\n", y.index, *it);
} else {
puts("0 0");
}
s.insert(y);
}
for (int j = 0; j < x; j++) {
node t;
t.index = d[j];
t.maxn = maxn[d[j]];
if (G[t.index].size()) s.insert(t);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
string s;
cin >> s;
long long na = 0, ng = 0, nc = 0, nt = 0, nq = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'A')
na++;
else if (s[i] == 'G')
ng++;
else if (s[i] == 'C')
nc++;
else if (s[i] == 'T')
nt++;
else if (s[i] == '?')
nq++;
}
long long b = n / 4;
if ((b - na) + (b - ng) + (b - nc) + (b - nt) != nq || (n % 4 != 0) ||
(b < na) || (b < nc) || (b < ng) || (b < nt)) {
cout << "==="
<< "\n";
return 0;
}
if ((b - na) + (b - ng) + (b - nc) + (b - nt) == nq) {
for (long long i = 0; i < n; i++) {
if (s[i] == '?') {
if (b > na) {
s.replace(i, 1, "A");
na++;
} else if (b > ng) {
s.replace(i, 1, "G");
ng++;
} else if (b > nc) {
s.replace(i, 1, "C");
nc++;
} else if (b > nt) {
s.replace(i, 1, "T");
nt++;
}
}
}
}
cout << s << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, t;
cin >> n >> t;
vector<int> v;
int temp;
for (int i = 0; i < n; ++i) {
cin >> temp;
v.push_back(temp);
}
int a = 0, b = 0;
int sum = 0;
bool whole = false;
while (true) {
if (b == n) {
whole = true;
break;
}
sum += v[b];
if (sum > t) {
sum -= v[b];
break;
}
b++;
}
if (!whole) {
int cursum = sum;
int max = b - a;
int curnum = max;
for (int i = 1; i < n; ++i) {
cursum -= v[i - 1];
curnum--;
while (true) {
if (b == n) {
break;
}
cursum += v[b];
if (cursum <= t) {
b++;
curnum++;
} else {
cursum -= v[b];
break;
}
}
if (curnum > max) max = curnum;
}
cout << max << '\n';
} else {
cout << n << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, ax, ay, bx, by, cx, cy;
cin >> n;
long long int a[n];
cin >> ax >> ay;
cin >> bx >> by;
cin >> cx >> cy;
if (cx > ax && bx < ax)
cout << "NO" << endl;
else if (cy > ay && by < ay)
cout << "NO" << endl;
else if (cy < ay && by > ay)
cout << "NO" << endl;
else if (cx < ax && bx > ax)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
if (k == 0) {
cout << s;
return 0;
}
if (s.length() == 1) {
if (k > 0) {
cout << "0";
return 0;
}
}
if (s[0] != '1') {
s[0] = '1';
k--;
}
for (long long i = 1; i < n; i++) {
if (k > 0)
if (s[i] != '0') {
s[i] = '0';
k--;
}
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ak[300001];
int f[5000][5000];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> ak[i];
sort(ak + 1, ak + n + 1);
int x = n / k;
int l = n % k;
int s = k - l;
memset(f, 127, sizeof(f));
f[0][0] = 0;
for (int i = 0; i <= l; i++) {
for (int j = 0; j <= s; j++) {
int tmp = i * (x + 1) + j * x;
if (i < l) {
f[i + 1][j] = min(f[i + 1][j], f[i][j] + ak[tmp + x + 1] - ak[tmp + 1]);
}
if (j < s) {
f[i][j + 1] = min(f[i][j + 1], f[i][j] + ak[tmp + x] - ak[tmp + 1]);
}
}
}
cout << f[l][s] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, tt[222222], res[222222];
pair<int, int> a[222222];
void in() {}
int main() {
cin >> n;
int maxfi = -1;
for (int i = 1; i <= n; ++i) {
int u, v;
cin >> u >> v;
a[i] = {v, u};
maxfi = max(maxfi, v);
}
sort(a + 1, a + n + 1);
int dem = 0;
int imax = 0;
tt[0] = 0;
res[0] = 1;
dem = 0;
for (int i = 1; i <= n; ++i) {
while (a[dem + 1].second <= a[i].first) {
++dem;
if (tt[dem] >= tt[imax]) {
if (tt[dem] == tt[imax]) res[dem] = (res[dem] + res[imax]) % 1000000007;
imax = dem;
}
}
int t = tt[imax] + a[i].second - a[i].first;
if (t > tt[i]) {
tt[i] = t;
res[i] = 0;
}
if (t == tt[i]) res[i] = (res[i] + res[imax]) % 1000000007;
}
int mins = INT_MAX, ans(0);
for (int i = 1; i <= n; ++i) {
if (a[i].second > maxfi && mins > a[i].second - tt[i]) {
mins = a[i].second - tt[i];
ans = 0;
}
if (a[i].second - tt[i] == mins && a[i].second > maxfi)
ans = (ans + res[i]) % 1000000007;
}
cout << ans;
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pll> vpll;
typedef vector<vll> vvll;
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
void solve(){
int n;
cin >> n;
ll arr[n];
for(int i=0;i<n;i++)
cin >> arr[i];
ll prev = 0;
for(int j=0;j<n;j++){
arr[j]+=prev;
if(arr[j] < j){
cout<<"NO"<<"\n";
return;
}
else prev=arr[j]-j;
}
cout<<"YES"<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const long long Mod = 1e9 + 7;
template <class T>
T checkMax(T& r, T val) {
if (r < val) r = val;
return r;
}
template <class T>
T checkMin(T& r, T val) {
if (r > val) r = val;
return r;
}
int n, m, K;
long long a[2][2][N][N];
int lowbit(int x) { return x & (-x); }
void add(long long a[N][N], int x, int y, long long val) {
while (x < N) {
int ty = y;
while (ty < N) {
a[x][ty] ^= val;
ty += lowbit(ty);
}
x += lowbit(x);
}
}
long long sum(long long a[N][N], int x, int y) {
long long res = 0;
while (x) {
int ty = y;
while (ty) {
res ^= a[x][ty];
ty -= lowbit(ty);
}
x -= lowbit(x);
}
return res;
}
long long query(int x, int y) { return sum(a[x % 2][y % 2], x, y); }
void update(int x, int y, long long val) { add(a[x % 2][y % 2], x, y, val); }
int main() {
int i, j, k;
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int t, x0, x1, y0, y1;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
--x0, --y0;
long long res =
query(x1, y1) ^ query(x0, y0) ^ query(x0, y1) ^ query(x1, y0);
cout << res << endl;
} else {
long long v;
scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
cin >> v;
++x1, ++y1;
update(x1, y1, v);
update(x1, y0, v);
update(x0, y1, v);
update(x0, y0, v);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000000], sum[1000000], mx[1000000], mxb[1000000];
long long strt[1000000], strtb[1000000];
int main() {
long long n, m, i, j, k, l;
scanf("%I64d", &n);
scanf("%I64d", &k);
for (i = 1; i <= (n); i++) {
scanf("%I64d", &a[i]);
}
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
for (i = 1; i < k; i++) mx[i] = -1000000000000000000;
mx[k] = sum[k];
strt[k] = 1;
for (i = k + 1; i <= n; i++) {
if (mx[i - 1] >= sum[i] - sum[i - k]) {
mx[i] = mx[i - 1];
strt[i] = strt[i - 1];
} else {
mx[i] = sum[i] - sum[i - k];
strt[i] = i - k + 1;
}
}
for (i = n; i > n - k + 1; i--) mxb[i] = -1000000000000000000;
mxb[n - k + 1] = sum[n] - sum[n - k];
strtb[n - k + 1] = n - k + 1;
for (i = n - k; i > 0; i--) {
if (mxb[i + 1] > sum[i + k - 1] - sum[i - 1]) {
mxb[i] = mxb[i + 1];
strtb[i] = strtb[i + 1];
} else {
mxb[i] = sum[i + k - 1] - sum[i - 1];
strtb[i] = i;
}
}
long long ans = 0, a, b;
for (i = k; i <= n - k; i++) {
if (mx[i] + mxb[i + 1] > ans) {
ans = mx[i] + mxb[i + 1];
a = strt[i];
b = strtb[i + 1];
}
}
printf("%I64d\n", a);
printf("%I64d\n", b);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, D = 350;
int n, w, a, b, mx = 0;
long long coe[N];
vector<int> eve[N];
struct line {
int a;
long long b;
line(int _a = 0, long long _b = 0) : a(_a), b(_b) {}
long long at(int x) { return 1LL * a * x + b; }
double intersect(const line &oth) const {
return 1.0 * (b - oth.b) / (oth.a - a);
}
};
struct convex_hull {
vector<line> con;
int opt, pt;
void push(line cur) {
while (con.size() >= 2 && con[con.size() - 2].intersect(cur) <=
con[con.size() - 2].intersect(con.back())) {
con.pop_back();
}
con.push_back(cur);
}
pair<long long, int> get_ans() {
while (pt + 1 < con.size() && con[pt].at(opt) <= con[pt + 1].at(opt)) {
pt++;
}
return {con[pt].at(opt), con[pt].a};
}
void build(int l, int r) {
con.clear();
pt = 0;
for (int i = l; i < r; i++) {
push(line(i, coe[i]));
}
}
} cht[D];
int get_index(int u) { return u / D; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> a >> b;
++b;
mx = max(b, mx);
eve[b].push_back(a);
}
for (int i = 0; i < N; i += D) {
cht[i / D].build(i, min(i + D, N));
}
for (int i = 0; i <= mx; i++) {
for (int &v : eve[i]) {
n--;
int ind = v / D;
for (int j = 0; j < ind; j++) {
cht[j].opt++;
}
for (int j = ind * D; j <= v; j++) {
coe[j] += j;
}
cht[ind].build(ind * D, min((ind + 1) * D, N));
}
pair<long long, int> ans = {-1, 0};
for (int j = 0; j < N; j += D) {
ans = max(ans, cht[j / D].get_ans());
}
cout << ans.first + 1LL * i * n * w << " " << ans.second << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dump_char;
int main() {
int n, x, i;
vector<int> pos, neg;
scanf("%d", &n);
for (i = 0; i < 2 * n - 1; i++) {
scanf("%d", &x);
if (x < 0) {
neg.push_back(x * (-1));
} else {
pos.push_back(x);
}
}
sort(neg.begin(), neg.end());
sort(pos.begin(), pos.end());
while (neg.size() >= n) {
for (i = 0; i < n; i++) {
pos.push_back(neg[neg.size() - 1]);
neg.pop_back();
}
}
sort(pos.begin(), pos.end());
if (n % 2 == 0 && neg.size() % 2) {
x = min(neg[0], pos[0]);
} else {
x = 0;
}
x = x * (-2);
for (i = 0; i < pos.size(); i++) x += pos[i];
for (i = 0; i < neg.size(); i++) x += neg[i];
printf("%d\n", x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int ans = 0, n, m, cnt, dif;
char a[maxn], b[maxn];
int main() {
scanf("%s%s", a + 1, b + 1);
n = strlen(a + 1), m = strlen(b + 1);
for (int i = 1; i <= m; i++)
if (a[i] != b[i]) dif++;
for (int i = 1; i < m; i++)
if (b[i] != b[i + 1]) cnt++;
cnt %= 2;
for (int i = 1; i + m <= n + 1; i++) {
if (dif % 2 == 0) ans++;
if (a[i] != b[1]) dif++;
if (a[i + m] != b[m]) dif++;
(dif += cnt) %= 2;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int s[5005], h[5005];
int main() {
int n, da, ans, i, t, j;
while (cin >> n) {
memset(s, 0, sizeof(s));
for (i = 0; i < n; i++) {
cin >> t;
s[t]++;
}
cin >> t;
memset(h, 0, sizeof(h));
for (i = 1; i <= 1000; i++) {
h[i] = h[i - 1] + s[i];
}
ans = 0;
for (i = 1; i <= 1000; i++) {
if (i - t < 1) {
j = 1;
} else {
j = i - t;
}
for (; j <= i; j++) {
if (j + t > 1000) {
da = h[1000] - h[j - 1];
} else {
da = h[j + t] - h[j - 1];
}
if (da > ans) {
ans = da;
}
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
mt19937 rng(std::chrono::duration_cast<std::chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
template <typename S, typename T>
void xmin(S &a, T const &b) {
if (b < a) a = b;
}
template <typename S, typename T>
void xmax(S &a, T const &b) {
if (b > a) a = b;
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
signed gen(int T) {
auto get_rand = [&](int64_t l, int64_t r) {
return uniform_int_distribution<int64_t>(l, r)(rng);
};
auto get_double = [&](double l, double r) {
return uniform_real_distribution<double>(l, r)(rng);
};
ofstream o("gen.txt");
o << T << "\n";
for (int cas = 0; cas < T; ++cas) {
o << "\n";
}
o << endl;
o.close();
return 0;
}
long long push_count = 0;
long long arc_scans = 0;
template <typename flow_t = long long>
struct PushRelabel {
struct Edge {
int to, rev;
flow_t f, c;
};
vector<vector<Edge>> g;
vector<flow_t> ec;
vector<Edge *> cur;
vector<vector<int>> hs;
vector<int> H;
PushRelabel(int n) : g(n), ec(n), cur(n), hs(2 * n), H(n) {}
int add_edge(int s, int t, flow_t cap, flow_t rcap = 0) {
if (s == t) return -1;
Edge a = {t, (int)g[t].size(), 0, cap};
Edge b = {s, (int)g[s].size(), 0, rcap};
g[s].push_back(a);
g[t].push_back(b);
return b.rev;
}
void add_flow(Edge &e, flow_t f) {
++push_count;
Edge &back = g[e.to][e.rev];
if (!ec[e.to] && f) hs[H[e.to]].push_back(e.to);
e.f += f;
e.c -= f;
ec[e.to] += f;
back.f -= f;
back.c += f;
ec[back.to] -= f;
}
flow_t max_flow(int s, int t) {
push_count = arc_scans = 0;
int v = g.size();
H[s] = v;
ec[t] = 1;
vector<int> co(2 * v);
co[0] = v - 1;
for (int i = 0; i < v; ++i) cur[i] = g[i].data();
for (auto &e : g[s]) add_flow(e, e.c);
if (hs[0].size())
for (int hi = 0; hi < 2 * v;) {
int u = hs[hi].back();
hs[hi].pop_back();
while (ec[u] > 0)
if (cur[u] == g[u].data() + g[u].size()) {
int hii = H[u];
H[u] = 1e9;
for (auto &e : g[u])
if (e.c && H[u] > H[e.to] + 1) H[u] = H[e.to] + 1, cur[u] = &e;
if (++co[H[u]], !--co[hii] && hii < v)
for (int i = 0; i < v; ++i)
if (hii < H[i] && H[i] < v) {
--co[H[i]];
H[i] = v + 1;
}
} else if (cur[u]->c && H[u] == H[cur[u]->to] + 1)
add_flow(*cur[u], min(ec[u], cur[u]->c));
else
++cur[u];
if (hi) --hi;
while (hi < 2 * v && hs[hi].empty()) ++hi;
}
return -ec[s];
}
};
const int N = 20000;
vector<bool> sieve(N + 1, true);
void init() {
for (long long i = (2); i <= (N); ++i) {
if (sieve[i]) {
for (int j = i * i; j <= N; j += i) {
sieve[j] = false;
}
}
}
}
vector<vector<int>> graph;
vector<bool> vis;
vector<int> path;
void dfs(int u) {
vis[u] = true;
path.push_back(u);
for (int v : graph[u]) {
if (not vis[v]) {
dfs(v);
}
}
}
signed main() {
init();
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> A(n);
for (int &x : A) {
cin >> x;
}
vector<int> even, odd;
for (long long i = (0); i <= (n - 1); ++i) {
if ((((A[i]) & 1) == 0 ? (0) : (1))) {
odd.push_back(i);
} else {
even.push_back(i);
}
}
int source = n, sink = n + 1, N = n + 2;
PushRelabel<long long> pr(N);
for (int x : even) {
pr.add_edge(source, x, 2);
}
for (int x : odd) {
pr.add_edge(x, sink, 2);
}
for (int x : even) {
for (int y : odd) {
if (sieve[A[x] + A[y]]) {
pr.add_edge(x, y, 1);
}
}
}
int flow = pr.max_flow(source, sink);
if (flow != n) {
cout << "Impossible\n";
} else {
graph.assign(n, {});
for (int x : even) {
for (auto &ed : pr.g[x]) {
int y = ed.to;
if (y != source and ed.f) {
graph[x].push_back(y);
graph[y].push_back(x);
}
}
}
vis.assign(n, false);
vector<vector<int>> tables;
for (long long i = (0); i <= (n - 1); ++i) {
if (not vis[i]) {
path.clear();
dfs(i);
tables.push_back(path);
}
}
cout << ((long long)(tables).size()) << "\n";
for (auto &table : tables) {
cout << ((long long)(table).size());
for (int x : table) {
cout << ' ' << x + 1;
}
cout << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxn = 510;
long long fac[maxn];
long long dp[maxn][maxn];
long long c[maxn][maxn];
long long a[maxn], cnt[maxn];
bool vis[maxn];
long long n, sz;
bool perfect_square(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x) {
now = mid;
l = mid + 1;
} else
r = mid - 1;
}
return now * now == x;
}
void get_comb() {
c[0][0] = 1;
fac[0] = 1;
for (long long i = 1; i <= 300; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
for (long long i = 1; i <= 300; i++) fac[i] = (fac[i - 1] * i) % mod;
}
void slove() {
dp[0][cnt[0] - 1] = 1;
long long lim = cnt[0];
for (long long i = 1; i < sz; i++) {
for (long long j = 0; j < lim; j++) {
for (long long k = 0; k < cnt[i]; k++) {
for (long long m = 0; m <= min(j, k + 1); m++) {
long long ways = c[cnt[i] - 1][k] % mod * c[j][m] % mod *
c[lim - 1 - j + 2][k + 1 - m] % mod;
dp[i][j + cnt[i] - 1 - k - m] =
(dp[i][j + cnt[i] - 1 - k - m] + dp[i - 1][j] * ways % mod) % mod;
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (long long i = 0; i < sz; i++) {
ans *= fac[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (long long i = 0; i < n; i++) {
if (vis[i] == 0) {
for (long long j = i; j < n; j++) {
if (perfect_square(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
get_comb();
slove();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int findUp(const std::vector<std::vector<char>>& v) {
for (int i = 0; i < v.size(); i++)
for (int j = 0; j < v[i].size(); j++)
if (v[i][j] == 'B') return i;
return -1;
}
inline int findDown(const std::vector<std::vector<char>>& v) {
for (int i = v.size() - 1; i >= 0; i--)
for (int j = 0; j < v[i].size(); j++)
if (v[i][j] == 'B') return i;
}
inline int findLeft(const std::vector<std::vector<char>>& v) {
for (int i = 0; i < v[0].size(); i++)
for (int j = 0; j < v.size(); j++)
if (v[j][i] == 'B') return i;
}
inline int findRight(const std::vector<std::vector<char>>& v) {
for (int i = v[0].size() - 1; i >= 0; i--)
for (int j = 0; j < v.size(); j++)
if (v[j][i] == 'B') return i;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
std::cin >> n >> m;
std::vector<std::vector<char>> sheet(n);
for (int i = 0; i < n; i++) sheet[i].resize(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) std::cin >> sheet[i][j];
int up = findUp(sheet), down = findDown(sheet), right = findRight(sheet),
left = findLeft(sheet);
int len = max(1 + abs(up - down), 1 + abs(right - left));
int ans, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (sheet[i][j] == 'B') cnt++;
}
if (cnt) {
if (len > n || len > m)
ans = -1;
else
ans = len * len - cnt;
} else
ans = 1;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long d, x, y;
void extendedEuclid(long long A, long long B) {
if (B == 0) {
d = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
long long temp = x;
x = y;
y = temp - (A / B) * y;
}
}
long long modInverse(long long A) {
extendedEuclid(A, 1000000007);
return (x % 1000000007 + 1000000007) % 1000000007;
}
long long modularExponentiation(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return result;
}
int main() {
long long n;
cin >> n;
long long temp = modularExponentiation(2, n);
temp = ((temp) % 1000000007 * (temp + 1) % 1000000007) % 1000000007;
long long ans =
((temp) % 1000000007 * (modInverse(2)) % 1000000007) % 1000000007;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[100000];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
cout << min(a[n - 1] - a[1], a[n - 2] - a[0]) << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
a.push_back(v);
}
if (n == 1) {
if (a[0] % 2 == 0) {
cout << 0 << endl;
continue;
} else {
cout << -1 << endl;
continue;
}
}
int o_num = 0, e_num = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0)
e_num += 1;
else
o_num += 1;
}
if (o_num > e_num) {
cout << -1 << endl;
continue;
}
if (e_num == o_num || n / 2 == o_num) {
int i = 0, j = 1, s = 0;
while (i < n || j < n) {
if (a[i] % 2 != 0) {
if (a[j] % 2 == 0) {
swap(a[i], a[j]);
s++;
i += 2;
j += 2;
} else {
j += 2;
}
} else {
i += 2;
}
}
cout << s << endl;
continue;
} else {
cout << -1 << endl;
continue;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3;
int a[MAX], b[MAX], c[MAX];
int main() {
int p = 0, n = 0, s = 0;
for (int i = 0; i < MAX; i++) cin >> a[i], s += a[i];
for (int i = 0; i < MAX; i++) {
cin >> b[i];
if (a[i] - b[i] < 0)
n -= (a[i] - b[i]);
else
p += ((a[i] - b[i]) / 2);
}
if (p >= n) return (cout << "YES", 0);
return (cout << "NO", 0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const long long mod = 1e9 + 7;
int t, n, m, l, r;
double a[maxn], s, tl, tr, sl, sr, pl, pr;
int main() {
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
l = 1;
r = n;
pl = 0;
pr = m;
s = 0;
sl = sr = 1;
while (l <= r + 1) {
if (l == r + 1) {
s += (pr - pl) / (sl + sr);
break;
}
tl = (a[l] - pl) / sl;
tr = (pr - a[r]) / sr;
if (tl < tr) {
s += tl;
pl = a[l];
l++;
sl++;
pr -= tl * sr;
if (fabs(pr - a[r]) < 1e-8) {
pr = a[r];
r--;
sr++;
}
} else {
s += tr;
pr = a[r];
r--;
sr++;
pl += tr * sl;
if (fabs(a[l] - pl) < 1e-8) {
pl = a[l];
l++;
sl++;
}
}
}
printf("%.8lf\n", s);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double a, b, c;
};
double max(double a, double b) { return a < b ? b : a; }
double min(double a, double b) { return a > b ? b : a; }
node tm[5005];
double one_2[5005];
const double inf = 2147483647.0;
int main() {
double a, b, c;
int n;
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%lf%lf%lf", &tm[i].a, &tm[i].b, &tm[i].c);
}
double a1 = tm[1].a;
double b1 = tm[1].b;
double c1 = tm[1].c;
double dis_pow2;
for (j = 2; j <= n; j++) {
double a2 = tm[j].a;
double b2 = tm[j].b;
double c2 = tm[j].c;
dis_pow2 = sqrt((a1 - a2) * (a1 - a2) + (b1 - b2) * (b1 - b2) +
(c1 - c2) * (c1 - c2));
one_2[j] = dis_pow2;
}
double ans = inf;
int id;
double dis2;
for (id = 2; id <= n; id++) {
double dis1 = one_2[id];
a1 = tm[id].a;
b1 = tm[id].b;
c1 = tm[id].c;
for (j = 2; j <= n; j++) {
if (j == id) continue;
double a2 = tm[j].a;
double b2 = tm[j].b;
double c2 = tm[j].c;
dis2 = sqrt((a1 - a2) * (a1 - a2) + (b1 - b2) * (b1 - b2) +
(c1 - c2) * (c1 - c2));
double cha = fabs(dis1 - one_2[j]);
ans = min(ans, dis1 + (cha + dis2) / 2);
}
}
printf("%.7lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<char> v;
for (int i = 0; i < s.size(); i++) {
v.push_back((s[i]));
i++;
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (i == v.size() - 1) {
cout << v[i];
continue;
}
cout << v[i] << "+";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, m;
cin >> n >> m;
string s;
vector<string> S;
vector<string> DS;
vector<string> X;
for (int i = 0; i < n; i++) {
cin >> s;
string ds;
S.push_back(s);
for (int p = m - 1; p > -1; p--) ds = ds + s[p];
DS.push_back(ds);
}
string f;
string k;
long long c = 0;
for (int i = 0; i < n; i++) {
for (int p = 0; p < n; p++) {
if (S[i] == DS[p] && p != i) {
DS[i] = "1";
f += S[i];
}
if (c == 0)
if (S[i] == DS[p] && p == i) {
c = 1;
k = S[i];
}
}
}
if (f.size() <= 0 && k.size() <= 0) {
cout << 0;
return 0;
}
cout << f.size() * 2 + k.size() << "\n";
cout << f;
cout << k;
for (int i = f.size() - 1; i >= 0; i--) cout << f[i];
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x;
}
long long n, t, res, mod, cnt;
long long a[2000005];
signed main() {
n = read(), t = read();
for (register long long i = (1); i <= (n); ++i) a[i] = read();
while (t) {
mod = cnt = 0;
for (register long long i = (1); i <= (n); ++i)
if (mod + a[i] <= t) mod += a[i], cnt++;
if (!mod) break;
res += t / mod * cnt;
t %= mod;
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int p[1000007], q[1000007], r[1000007], arr[10000];
int main() {
long long int i, j, k, n, x, y, z, t, ans = 1, ans1 = 1, m = -1, xx;
for (i = 2; i * i <= 1e6; i++) {
if (p[i] == 0) {
for (j = i; j <= 1e6; j += i) {
p[j] = i;
}
}
}
for (i = 2; i <= 1e6; i++) {
if (p[i] == 0) p[i] = i;
}
cin >> t;
for (i = 0; i < t; i++) {
cin >> n;
for (j = 0; j < n; j++) {
cin >> x;
arr[j] = x;
xx = x;
if (x > m) m = x;
while (x > 1) {
y = p[x];
q[y]++;
if (q[y] > r[y]) {
r[y]++;
ans *= y;
}
x /= p[x];
}
while (xx > 1) {
y = p[xx];
q[y] = 0;
xx /= y;
}
}
if (ans == m) {
ans = m * p[m];
r[p[m]]++;
}
for (j = 2; j <= 1e6; j++) {
ans1 *= (r[j] + 1);
}
if ((ans1 - 2) == n)
cout << ans << endl;
else
cout << -1 << endl;
for (k = 0; k <= 1e6; k++) r[k] = 0;
ans = 1;
ans1 = 1;
m = -1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool is(string s, char a, char b) {
for (unsigned int i = 0; i < s.length(); i++) {
if (s[i] != a && s[i] != b) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
string w[n];
for (int i = 0; i < n; i++) {
cin >> w[i];
}
int maxsum = 0;
for (char a = 'a'; a <= 'y'; a++) {
for (char b = a + 1; b <= 'z'; b++) {
int sum = 0;
for (int i = 0; i < n; i++) {
if (is(w[i], a, b)) {
sum += w[i].length();
}
}
if (sum > maxsum) {
maxsum = sum;
}
}
}
cout << maxsum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N], b[N];
int nxt[N], col[N];
void dfs(int u, int c) {
col[u] = c;
col[u ^ 1] = 3 - c;
if (!col[nxt[u]]) dfs(nxt[u], 3 - c);
if (!col[nxt[u ^ 1]]) dfs(nxt[u ^ 1], c);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", a + i, b + i);
a[i]--;
b[i]--;
nxt[a[i]] = b[i];
nxt[b[i]] = a[i];
}
for (int i = 0; i < n + n; i += 2)
if (col[i] == 0) {
dfs(i, 1);
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", col[a[i]], col[b[i]]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, answer;
int X_axe[2010], Y_axe[2010];
bool is_triangle(int x1, int y1, int x2, int y2, int x3, int y3) {
return (((x1 - x3) * (y2 - y3) - (x2 - x3) * (y1 - y3)) != 0);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) scanf("%d%d", &X_axe[i], &Y_axe[i]);
for (int i = 0; i < N; ++i)
for (int j = i + 1; j < N; ++j)
for (int k = j + 1; k < N; ++k)
if (is_triangle(X_axe[i], Y_axe[i], X_axe[j], Y_axe[j], X_axe[k],
Y_axe[k]))
++answer;
printf("%d\n", answer);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
struct edge
{
int a,b,c;
edge(int x,int y,int z){a=x,b=y,c=min(z,1000000);}
};
vector<edge> eg,ans;
int l,r;
int n=32,m;
int main()
{
ios_base::sync_with_stdio(false);
cin>>l>>r;
cout<<"YES"<<endl;
if(l==r)
{
cout<<2<<' '<<1<<endl;
cout<<1<<' '<<2<<' '<<l<<endl;
return 0;
}
for(int i=0;i<=25;i++)
{
for(int j=i+1;j<=25;j++)
{
eg.push_back({i,j,1<<(max(0,i-1))});
}
}
if(l==1)
{
for(auto x:eg)
{
ans.push_back({x.a+1,x.b+1,x.c});
}
int s=1;
ans.push_back({1,n,1});
r--;
for(int c=1;c<=25;c++)
{
if(r&(1<<(c-1)))
ans.push_back({c+1,n,s}),s+=(1<<(c-1));
}
}
else
{
for(auto x:eg)
{
ans.push_back({x.a+2,x.b+2,x.c});
}
int s=1;
ans.push_back({1,2,l-1});
ans.push_back({1,n,l});
r-=l;
for(int c=1;c<=25;c++)
{
if(r&(1<<(c-1)))
ans.push_back({c+2,n,s}),s+=(1<<(c-1));
}
}
cout<<n<<' '<<ans.size()<<endl;
for(auto x:ans)cout<<x.a<<' '<<x.b<<' '<<x.c<<endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long a[200010];
int main() {
long n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long bst = a[n - 1] - a[0], cnt = 0;
for (int i = 0; i < n - 1; i++) {
long l = a[i + 1] - a[i];
if (bst > l) bst = l, cnt = 0;
if (bst == l) ++cnt;
}
cout << bst << " " << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int m;
long long mpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % m;
x = x * x % m;
n /= 2;
}
return res;
}
int main() {
long long n;
cin >> n >> m;
cout << (mpow(3, n) + m - 1) % m << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c = 0;
cin >> n >> m;
for (int i = 0; i <= max(m, n); i++)
for (int j = 0; j <= max(m, n); j++)
if (i * i + j == n && i + j * j == m) c++;
cout << c << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int r[3];
memset(r, 0, sizeof(r));
for (int i = 0; i < n; i++) {
r[a[i] % 3]++;
}
long long int ans = r[0] / 2 + min(r[1], r[2]);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
std::list<int> r[100000];
int d[100000];
void rec(int i, int n) {
if (d[i] == -1) {
d[i] = n;
for (std::list<int>::iterator j = r[i].begin(); j != r[i].end(); j++) {
rec(*j, n + 1);
}
}
}
int abs(int r) {
if (r < 0) return -r;
return r;
}
int ans[100000];
int ddd(int a, int b) {
if (b > a) return ddd(b, a);
if (b == 0) return a;
return ddd(b, a % b);
}
int q[100000][2];
int main() {
memset(d, 0xff, sizeof(d));
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
r[a - 1].push_back(b - 1);
q[i][0] = a - 1;
q[i][1] = b - 1;
}
rec(0, 0);
int t = 0;
for (int i = 0; i < m; i++)
if (d[q[i][0]] >= 0 && d[q[i][1]] >= 0) {
t = ddd(t, abs(d[q[i][0]] + 1 - d[q[i][1]]));
}
printf("%d\n", t);
int k = 0;
for (int i = 0; i < n; i++)
if (d[i] % t == 0 && d[i] >= 0) k++, ans[k - 1] = i + 1;
printf("%d\n", k);
for (int i = 0; i < k; i++) printf("%d ", ans[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, m;
cin >> n >> m;
long long int a, b;
while (m--) {
cin >> a >> b;
}
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
cout << 0;
else
cout << 1;
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[66666];
int g[66666];
int que[66666];
int main() {
int n;
cin >> n;
int head = 0, tail = 0;
int edgeNum = 0;
for (int i = 0; i < n; i++) {
cin >> f[i] >> g[i];
if (f[i] == 1) que[tail++] = i;
edgeNum += f[i];
}
cout << edgeNum / 2 << endl;
while (head < tail) {
int now = que[head++];
if (f[now] == 0) continue;
f[g[now]]--;
g[g[now]] ^= now;
if (f[g[now]] == 1) que[tail++] = g[now];
cout << now << " " << g[now] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 2000 + 100;
using namespace std;
char s1[maxn], s2[maxn];
int dp[maxn][maxn];
int n, m;
int solve(int i) {
int top = m, ans = 0;
if (i < m) return maxn;
while (top && i) {
if (s1[i] == s2[top])
top--;
else
ans++;
i--;
}
if (top)
return maxn;
else
return ans;
}
int main() {
scanf("%s%s", s1 + 1, s2 + 1);
n = strlen(s1 + 1);
m = strlen(s2 + 1);
for (int i = 0; i <= n; i++)
for (int j = i + 1; j <= n; j++) dp[i][j] = -maxn;
for (int i = 1; i <= n; i++) {
int k = solve(i);
for (int j = 0; j <= i; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j]);
if (j >= k) {
dp[i][j] = max(dp[i][j], dp[i - m - k][j - k] + 1);
}
}
}
for (int i = 0; i <= n; i++) {
printf("%d ", dp[n][i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 1e9 + 7;
const long double EPS = 1e-9;
const long double PI = 3.14159265359;
int main() {
int n;
cin >> n;
cout << "YES\n";
for (int i = 0; i < n; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << ((12 + 2 * (x1 % 2) + (y1 % 2)) % 4) + 1 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T>;
const int mod = 998244353;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct PairHash {
template <typename T1, typename T2>
std::size_t operator()(const pair<T1, T2> &p) const {
return hash<T1>()(p.first) ^ hash<T2>()(p.second);
}
};
bool is_power_of_2(int n) { return (n & (n - 1)) == 0; }
bool can(int n, int k) {
if (n % 2 == 0 || k > max(0, (n - 3) / 2)) {
return false;
}
if (is_power_of_2(n + 1)) {
if (k == 1) {
return false;
}
} else {
if (k == 0) {
return false;
}
}
return !(n == 9 && k == 2);
}
void solve(int ncase) {
int n, k;
scanf("%d%d", &n, &k);
if (!can(n, k)) {
puts("NO");
return;
}
puts("YES");
vector<int> p(n + 1);
int idx = 1;
int sub_root = 0;
while (k > 1) {
if (can(n + 1 - idx - 2, k - 1)) {
p[idx] = sub_root;
p[idx + 1] = idx;
sub_root = idx;
idx += 2;
} else {
p[idx] = sub_root;
p[idx + 1] = idx;
p[idx + 2] = p[idx + 3] = idx + 1;
sub_root = idx;
idx += 4;
}
k--;
}
int left = n + 1 - idx;
if (left == 1) {
p[idx] = sub_root;
} else if (left == 3) {
p[idx] = sub_root;
p[idx + 1] = p[idx + 2] = idx;
} else {
int m = 0;
while ((1 << m) < left) m++;
m--;
int left_sub = (1 << m) - 1;
int right_sub = left - 1 - left_sub;
if (k == 1 && left_sub > right_sub * 2) {
m--;
left_sub = (1 << m) - 1;
right_sub = left - 1 - left_sub;
}
(left_sub, right_sub);
p[idx] = sub_root;
p[idx + 1] = idx;
for (int i = 2; i <= left_sub; i++) {
p[i + idx] = idx + i / 2;
}
p[idx + left_sub + 1] = idx;
for (int i = 2; idx + left_sub + i <= n; i++) {
p[idx + left_sub + i] = idx + left_sub + i / 2;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", p[i], " \n"[i == n]);
}
void solve_all_cases() {
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
int main() {
cout << std::fixed;
cout << setprecision(9);
solve_all_cases();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[12][2020];
int mx[2020], id[2020];
int dp[13][1 << 12];
int sum[1 << 12];
int main() {
int T, n, m;
for (cin >> T; T--;) {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", a[i] + j);
for (int j = 0; j < m; j++) {
mx[j] = 0;
for (int i = 0; i < n; i++) mx[j] = max(mx[j], a[i][j]);
id[j] = j;
}
sort(id, id + m, [](int a, int b) { return mx[a] > mx[b]; });
int mask = (1 << n) - 1;
m = min(m, n);
for (int jj = 0; jj < m; jj++) {
int j = id[jj];
for (int i = 1; i < 1 << n; i++) {
sum[i] = sum[i - (i & -i)] + a[__builtin_ctz(i)][j];
}
for (int i = 1; i < 1 << n; i++) {
int mx = 0;
for (int k = 0; k < n; k++) {
int ii = ((i << k) & mask) + (((i << k) & (mask << n)) >> n);
mx = max(mx, sum[ii]);
}
sum[i] = mx;
}
for (int i = 0; i < 1 << n; i++) dp[jj + 1][i] = 0;
for (int i = 0; i < 1 << n; i++) {
for (int ii = mask ^ i;; ii = (ii - 1) & (mask ^ i)) {
dp[jj + 1][i | ii] = max(dp[jj + 1][i | ii], dp[jj][i] + sum[ii]);
if (ii == 0) break;
}
}
}
printf("%d\n", dp[m][mask]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[305][305];
int main() {
memset(a, 0, sizeof a);
int n;
cin >> n;
int i = 1, j = 1;
int t = 1;
bool flag = true;
while (t <= n * n) {
if (flag) {
while (i <= n) {
a[i++][j] = t++;
}
i--;
} else {
while (i >= 1) {
a[i--][j] = t++;
}
i++;
}
flag = !flag;
j++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 2e5 + 10;
long long val[maxn], ret = 0;
vector<int> g[maxn];
int N, sz[maxn][2], colour[maxn];
void DFS1(int v, int p, int c) {
colour[v] = c;
sz[v][c] = 1;
for (int u : g[v]) {
if (u != p) {
DFS1(u, v, 1 - c);
for (int x : {0, 1}) {
sz[v][x] += sz[u][x];
}
}
}
if (0)
for (int x : {0, 1}) {
printf("sz[%d][%d] = %d\n", v, x, sz[v][x]);
}
}
void DFS2(int v, int p) {
if (0) cout << "v = " << v << endl;
ret += val[v];
if (ret >= MOD) ret -= MOD;
long long B = sz[1][colour[v]] - sz[v][colour[v]],
W = sz[1][1 - colour[v]] - sz[v][1 - colour[v]];
for (int u : g[v]) {
if (u != p) {
DFS2(u, v);
ret += (val[v] * B % MOD) * (sz[u][0] + sz[u][1]) % MOD;
if (ret >= MOD) ret -= MOD;
ret += (val[v] * sz[u][colour[v]] % MOD) * (B + W) % MOD;
if (ret >= MOD) ret -= MOD;
ret -= (val[v] * sz[u][1 - colour[v]] % MOD) * (B + W) % MOD;
if (ret < 0) ret += MOD;
ret -= (val[v] * W % MOD) * (sz[u][0] + sz[u][1]) % MOD;
if (ret < 0) ret += MOD;
B += sz[u][colour[v]];
W += sz[u][1 - colour[v]];
}
}
ret += (val[v] * B % MOD) * 2 % MOD;
if (ret >= MOD) ret -= MOD;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%lld", &val[i]);
}
for (int i = 1; i < N; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
DFS1(1, 1, 1);
DFS2(1, 1);
printf("%lld\n", (ret % MOD + MOD) % MOD);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, min = INT_MAX, count = 0;
int arr[1000001];
int j;
cin >> n;
for (j = 0; j < n; j++) cin >> arr[j];
sort(arr, arr + n);
int i, diff;
for (i = 0; i < n - 1; i++) {
j = i + 1;
diff = arr[j] - arr[i];
if (diff < 0) diff = -diff;
if (diff < min) {
min = diff;
count = 1;
} else if (diff == min)
count++;
}
cout << min << " " << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 5;
inline void getint(int& num) {
char c;
bool flag = 0;
num = 0;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = 1;
while (c >= '0' && c <= '9') {
num = num * 10 + c - 48;
c = getchar();
}
if (flag) num = -num;
}
int n, m, K, key, tot, tar, room, fa[N], Fa[N], R;
pair<int, int> e[N];
string str;
map<string, int> human;
int root(int x) {
if (!fa[x]) return x;
return fa[x] = root(fa[x]);
}
void merge(int a, int b) {
if (root(a) > root(b))
fa[root(a)] = root(b);
else
fa[root(b)] = root(a);
}
int Root(int x) {
if (!Fa[x]) return x;
return Fa[x] = Root(Fa[x]);
}
void Merge(int a, int b) {
if (Root(a) > Root(b))
Fa[Root(a)] = Root(b);
else
Fa[Root(b)] = Root(a);
}
int main() {
getint(n), getint(m), getint(K);
for (int i = 1; i <= m; i++) getint(e[i].first), getint(e[i].second);
for (int i = 1; i <= K; i++) {
cin >> str, human[str] = i + n + m;
getint(room), getint(tot);
for (int j = 1; j <= tot; j++) getint(key), merge(key + n, room);
merge(i + n + m, room);
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++) {
int x = root(e[j].first);
int y = root(e[j].second);
if (x == y) continue;
if (root(j + n) == x || root(j + n) == y) merge(x, y);
}
for (int i = 1; i <= K; i++) {
cin >> str;
getint(room), getint(tot);
for (int j = 1; j <= tot; j++) getint(key), Merge(key + n, room);
Merge(human[str], room);
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++) {
int x = Root(e[j].first);
int y = Root(e[j].second);
if (x == y) continue;
if (Root(j + n) == x || Root(j + n) == y) Merge(x, y);
}
bool flag = 1;
for (int i = 1; i <= n + m + K; i++)
if (root(i) != Root(i)) {
flag = 0;
break;
}
printf("%s\n", flag ? "YES" : "NO");
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.