solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int i, j, n;
cin >> n;
map<int, int> a;
for (i = 0; i < n; i++) {
cin >> j;
a[j]++;
}
if (a.size() == 1) {
a[a.rbegin()->first]--;
if (a.rbegin()->first == 1)
a[2]++;
else
a[1]++;
for (auto i : a) {
for (j = 1; j <= i.second; j++) cout << i.first << " ";
}
} else {
a[a.rbegin()->first]--;
a[1]++;
for (auto i : a) {
for (j = 1; j <= i.second; j++) cout << i.first << " ";
}
}
}
int main() {
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) solve();
auto stop = chrono::high_resolution_clock::now();
auto durn = chrono::duration_cast<chrono::microseconds>(stop - start);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, z;
vector<int> v;
bool diff = false;
cin >> n;
v.resize(n);
cin >> v[0];
for (int i = 1; i < n; i++) {
cin >> v[i];
if (v[i] != v[i - 1]) diff = true;
}
if (n > 2 && diff) {
for (int k = 0; k < 2; k++) {
x = v[k];
y = v[k + 1];
for (int i = k + 2; i < n; i++) {
z = v[i];
if (x != z) {
if (y == z || (x < y && y < z) || (z < y && y < x))
cout << k + 1 << " " << k + 2 << endl;
else if (x == y)
cout << k + 2 << " " << i + 1 << endl;
else
cout << k + 1 << " " << i + 1 << endl;
return 0;
}
}
}
}
cout << -1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int MAXN = 1e3;
int N;
int A[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
priority_queue<int> vals;
priority_queue<int> found;
for (int i = 0; i < N * N; i++) {
int v;
cin >> v;
vals.push(v);
}
for (int i = 0; i < N; i++) {
while (!vals.empty() && !found.empty() && vals.top() == found.top()) {
vals.pop();
found.pop();
}
A[i] = vals.top();
vals.pop();
for (int j = 0; j < i; j++) {
int g = gcd(A[i], A[j]);
found.push(g);
found.push(g);
}
}
assert(found.size() == vals.size());
for (int i = 0; i < N; i++) cout << A[i] << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int edge[100005][3];
int newedge[100005][3];
int ansx[100005], ansy[100005];
int ansi;
int sh[100005];
void init() {
srand(time(0));
memset(edge, 0, sizeof(edge));
scanf("%d%d", &n, &m);
int u, v;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
edge[u][++edge[u][0]] = v;
edge[v][++edge[v][0]] = u;
}
}
int find() {
int arr[100005];
for (int i = 1; i <= n; ++i) arr[i] = i;
random_shuffle(arr + 1, arr + n + 1);
arr[n + 1] = arr[1];
for (int i = 1; i <= m; ++i) {
int x = arr[i];
int y = arr[i + 1];
if (x == edge[y][1] || x == edge[y][2]) return 0;
ansx[i - 1] = x;
ansy[i - 1] = y;
}
return 1;
}
void work() {
int succ = 0;
int test = 100;
for (int i = 0; i < test; ++i) {
if (find()) {
succ = 1;
break;
}
}
if (succ)
for (int i = 0; i < m; ++i) cout << ansx[i] << " " << ansy[i] << endl;
else
cout << -1 << endl;
}
int main(int argc, char *argv[]) {
init();
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long a[20];
int n;
unsigned long long d[20];
unsigned long long sum[10];
unsigned long long d2[20];
unsigned long long x1[20];
unsigned long long x2[20];
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
sum[0] = 0;
for (int i = 1; i <= 9; i++) sum[i] = sum[i - 1] + i;
d[0] = 1;
for (int i = 1; i <= 17; i++) {
d[i] = d[i - 1] * 10;
if (i < 18) d2[i] = d[i] * 9 * i / 2;
}
unsigned long long need;
cin >> need;
for (int i = 1; i <= 17; i++) {
x1[i] = 0;
x2[i] = 0;
}
unsigned long long r1 = 0;
unsigned long long r2 = 0;
unsigned long long b;
for (int dig = 17; dig >= 1; dig--) {
n = 17;
unsigned long long best = 9000000000000000000;
int best1 = 0;
int best2 = 0;
for (int dig1 = 0; dig1 <= 9; dig1++)
for (int dig2 = 0; dig2 <= 9; dig2++) {
x1[dig] = dig1;
x2[dig] = dig2;
for (int i = 1; i <= 17; i++) a[i] = x1[i];
int sm = 0;
unsigned long long res1 = 0;
for (int i = n; i >= 1; i--) {
res1 += a[i];
res1 += a[i] * d2[i - 1] + sum[a[i] - 1] * d[i - 1] +
sm * d[i - 1] * a[i];
sm += a[i];
}
for (int i = 1; i <= 17; i++) a[i] = x2[i];
sm = 0;
unsigned long long res2 = 0;
for (int i = n; i >= 1; i--) {
res2 += a[i];
res2 += a[i] * d2[i - 1] + sum[a[i] - 1] * d[i - 1] +
sm * d[i - 1] * a[i];
sm += a[i];
}
if (res2 >= res1) {
unsigned long long huyak;
if (res2 - res1 > need)
huyak = res2 - res1 - need;
else
huyak = need + res1 - res2;
if (huyak < best) {
best1 = dig1;
best2 = dig2;
best = huyak;
r1 = res1;
r2 = res2;
}
}
}
x1[dig] = best1;
x2[dig] = best2;
b = best;
}
unsigned long long res1 = r1;
unsigned long long res2 = r2;
int cnt = 0;
if (r2 - r1 != need)
while (true) {
cnt++;
int x = 1;
while (x1[x] == 9) {
x1[x] = 0;
x++;
}
x1[x] = (x1[x] + 1) % 10;
for (int i = 1; i <= 17; i++) res1 += x1[i];
while (res1 + need > res2) {
int x = 1;
while (x2[x] == 9) {
x2[x] = 0;
x++;
}
x2[x] = (x2[x] + 1) % 10;
for (int i = 1; i <= 17; i++) res2 += x2[i];
}
if (res1 + need == res2) break;
}
int x = 1;
while (x1[x] == 9) {
x1[x] = 0;
x++;
}
x1[x] = (x1[x] + 1) % 10;
bool z = false;
for (int i = 17; i >= 1; i--) {
if (x1[i] > 0) z = true;
if (z) cout << x1[i];
}
cout << "\n";
z = false;
for (int i = 17; i >= 1; i--) {
if (x2[i] > 0) z = true;
if (z) cout << x2[i];
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long ppl[101];
int main() {
long long n, m, i;
scanf("%lld %lld", &n, &m);
for (i = 0; i < m; ++i) {
long long sender, reciever, amt;
scanf("%lld %lld %lld", &sender, &reciever, &amt);
ppl[sender] -= amt;
ppl[reciever] += amt;
}
long long total = 0;
for (i = 0; i <= n; ++i)
if (ppl[i] > 0) total += ppl[i];
printf("%lld\n", total);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (b < a * 2) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
for (int i = 0; i < a - 1; i++) cout << 2 << ' ';
cout << b - 2 * (a - 1) << '\n';
cout << 1 << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = 2e16;
const long long maxn = 1e6 + 5;
const double Pi = acos(-1.0);
double Exp = 1e-4;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long n, m, kk;
struct node {
long long x;
long long id;
} a[maxn];
long long tot = 0;
bool cmp(node a, node b) {
if (a.x != b.x) return a.x < b.x;
return a.id < b.id;
}
long long dp[265];
long long vis[8];
signed main() {
n = read(), m = read(), kk = read();
for (long long i = 1; i <= n; i++) {
long long l = read(), r = read();
tot++;
a[tot].x = l, a[tot].id = i;
tot++;
a[tot].x = r + 1, a[tot].id = -i;
}
sort(a + 1, a + 1 + tot, cmp);
for (long long i = 1; i < 256; i++) dp[i] = -INF;
for (long long i = 1; i <= tot; i++) {
long long k;
long long len = 0;
long long p = a[i].id;
if (i != tot) {
len = a[i + 1].x - a[i].x;
}
if (p > 0) {
for (long long i = 0; i < 8; i++) {
if (vis[i] == 0) {
k = i;
vis[i] = p;
break;
}
}
for (long long i = 255; i >= 0; i--) {
if ((i >> k) & 1) {
dp[i] = dp[i ^ (1 << k)] + len * __builtin_parity(i);
} else {
dp[i] = dp[i] + len * __builtin_parity(i);
}
}
} else {
for (long long i = 0; i < 8; i++) {
if (vis[i] == -p) {
k = i;
vis[i] = 0;
break;
}
}
for (long long i = 0; i < 256; i++) {
if ((i >> k) & 1) {
dp[i] = -INF;
} else {
dp[i] = max(dp[i], dp[i ^ (1 << k)]) + len * __builtin_parity(i);
}
}
}
}
printf("%lld\n", dp[0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int A[MAXN];
int num[MAXN];
bool valid[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
fill(num, num + n + 2, 1);
num[n + 1] = 0;
int maxi = 0;
for (int i = n - 1; i >= 0; i--) {
if (valid[A[i] + 1]) num[A[i]] += num[A[i] + 1];
valid[A[i]] = true;
maxi = max(maxi, num[A[i]]);
}
fill(num, num + n + 2, 1);
num[0] = 0;
fill(valid, valid + n + 1, false);
valid[0] = true;
for (int i = 0; i < n; i++) {
if (valid[A[i] - 1]) num[A[i]] += num[A[i] - 1];
valid[A[i]] = true;
maxi = max(maxi, num[A[i]]);
}
printf("%d\n", n - maxi);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> node[500000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) node[i].clear();
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--, b--;
node[a].push_back(b);
node[b].push_back(a);
}
string s;
cin >> s;
int maxdeg = 0;
for (int i = 0; i < n; i++) maxdeg = max(maxdeg, int(node[i].size()));
int whites = count(s.begin(), s.end(), 'W');
if (n <= 3) {
if (n == 3 && whites == 2)
goto win;
else
goto draw;
}
if (maxdeg >= 4) goto win;
if (maxdeg == 2) {
for (int i = 0; i < n; i++)
if (s[i] == 'W' && node[i].size() == 2) goto win;
if (whites == 2 && n % 2)
goto win;
else
goto draw;
} else if (maxdeg == 3 && !whites) {
if (n <= 5) goto draw;
int triples = 0;
for (int i = 0; i < n; i++) {
if (node[i].size() == 3) {
int leaves = 0;
for (int j : node[i]) leaves += node[j].size() == 1;
if (leaves <= 1) goto win;
triples++;
}
}
if (triples >= 3) goto win;
if (triples == 2 && n % 2) goto win;
goto draw;
} else if (maxdeg == 3 && whites) {
int ok = 0;
for (int i = 0; i < n; i++)
if (s[i] == 'W' && node[i].size() >= 2) ok = 1;
int leaves = 0, triples = 0;
for (int i = 0; i < n; i++) {
if (node[i].size() == 3) {
for (int j : node[i]) {
leaves += node[j].size() == 1;
if (s[j] == 'W') ok = 1;
}
triples++;
}
}
if (triples == 1 && leaves == 2 && !ok && n % 2) goto draw;
goto win;
}
assert(0);
continue;
win:
cout << "White" << endl;
continue;
draw:
cout << "Draw" << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, signal, word[26];
char s[100];
while (scanf("%d %s", &n, &s) == 2) {
for (i = 0; i < 26; i++) {
word[i] = 0;
}
for (i = 0; i < n; i++) {
if (s[i] == 65 || s[i] == 97) {
word[0] = 1;
} else if (s[i] == 66 || s[i] == 98) {
word[1] = 1;
} else if (s[i] == 67 || s[i] == 99) {
word[2] = 1;
} else if (s[i] == 68 || s[i] == 100) {
word[3] = 1;
} else if (s[i] == 69 || s[i] == 101) {
word[4] = 1;
} else if (s[i] == 70 || s[i] == 102) {
word[5] = 1;
} else if (s[i] == 71 || s[i] == 103) {
word[6] = 1;
} else if (s[i] == 72 || s[i] == 104) {
word[7] = 1;
} else if (s[i] == 73 || s[i] == 105) {
word[8] = 1;
} else if (s[i] == 74 || s[i] == 106) {
word[9] = 1;
} else if (s[i] == 75 || s[i] == 107) {
word[10] = 1;
} else if (s[i] == 76 || s[i] == 108) {
word[11] = 1;
} else if (s[i] == 77 || s[i] == 109) {
word[12] = 1;
} else if (s[i] == 78 || s[i] == 110) {
word[13] = 1;
} else if (s[i] == 79 || s[i] == 111) {
word[14] = 1;
} else if (s[i] == 80 || s[i] == 112) {
word[15] = 1;
} else if (s[i] == 81 || s[i] == 113) {
word[16] = 1;
} else if (s[i] == 82 || s[i] == 114) {
word[17] = 1;
} else if (s[i] == 83 || s[i] == 115) {
word[18] = 1;
} else if (s[i] == 84 || s[i] == 116) {
word[19] = 1;
} else if (s[i] == 85 || s[i] == 117) {
word[20] = 1;
} else if (s[i] == 86 || s[i] == 118) {
word[21] = 1;
} else if (s[i] == 87 || s[i] == 119) {
word[22] = 1;
} else if (s[i] == 88 || s[i] == 120) {
word[23] = 1;
} else if (s[i] == 89 || s[i] == 121) {
word[24] = 1;
} else if (s[i] == 90 || s[i] == 122) {
word[25] = 1;
}
}
for (i = 0; i < 26; i++) {
if (word[i] == 1) {
signal++;
} else {
signal = 0;
break;
}
}
if (signal == 26) {
printf("YES\n");
} else if (signal < 26) {
printf("NO\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d[405][405];
int dg[405];
int n, m;
double u[405][405];
int ut[405][405];
double sm[405];
int st[405];
int T;
void clr() { T++; }
double &gu(int i, int j) {
if (ut[i][j] != T) {
u[i][j] = 0;
ut[i][j] = T;
}
return u[i][j];
}
double &gsm(int i) {
if (st[i] != T) {
sm[i] = 0;
st[i] = T;
}
return sm[i];
}
vector<int> l[405];
double pd[405];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++) d[i][j] = 1000;
for (int i = (0); i < (n); i++) d[i][i] = 0;
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
d[a][b] = d[b][a] = 1;
dg[a]++;
dg[b]++;
}
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++)
for (int k = (0); k < (n); k++) d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
double bst = 0;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++) l[j].clear();
for (int j = (0); j < (n); j++) l[d[i][j]].push_back(j);
double cans = 0;
for (int li = (0); li < (n); li++)
if (int(l[li].size())) {
double lb = 1. / int(l[li].size());
for (int j = (0); j < (n); j++) pd[j] = 0;
clr();
for (int j : l[li]) {
double du = 1. / dg[j] / int(l[li].size());
for (int k = (0); k < (n); k++)
if (d[j][k] == 1) {
pd[k] += du;
}
}
for (int j = (0); j < (n); j++)
if (pd[j] > 1e-5) {
for (int k = (0); k < (n); k++) {
double ov = gu(k, d[j][k]);
if (ov < pd[j]) {
double os = gsm(k);
os += pd[j] - ov;
gsm(k) = os;
ov = pd[j];
gu(k, d[j][k]) = ov;
}
}
}
for (int j = (0); j < (n); j++) lb = max(lb, gsm(j));
cans += lb * int(l[li].size()) / 1. / n;
}
bst = max(bst, cans);
}
printf("%.12lf\n", bst);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct zz {
int ed, last;
} w[705 << 1];
int cot = 0, head[705];
void Add(int s, int e) {
w[++cot].ed = e, w[cot].last = head[s], head[s] = cot;
return;
}
struct Big {
long long num[25], l;
Big operator*(const Big &b) const {
Big ans;
memset(ans.num, 0, sizeof(ans.num));
for (int i = 1; i <= l; i++)
for (int j = 1; j <= b.l; j++) ans.num[i + j - 1] += num[i] * b.num[j];
int len = l + b.l + 1;
for (int i = 1; i <= len; i++)
ans.num[i + 1] += ans.num[i] / 100000000, ans.num[i] %= 100000000;
while (ans.num[len] == 0 && len) len--;
if (!len) len = 1;
ans.l = len;
return ans;
}
Big operator*(const int &b) const {
Big ans;
memset(ans.num, 0, sizeof(ans.num));
for (int i = 1; i <= l; i++) ans.num[i] += num[i] * b;
int len = l + 2;
for (int i = 1; i <= len; i++)
ans.num[i + 1] += ans.num[i] / 100000000, ans.num[i] %= 100000000;
while (ans.num[len] == 0 && len) len--;
if (!len) len = 1;
ans.l = len;
return ans;
}
void Output() {
printf("%lld", num[l]);
for (int i = l - 1; i >= 1; i--) printf("%08lld", num[i]);
puts("");
return;
}
} dp[705][705];
int sz[705];
Big Max(Big k1, Big k2) {
if (k1.l < k2.l) return k2;
if (k1.l > k2.l) return k1;
int l1 = k1.l, l2 = k2.l;
while (l1 && l2 && k1.num[l1] == k2.num[l2]) l1--, l2--;
if (!l1 && !l2) return k1;
if (k1.num[l1] > k2.num[l2])
return k1;
else
return k2;
}
void dfs(int now, int pre) {
sz[now] = 1;
dp[now][1].l = 1, dp[now][1].num[1] = 1;
for (int i = head[now]; i; i = w[i].last) {
int e = w[i].ed;
if (e == pre) continue;
dfs(e, now);
for (int j = sz[now]; j >= 1; j--) {
for (int k = sz[e]; k >= 0; k--)
dp[now][j + k] = Max(dp[now][j + k], dp[now][j] * dp[e][k]);
}
sz[now] += sz[e];
}
for (int i = 1; i <= sz[now]; i++)
dp[now][0] = Max(dp[now][0], dp[now][i] * i);
return;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, a, b; i < n; i++) {
scanf("%d%d", &a, &b);
Add(a, b), Add(b, a);
}
dfs(1, 0);
dp[1][0].Output();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int to[N << 1], nt[N << 1], hd[N], tot = 1;
void adde(int x, int y) {
++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot;
++tot, to[tot] = x, nt[tot] = hd[y], hd[y] = tot;
}
int sl, sr, n, m, ra[N][2], a[N][2], tt = 1, ff[N], co[N], sq[N], tp, cn[N];
bool an[N];
queue<int> q;
bool cmp(int aa, int bb) { return a[aa][0] < a[bb][0]; }
multiset<int> sb;
int main() {
sl = rd(), sr = rd(), n = rd(), m = rd();
for (int i = 1; i <= n; ++i) ra[i][0] = rd(), ra[i][1] = rd();
a[0][0] = -1, a[0][1] = 2e9;
for (int i = 1; i <= m; ++i) adde(rd(), rd());
for (int i = 1; i <= n; ++i)
if (!ff[i]) {
++tt, a[tt][0] = a[0][0], a[tt][1] = a[0][1];
++tt, a[tt][0] = a[0][0], a[tt][1] = a[0][1];
ff[i] = tt - 1, q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
int xt = tt ^ 1 ^ co[x];
a[xt][0] = max(a[xt][0], ra[x][0]), a[xt][1] = min(a[xt][1], ra[x][1]);
for (int j = hd[x]; j; j = nt[j]) {
int y = to[j];
if (ff[y]) {
if (co[x] == co[y]) {
puts("IMPOSSIBLE");
return 0;
}
} else
ff[y] = ff[x] ^ 1, co[y] = co[x] ^ 1, q.push(y);
}
}
if (a[tt - 1][0] > a[tt - 1][1] || a[tt][0] > a[tt][1]) {
puts("IMPOSSIBLE");
return 0;
}
}
int m1 = 0, m2 = 0;
for (int i = 2; i <= tt; ++i) {
if (a[i][0] > a[m1][0]) m1 = i;
if (a[i][1] < a[m2][1]) m2 = i;
}
if (a[m1][0] <= a[m2][1]) {
int z1 = a[m1][0], z2 = a[m2][1],
pl = max(max(a[m1 ^ 1][0], a[m2 ^ 1][0]), 0),
pr = min(a[m1 ^ 1][1], a[m2 ^ 1][1]),
rs = (tt >> 1) - 2 + ((m1 >> 1) == (m2 >> 1));
an[m1 >> 1] = m1 & 1, an[m2 >> 1] = m2 & 1;
for (int i = 2; i <= tt; ++i)
if ((i >> 1) != (m1 >> 1) && (i >> 1) != (m2 >> 1)) sq[++tp] = i;
sort(sq + 1, sq + tp + 1, cmp);
sb.insert(pr);
for (int i = 0; i <= tp; ++i) {
int x = sq[i];
if (x) {
if (a[x][0] > pr) break;
++cn[x >> 1];
if (cn[x >> 1] == 1)
--rs, sb.insert(a[x][1]), an[x >> 1] = (x & 1) ^ 1;
else {
int y = x ^ 1;
if (a[x][1] > a[y][1])
sb.erase(sb.find(a[y][1])), sb.insert(a[x][1]), an[x >> 1] ^= 1;
}
}
int nl = max(pl, a[x][0]), nr = (*sb.begin());
if (rs <= 0 && nl <= nr && max(nl + z1, sl) <= min(nr + z2, sr)) {
puts("POSSIBLE");
int mm = sl - (z1 + nl);
if (mm > 0) {
if (z1 + mm <= z2)
z1 += mm;
else
nl += mm - (z2 - z1), z1 = z2;
}
printf("%d %d\n", z1, nl);
for (int i = 1; i <= n; ++i)
printf("%d", 1 + ((an[ff[i] >> 1] ^ ff[i]) & 1));
return 0;
}
}
}
tp = 0;
sb.clear();
memset(cn, 0, sizeof(cn));
if (m1 != m2) {
int z1 = a[m1][0], z2 = a[m2][1], pl = max(max(a[m1 ^ 1][0], a[m2][0]), 0),
pr = min(a[m1][1], a[m2 ^ 1][1]),
rs = (tt >> 1) - 2 + ((m1 >> 1) == (m2 >> 1));
an[m1 >> 1] = m1 & 1, an[m2 >> 1] = (m2 & 1) ^ 1;
for (int i = 2; i <= tt; ++i)
if ((i >> 1) != (m1 >> 1) && (i >> 1) != (m2 >> 1)) sq[++tp] = i;
sort(sq + 1, sq + tp + 1, cmp);
sb.insert(pr);
for (int i = 0; i <= tp; ++i) {
int x = sq[i];
if (x) {
if (a[x][0] > z2) break;
++cn[x >> 1];
if (cn[x >> 1] == 1)
--rs, sb.insert(a[x ^ 1][1]), an[x >> 1] = (x & 1) ^ 1;
else {
int y = x ^ 1;
if (a[y][1] > a[x][1])
sb.erase(sb.find(a[x][1])), sb.insert(a[y][1]), an[x >> 1] ^= 1;
}
}
int nl = max(pl, a[x][0]), nr = (*sb.begin());
if (rs <= 0 && z1 <= nr && nl <= z2 &&
max(nl + z1, sl) <= min(nr + z2, sr)) {
puts("POSSIBLE");
int mm = sl - (z1 + nl);
if (mm > 0) {
if (z1 + mm <= nr)
z1 += mm;
else
nl += mm - (nr - z1), z1 = nr;
}
printf("%d %d\n", z1, nl);
for (int i = 1; i <= n; ++i)
printf("%d", 1 + ((an[ff[i] >> 1] ^ ff[i]) & 1));
return 0;
}
}
}
puts("IMPOSSIBLE");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, x, y, curr, T, t, K, N, coun[51], fact[21], rev[51];
vector<int> ans, v;
set<int> cand;
set<int>::iterator it;
void precomp() {
fact[0] = 1;
for (i = 1; i < 21; i++) {
fact[i] = fact[i - 1] * i;
}
coun[0] = coun[1] = 1;
for (i = 2; i < 23; i++) {
coun[i] = fact[i - 2] + coun[i - 1];
for (j = 2; j < i; j++) {
coun[i] += (fact[j - 2] * coun[i - j]);
}
}
for (i = 23; i < 51; i++) coun[i] = coun[22];
}
void fillv(long long n, long long k) {
v.clear();
if (n < 3) {
for (i = n; i > 0; i--) v.push_back(i);
return;
}
cand.clear();
for (i = 1; i < n; i++) {
cand.insert((int)i);
rev[i] = 0;
}
v.push_back(n);
rev[n] = 1;
for (i = 1; i < (n - 1); i++) {
for (j = i + 1; rev[j] > 0; j = rev[j])
;
x = cand.size();
for (it = cand.begin(), y = 0; y < (k / fact[x - 2]); y++, ++it) {
if (j == (*it)) ++it;
}
if (j == (*it)) ++it;
v.push_back(*it);
rev[*it] = v.size();
cand.erase(it);
k = k % fact[x - 2];
}
v.push_back(*cand.begin());
}
void fill(long long n, long long k) {
int i;
if (n == 0) return;
if (coun[n - 1] > k) {
ans.push_back(ans.size() + 1);
fill(n - 1, k);
return;
}
k -= coun[n - 1];
for (i = 2; i < n; i++) {
j = fact[i - 2] * coun[n - i];
if (j <= k) {
k -= j;
continue;
}
break;
}
fillv(i, k / coun[n - i]);
k = k % (coun[n - i]);
n -= i;
int x = ans.size();
for (j = 0; j < i; j++) {
ans.push_back(x + v[j]);
}
fill(n, k);
}
int main() {
precomp();
cin >> T;
for (t = 0; t < T; t++) {
cin >> N >> K;
if (K > coun[N]) {
cout << "-1\n";
continue;
}
ans.clear();
fill(N, K - 1);
for (i = 0; i < N; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a, d;
int main() {
scanf("%d%d%d", &n, &a, &d);
double anst = 0, anst1, s1;
for (int i = 0; i < n; i++) {
int t, v;
scanf("%d%d", &t, &v);
s1 = 0.5 * v * v / a;
if (s1 > d) {
anst1 = t + sqrt(2.0 * d / a);
if (anst1 < anst)
anst1 = anst;
else
anst = anst1;
printf("%.9lf\n", anst1);
} else {
anst1 = t + 1.0 * v / a + (d - s1) / v;
if (anst1 < anst)
anst1 = anst;
else
anst = anst1;
printf("%.9lf\n", anst1);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int ind[100005];
vector<pair<long long int, long long int> > v, g;
vector<long long int> res;
bool comp(long long int i, long long int j) {
if (v[i].first == v[j].first) return v[i].second < v[j].second;
return v[i].first < v[j].first;
}
void solve() {
long long int n, m, s;
cin >> n >> m >> s;
v.resize(n), g.resize(m);
for (long long int i = 0; i < m; i++) {
cin >> g[i].first;
g[i].second = i;
}
for (long long int i = 0; i < n; i++) cin >> v[i].first;
for (long long int i = 0; i < n; i++) {
cin >> v[i].second;
ind[i] = i;
}
sort(g.begin(), g.end());
sort(ind, ind + n, comp);
long long int l0 = 1, r0 = m;
while (l0 <= r0) {
long long int m0 = (l0 + r0) / 2, ans = 0;
vector<long long int> dum(m, 0);
long long int j = n - 1, i = m - 1;
multiset<pair<long long int, long long int> > st;
while (i >= 0) {
long long int val = g[i].first;
while (j >= 0 && v[ind[j]].first >= val) {
st.insert({v[ind[j]].second, ind[j]});
j--;
}
if (st.empty()) {
ans = s + 1;
break;
}
pair<long long int, long long int> x = (*st.begin());
st.erase(st.begin());
ans += x.first;
long long int cnt = 0;
while (cnt < m0 && i >= 0) {
dum[g[i].second] = x.second + 1;
cnt++;
i--;
}
}
if (ans <= s) {
res = dum;
r0 = m0 - 1;
} else
l0 = m0 + 1;
}
if (res.empty()) {
cout << "NO";
return;
}
cout << "YES\n";
for (long long int i = 0; i < m; i++) cout << res[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t z = clock();
long long int qc = 1;
for (long long int i = 1; i <= qc; i++) {
solve();
}
fprintf(stderr, "Total Time:%.4Lf\n",
(long double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1e9 + 7;
const int MAXN = 25;
const int INF = 1e9;
int n, m, males;
vector<long long> vals;
char b[MAXN][MAXN];
int v = 0;
int scx, scy, sct;
vector<long long> ma[3], fe[3];
int source, sink;
long long dist[MAXN][MAXN][MAXN][MAXN];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
bool vis[MAXN][MAXN];
vector<int> adj[4 * MAXN * MAXN];
int res[4 * MAXN * MAXN][4 * MAXN * MAXN];
int h[4 * MAXN * MAXN];
queue<int> frontier;
int visited[4 * MAXN * MAXN];
int N;
bool level(int source, int sink) {
for (int i = 0; i <= N; i++) h[i] = INF;
h[source] = 0;
frontier.push(source);
while (frontier.size() > 0) {
int x = frontier.front();
frontier.pop();
for (int i : adj[x])
if (res[x][i] && h[i] == INF) {
h[i] = h[x] + 1;
frontier.push(i);
}
}
return (h[sink] != INF);
}
int dfs(int x, int source, int sink) {
if (x == sink) return 1;
visited[x] = 1;
int num = 0;
for (int i : adj[x]) {
if (!visited[i] && h[i] == h[x] + 1 && res[x][i] && dfs(i, source, sink)) {
res[x][i] -= 1;
res[i][x] += 1;
num += 1;
if (x != source) return num;
}
}
return num;
}
int maxflow(int source, int sink) {
int flow = 0;
while (true) {
if (!level(source, sink)) break;
for (int i = 0; i <= N; i++) visited[i] = 0;
flow += dfs(source, source, sink);
}
return flow;
}
bool chk(long long v) {
memset(res, 0, sizeof(res));
for (int i = 0; i <= N; ++i) adj[i].clear();
for (int i = 1; i <= males; ++i) {
adj[i].push_back(source);
adj[source].push_back(i);
res[source][i] = 1;
}
for (int i = males + 1; i <= 2 * males; ++i) {
adj[i].push_back(sink);
adj[sink].push_back(i);
res[i][sink] = 1;
}
for (int i = 1; i <= males; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k) {
int xd = ma[0][i - 1], yd = ma[1][i - 1];
if (dist[xd][yd][j][k] * ma[2][i - 1] > v) continue;
adj[i].push_back(j * m + k + 2 * males + 1);
adj[j * m + k + 2 * males + 1].push_back(i);
res[i][j * m + k + 2 * males + 1] = 1;
}
for (int i = 1; i <= males; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k) {
int xd = fe[0][i - 1], yd = fe[1][i - 1];
if (dist[xd][yd][j][k] * fe[2][i - 1] > v) continue;
adj[i + males].push_back(m * n + j * m + k + 2 * males + 1);
adj[m * n + j * m + k + 2 * males + 1].push_back(i + males);
res[m * n + j * m + k + 2 * males + 1][i + males] = 1;
}
for (int i = 2 * males + 1; i <= 2 * males + m * n; ++i) {
adj[i].push_back(i + m * n);
adj[i + m * n].push_back(i);
res[i][i + m * n] = 1;
}
return (maxflow(source, sink) >= males);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int mx, nx;
cin >> n >> m >> nx >> mx;
vals.push_back(0);
if ((nx - mx != 1) && (mx - nx != 1)) {
cout << "-1\n";
return 0;
}
males = max(nx, mx);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> b[i][j];
cin >> scx >> scy >> sct;
scx--;
scy--;
if (nx - mx == 1) {
fe[0].push_back(scx), fe[1].push_back(scy), fe[2].push_back(sct);
} else {
ma[0].push_back(scx), ma[1].push_back(scy), ma[2].push_back(sct);
}
for (int i = 0; i < nx; ++i) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
ma[0].push_back(x);
ma[1].push_back(y);
ma[2].push_back(t);
}
source = 0, sink = 2 * m * n + 2 * males + 1;
N = sink;
for (int i = 0; i < mx; ++i) {
int x, y, t;
cin >> x >> y >> t;
x--;
y--;
fe[0].push_back(x);
fe[1].push_back(y);
fe[2].push_back(t);
}
assert(ma[0].size() == fe[0].size());
for (int i = 0; i < ma[2].size(); ++i) {
for (int j = 1; j <= n * m; ++j)
vals.push_back(1LL * j * ma[2][i]), vals.push_back(1LL * j * fe[2][i]);
}
sort(vals.begin(), vals.end());
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int a = 0; a < n; ++a)
for (int b = 0; b < m; ++b) dist[i][j][a][b] = 1e9;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
memset(vis, 0, sizeof(vis));
if (b[i][j] == '#') continue;
queue<pair<int, int> > q;
pair<int, int> t = pair<int, int>(i, j);
dist[i][j][i][j] = 0;
q.push(t);
vis[i][j] = true;
while (!q.empty()) {
pair<int, int> t1 = q.front();
q.pop();
for (int k = 0; k < 4; ++k) {
int i1 = t1.first + dx[k], j1 = t1.second + dy[k];
if (i1 < 0 || i1 >= n || j1 < 0 || j1 >= m) continue;
if (vis[i1][j1] == 1) continue;
if (b[i1][j1] == '#') continue;
dist[i][j][i1][j1] = dist[i][j][t1.first][t1.second] + 1;
vis[i1][j1] = 1;
q.push(pair<int, int>(i1, j1));
}
}
}
int lo = 0, hi = vals.size();
while (lo != hi) {
long long mid = (lo + hi) / 2;
if (chk(vals[mid])) {
hi = mid;
} else
lo = mid + 1;
}
if (hi == vals.size()) {
cout << "-1\n";
} else
cout << vals[lo] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> pr[N];
bool notprime[N];
vector<int> primes;
int lw[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int x2;
cin >> x2;
notprime[0] = 1;
notprime[1] = 1;
for (int i = 2; i < N; i++) {
if (notprime[i]) continue;
for (int j = i + i; j < N; j += i) notprime[j] = 1;
}
for (int i = 0; i < N; i++) {
if (!notprime[i]) primes.push_back(i);
}
for (int i = 0; i < primes.size(); i++) {
for (int j = primes[i]; j < N; j += primes[i])
lw[j] = max(lw[j], primes[i]);
}
for (int i = 0; i < N; i++) {
lw[i] = i - lw[i] + 1;
}
int ans = INT_MAX;
for (int i = 0; i < primes.size(); i++) {
if (x2 % primes[i] == 0) {
for (int j = x2; j > x2 - primes[i]; j--) {
if (notprime[j]) ans = min(ans, lw[j]);
}
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n == 1) {
if (k == 0)
puts("1");
else
puts("-1");
return 0;
}
int a = k - n / 2 + 1;
if (a <= 0) {
puts("-1");
return 0;
}
int b = 2 * a;
int p1 = 1;
vector<int> ans;
ans.push_back(a);
ans.push_back(b);
int cnt = n / 2 - 1;
while (1) {
if (cnt == 0) break;
if ((p1 != a) && ((p1 + 1) != b) && (p1 != b) && (p1 + 1 != a)) {
ans.push_back(p1);
ans.push_back(p1 + 1);
cnt--;
p1++;
}
p1++;
}
if (n % 2 == 1) {
cnt = 1;
while (1) {
if (cnt == 0) break;
if ((p1 != a) && (p1 != b)) {
ans.push_back(p1);
cnt--;
}
p1++;
}
}
for (int i = 0; i < (int)ans.size(); i++)
cout << ans[i] << char(i + 1 == (int)ans.size() ? 10 : 32);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, q, tp, nn, tt, dep[N], dfn[N], low[N], stk[N], fa[25][N];
vector<int> g[N], gg[N];
void tarjan(int x, int p) {
dfn[x] = low[x] = ++tt;
stk[++tp] = x;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != p) {
int y = g[x][i];
if (!dfn[y]) {
tarjan(y, x), low[x] = min(low[x], low[y]);
if (low[y] >= dfn[x]) {
nn++;
while (stk[tp] != y)
gg[nn].push_back(stk[tp]), gg[stk[tp]].push_back(nn), tp--;
gg[nn].push_back(y), gg[y].push_back(nn);
tp--;
gg[nn].push_back(x), gg[x].push_back(nn);
}
} else
low[x] = min(low[x], dfn[y]);
}
}
void dfs(int x, int p) {
dep[x] = dep[p] + 1;
fa[0][x] = p;
for (int i = 0; i < gg[x].size(); i++)
if (gg[x][i] != p) dfs(gg[x][i], x);
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int sub = dep[u] - dep[v];
for (int i = 0; i <= 20; i++)
if (sub >> i & 1) u = fa[i][u];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (fa[i][u] != fa[i][v]) u = fa[i][u], v = fa[i][v];
return fa[0][u];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
nn = n;
tarjan(1, 0);
dfs(1, 0);
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= nn; j++) fa[i][j] = fa[i - 1][fa[i - 1][j]];
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", (dep[u] + dep[v] - dep[lca(u, v)] * 2) / 2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int table[1000][1000];
int main() {
int k = 0;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &table[i][j]);
}
}
while (k) {
char command;
int x, y;
scanf(" %c %d %d", &command, &x, &y);
if (command == 'g')
printf("%d\n", table[x - 1][y - 1]);
else if (command == 'c')
for (int i = 0; i < n; ++i) swap(table[i][x - 1], table[i][y - 1]);
else
for (int i = 0; i < m; ++i) swap(table[x - 1][i], table[y - 1][i]);
k--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
bool haveMask[1 << N];
int dp[1 << N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) s[i] -= 'a';
vector<bool> have;
for (int i = 0; i < s.size(); i++) {
have.assign(N, false);
int mask = 0;
for (int j = i; j < s.size() && !have[s[j]]; j++) {
have[s[j]] = true;
mask += 1 << s[j];
haveMask[mask] = true;
}
}
for (int mask = 0; mask < (1 << N); mask++)
if (haveMask[mask]) dp[mask] = __builtin_popcount(mask);
for (int i = 0; i < N; i++)
for (int mask = 0; mask < (1 << N); mask++)
if (mask >> i & 1) dp[mask] = max(dp[mask], dp[mask - (1 << i)]);
int ans = 0;
for (int mask = 0; mask < (1 << N); mask++)
if (haveMask[mask])
ans = max(ans, __builtin_popcount(mask) + dp[mask ^ ((1 << N) - 1)]);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <class T>
int size(T &&a) {
return (int)(a.size());
}
ostream &operator<<(ostream &os, string str) {
for (char c : str) os << c;
return os;
}
template <class A, class B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
template <class T>
auto operator<<(ostream &os, T &&x) -> decltype(x.begin(), os) {
os << '{';
for (auto it = x.begin(); it != x.end(); ++it)
os << *it << (it == prev(x.end()) ? "" : " ");
return os << '}';
}
template <class T>
ostream &operator<<(ostream &os, vector<vector<T>> vec) {
for (auto x : vec) os << "\n " << x;
return os;
}
void dump() {}
template <class T, class... Args>
void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<vector<int>> pos(n);
for (int i = 0; i < (n); ++i) {
cin >> a[i];
--a[i];
pos[a[i]].emplace_back(i);
}
vector<vector<int>> dp(n, vector<int>(n));
for (int len = (2); len <= (n); ++len) {
for (int i = 0; i < (n - len + 1); ++i) {
int j = i + len - 1;
dp[i][j] = dp[i + 1][j] + 1;
for (int k : pos[a[i]]) {
if (i < k and k <= j) {
if (k - 1 < i + 1)
dp[i][j] = min(dp[i][j], dp[k][j]);
else
dp[i][j] = min(dp[i][j], dp[i + 1][k - 1] + dp[k][j] + 1);
}
}
}
}
cout << dp[0][n - 1] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
ll n;
int main() {
cin >> n;
ll i = 0;
for (; (i * (i + 1) / 2) < n; ++i)
;
i--;
cout << (n - i * (i + 1) / 2);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '[';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << ']';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '{' << p.first << ", " << p.second << '}';
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
string sep;
for (const auto &x : s) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const map<A, B> &mp) {
os << '[';
string sep;
for (const auto &x : mp) os << sep << x, sep = ", ";
return os << ']';
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &s) {
os << '{';
string sep;
for (const auto &x : s) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long>> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i].first;
}
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
}
sort(v.begin(), v.end());
long long ans = 0;
priority_queue<pair<long long, long long>> pq;
for (long long i = 0; i < n;) {
long long j = 0;
for (j = i; j < n && (v[i].first == v[j].first); j++) {
pq.push({v[j].second, v[j].first});
}
long long last_limit = (j == n ? 1e18 : v[j].first);
long long now = v[i].first;
i = j;
while ((long long)(pq).size() && (now < last_limit)) {
pair<long long, long long> here = pq.top();
pq.pop();
ans += (now - here.second) * here.first;
now++;
}
}
cout << ans << '\n';
}
int32_t main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int ansa, ansb, ansc;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int main() {
a = read();
b = read();
c = read();
d = read();
if (c * 2 < d || d * 2 < c || a <= d || b <= d) {
printf("-1");
return 0;
}
printf("%d\n%d\n%d", a * 2, b * 2, min(c * 2, d * 2));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int temp = n;
int two = 1;
while (temp) {
if (temp == 3) {
cout << two << ' ' << two << ' ' << two * 3;
return 0;
}
temp /= 2;
if (n % 2) temp++;
for (int i = 0; i < temp; i++) {
cout << two << ' ';
}
two *= 2;
temp = n - temp;
n = temp;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const int eps = 1e-6;
const int N = 2e5 + 5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
cout << n << '\n';
string yo = s.substr(0, k);
for (int i = k; i < n; i++) {
yo += yo[i - k];
}
if (yo >= s) {
cout << yo;
return 0;
}
for (int i = k - 1; i >= 0; i--) {
if (yo[i] == '9')
yo[i] = '0';
else {
++yo[i];
break;
}
}
for (int i = k; i < n; i++) {
yo[i] = yo[i - k];
}
cout << yo;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
long long a[maxn], b[maxn], suma[maxn], sumb[maxn];
vector<long long> v;
int main() {
long long INF = 1000001;
INF = INF * INF * INF;
long long ans = INF;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int j = 1; j <= m; j++) cin >> b[j];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
long long prb = 1;
for (; prb <= m; prb++)
if (b[prb] > a[1]) break;
for (int i = prb; i <= m; i++) v.push_back(b[i]);
for (int i = 1; i <= n; i++)
if (a[i] < b[m]) v.push_back(a[i]);
if (v.size() == 0) {
cout << 0 << "\n";
return 0;
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; i++) suma[i] = suma[i - 1] + a[i];
for (int i = 1; i <= m; i++) sumb[i] = sumb[i - 1] + b[i];
long long pra = 1;
for (int i = 0; i < v.size(); i++) {
long long x = v[i];
while (prb <= m && b[prb] <= x) prb++;
while (pra <= n && a[pra] < x) pra++;
long long cur = ((pra - 1) * x - suma[pra - 1]);
cur += (sumb[m] - sumb[prb - 1] - (m - prb + 1) * x);
ans = min(ans, cur);
}
cout << ans;
cin >> n;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static char buf[200 << 20];
void* operator new(size_t s) {
static size_t i = sizeof buf;
assert(s < i);
return (void*)&buf[i -= s];
}
void operator delete(void*) {}
const int inf = 1e9;
struct Node {
Node *l = 0, *r = 0;
int lo, hi, mset = inf, madd = 0, val = 0;
Node(int lo, int hi) : lo(lo), hi(hi) {}
Node(vector<int>& v, int lo, int hi) : lo(lo), hi(hi) {
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
val = max(l->val, r->val);
} else
val = v[lo];
}
int query(int L, int R) {
if (R <= lo || hi <= L) return -inf;
if (L <= lo && hi <= R) return val;
push();
return max(l->query(L, R), r->query(L, R));
}
void set(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R)
mset = val = x, madd = 0;
else {
push(), l->set(L, R, x), r->set(L, R, x);
val = max(l->val, r->val);
}
}
void add(int L, int R, int x) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
if (mset != inf)
mset += x;
else
madd += x;
val += x;
} else {
push(), l->add(L, R, x), r->add(L, R, x);
val = max(l->val, r->val);
}
}
void push() {
if (!l) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid);
r = new Node(mid, hi);
}
if (mset != inf)
l->set(lo, hi, mset), r->set(lo, hi, mset), mset = inf;
else if (madd)
l->add(lo, hi, madd), r->add(lo, hi, madd), madd = 0;
}
};
template <bool VALS_EDGES>
struct HLD {
int N, tim = 0;
vector<vector<int>> adj;
vector<int> par, siz, depth, rt, pos;
Node* tree;
HLD(vector<vector<int>> adj_)
: N(adj_.size()),
adj(adj_),
par(N, -1),
siz(N, 1),
depth(N),
rt(N),
pos(N),
tree(new Node(0, N)) {
dfsSz(0);
dfsHld(0);
}
void dfsSz(int v) {
if (par[v] != -1) adj[v].erase(find(adj[v].begin(), adj[v].end(), par[v]));
for (int& u : adj[v]) {
par[u] = v, depth[u] = depth[v] + 1;
dfsSz(u);
siz[v] += siz[u];
if (siz[u] > siz[adj[v][0]]) swap(u, adj[v][0]);
}
}
void dfsHld(int v) {
pos[v] = tim++;
for (int u : adj[v]) {
rt[u] = (u == adj[v][0] ? rt[v] : u);
dfsHld(u);
}
}
template <class B>
void process(int u, int v, B op) {
for (; rt[u] != rt[v]; v = par[rt[v]]) {
if (depth[rt[u]] > depth[rt[v]]) swap(u, v);
op(pos[rt[v]], pos[v] + 1);
}
if (depth[u] > depth[v]) swap(u, v);
op(pos[u] + VALS_EDGES, pos[v] + 1);
}
void modifyPath(int u, int v, int val) {
process(u, v, [&](int l, int r) { tree->add(l, r, val); });
}
int queryPath(int u, int v) {
int res = -1e9;
process(u, v, [&](int l, int r) { res = max(res, tree->query(l, r)); });
return res;
}
int querySubtree(int v) {
return tree->query(pos[v] + VALS_EDGES, pos[v] + siz[v]);
}
};
class DSU {
vector<int> rank, parent;
int n;
public:
DSU(int n) : rank(n, 0), parent(n) {
this->n = n;
for (int i = 0; i < n; ++i) parent[i] = i;
}
int find(int x) {
if (parent[x] != x) parent[x] = find(parent[x]);
return parent[x];
}
void join(int x, int y) {
int xset = find(x);
int yset = find(y);
if (xset == yset) return;
if (rank[xset] < rank[yset])
parent[xset] = yset;
else if (rank[xset] > rank[yset])
parent[yset] = xset;
else {
parent[yset] = xset;
rank[xset]++;
}
}
};
vector<int> get_parents(const vector<vector<int>>& adj, int root) {
int n = adj.size();
vector<int> parents(n, -1);
stack<pair<int, int>> st;
st.emplace(root, -1);
while (!st.empty()) {
int node = st.top().first;
parents[node] = st.top().second;
st.pop();
for (int i : adj[node]) {
if (i != parents[node]) {
st.emplace(i, node);
}
}
}
return parents;
}
vector<vector<int>> get_children(const vector<int>& parents) {
int n = parents.size();
vector<vector<int>> children(n);
for (int i = 0; i < n; ++i) {
if (parents[i] >= 0) {
children[parents[i]].push_back(i);
}
}
return children;
}
vector<bool> solve_component(int n,
const vector<pair<pair<int, int>, int>>& queries) {
int n_queries = queries.size();
vector<bool> ans(n_queries, false);
vector<int> edge_indices;
DSU dsu(n);
vector<int> remaining;
for (int qi = 0; qi < n_queries; ++qi) {
int u = queries[qi].first.first;
int v = queries[qi].first.second;
if (dsu.find(u) != dsu.find(v)) {
ans[qi] = true;
edge_indices.push_back(qi);
dsu.join(u, v);
} else {
remaining.push_back(qi);
}
}
assert(int(edge_indices.size()) == (n - 1));
vector<vector<int>> adj(n);
for (int i : edge_indices) {
const pair<int, int>& edge = queries[i].first;
adj[edge.first].push_back(edge.second);
adj[edge.second].push_back(edge.first);
}
vector<int> parents = get_parents(adj, 0);
vector<int> cumxor(n, 0);
for (int i : edge_indices) {
const pair<int, int>& edge = queries[i].first;
if (parents[edge.first] == edge.second) {
cumxor[edge.first] = queries[i].second;
} else {
cumxor[edge.second] = queries[i].second;
}
}
vector<vector<int>> children = get_children(parents);
vector<int> q(1, 0);
for (int i = 0; i < int(q.size()); ++i) {
if (parents[q[i]] >= 0) {
cumxor[q[i]] ^= cumxor[parents[q[i]]];
}
q.insert(q.end(), children[q[i]].begin(), children[q[i]].end());
}
HLD<true> hld(adj);
for (int qi : remaining) {
int u = queries[qi].first.first;
int v = queries[qi].first.second;
int x = queries[qi].second;
if (((cumxor[u] ^ cumxor[v] ^ x) != 1) || (hld.queryPath(u, v) > 0)) {
ans[qi] = false;
continue;
}
ans[qi] = true;
hld.modifyPath(u, v, 1);
}
return ans;
}
vector<bool> solve(int n, const vector<int>& u, const vector<int>& v,
const vector<int>& x) {
int q = u.size();
DSU dsu(n);
for (int i = 0; i < q; ++i) {
dsu.join(u[i], v[i]);
}
vector<int> component_map(n, -1);
vector<vector<int>> components;
int n_components = 0;
for (int i = 0; i < n; ++i) {
int compi = dsu.find(i);
if (component_map[compi] < 0) {
component_map[compi] = n_components++;
components.emplace_back();
}
int j = component_map[compi];
components[j].push_back(i);
}
vector<vector<int>> queries_by_component(n_components);
for (int i = 0; i < q; ++i) {
queries_by_component[component_map[dsu.find(u[i])]].push_back(i);
}
vector<bool> ans(q);
vector<int> vertex_map(n, -1);
for (int compi = 0; compi < n_components; ++compi) {
vector<pair<pair<int, int>, int>> queries;
int compn = components[compi].size();
for (int i = 0; i < compn; ++i) {
vertex_map[components[compi][i]] = i;
}
for (int i : queries_by_component[compi]) {
queries.emplace_back(make_pair(vertex_map[u[i]], vertex_map[v[i]]), x[i]);
}
vector<bool> comp_ans = solve_component(compn, queries);
for (int i = 0; i < int(queries_by_component[compi].size()); ++i) {
ans[queries_by_component[compi][i]] = comp_ans[i];
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> u(q), v(q), x(q);
for (int i = 0; i < q; ++i) {
cin >> u[i] >> v[i] >> x[i];
--u[i];
--v[i];
}
vector<bool> ans = solve(n, u, v, x);
for (int i = 0; i < q; ++i) {
cout << (ans[i] ? "YES" : "NO") << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
bool chmin(T& x, const T& y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T>
bool chmax(T& x, const T& y) {
if (x < y) {
x = y;
return true;
}
return false;
}
auto random_address = [] {
char* p = new char;
delete p;
return (uint64_t)p;
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
int main(int, char**) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
while (cin >> s) {
int n = s.size();
vector<int> a(n + 2, 0);
for (int i = 0; i < n; ++i) {
a[i] = s[i] - 'a' + 1;
}
int m = 1;
while ((1 << m) <= n) {
m += 1;
}
const int P = 29;
vector<unsigned long long> p(n + 1);
p[0] = 1;
for (int i = 1; i <= n; ++i) {
p[i] = p[i - 1] * P;
}
auto hsh = vector<vector<unsigned long long> >(
n + 1, vector<unsigned long long>(m, 0));
auto nxt = vector<vector<int> >(n + 1, vector<int>(m, n));
auto len = vector<int>(n + 1, 0);
auto jmp = vector<int>(n + 1, 0);
iota((jmp).begin(), (jmp).end(), 0);
auto cmp = [&](int x, int y) {
x = jmp[x];
y = jmp[y];
for (int i = m - 1; i >= 0; --i) {
if (hsh[x][i] == hsh[y][i]) {
x = nxt[x][i];
y = nxt[y][i];
}
}
return a[x] < a[y];
};
auto upd = [&](int x, int v) {
v = jmp[v];
len[x] = len[v] + 1;
hsh[x][0] = a[x];
nxt[x][0] = v;
for (int i = 1; i < m; ++i) {
int y = nxt[x][i - 1];
nxt[x][i] = nxt[y][i - 1];
hsh[x][i] = hsh[x][i - 1] * p[1 << (i - 1)] + hsh[y][i - 1];
}
};
for (int i = n - 1; i >= 0; --i) {
upd(i, i + 1);
if (i + 1 < n && a[i] == a[i + 1] && cmp(i + 2, i)) {
jmp[i] = jmp[jmp[i + 2]];
len[i] = len[jmp[i]];
}
}
for (int i = 0; i < n; ++i) {
cout << len[i] << " ";
int x = jmp[i];
for (int j = 0, limit = len[i] <= 10 ? len[i] : 5; j < limit;
++j, x = nxt[x][0]) {
cout << s[x];
}
if (len[i] > 10) {
int d = len[i] - 5 - 2;
for (int i = m - 1; i >= 0; --i) {
if ((1 << i) <= d) {
d -= 1 << i;
x = nxt[x][i];
}
}
cout << "...";
for (int j = 0; j < 2; ++j, x = nxt[x][0]) {
cout << s[x];
}
}
cout << "\n";
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int n;
cin >> n;
int cnt[n];
for (int i = 0; i < n; i++) cin >> cnt[i];
sort(cnt, cnt + n);
int j = 0;
int count = 0;
for (int i = n - 1; i >= j; i--) {
int sum = cnt[i];
while (i > j && sum + cnt[j] <= 4) sum += cnt[j++];
count++;
}
cout << count << endl;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
#define f for(int i = 1; i <= n; i++)
using namespace std;
const int N = 2e5 + 5;
int a[N], b[N], c[N];
void solve(){
int n; cin >> n;
for(int i = 1; i <= n; i++) cin >> c[i], a[i] = b[i] = 0;
int p = 1;
f {
if(c[i] != c[i - 1]) a[c[i]] = 1, cout << c[i] << " ";
else{
while(a[p]) ++p;
a[p] = 1; cout << p << " ";
}
}
cout << "\n";
int top = 0;
f{
if(c[i] != c[i - 1]){
cout << c[i] << " ";
for(int j = c[i - 1] + 1; j < c[i]; j++) b[++top] = j;
}
else cout << b[top--] << " ";
}
cout << "\n";
return ;
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t; cin >> t;
while(t--){
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e5 + 5;
priority_queue<ll, vector<ll>, greater<ll> > g[66];
int cal(ll x) {
int res = 0;
while (x) {
res++;
x >>= 1;
}
return res - 1;
}
ll ans[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
ll t;
cin >> t;
g[cal(t)].push(t);
}
ll sum = 0;
int L = 0;
for (int i = 1; i <= n; i++) {
bool f = 0;
for (int k = 0; k <= 61; k++) {
if (!(sum & (1ll << k)) && g[k].size()) {
ans[++L] = g[k].top();
sum ^= ans[L];
g[k].pop();
f = 1;
break;
}
}
if (!f) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (auto &x : v) {
cin >> x;
};
long long int len = 1;
len += v[0];
for (long long int i = 1; i < n; i++) {
if (v[i] == 0 && v[i - 1] == 0) {
len = -1;
break;
}
if (v[i] > 0 && v[i - 1] > 0) {
len += 5;
} else if (v[i] > 0) {
len++;
}
}
cout << len << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int _ = 0;
cin >> _;
while (_--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r, i;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
int a, b;
cin >> a >> b;
int X, Y, g;
double B;
for (int x = 1; x <= a - 1; x++) {
int y = sqrt(a * a - x * x);
if (y * y - (a * a - x * x) == 0) {
g = gcd(x, y);
X = -(y / g);
Y = (x / g);
B = sqrt(X * X + Y * Y);
if (b % (int)B == 0) {
if (Y * (b / B) != y) {
cout << "YES\n";
cout << 0 << " " << 0 << endl;
cout << x << " " << y << endl;
cout << X * (b / B) << " " << Y * (b / B) << endl;
return 0;
}
}
}
}
cout << "NO\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, m, w, i = 0, j = 0;
cin >> n;
if (n == 0 || n == 1) {
cin >> x >> y;
cout << "-1" << endl;
}
int v[4][2];
for (i = 0; i < n; ++i)
for (j = 0; j < 2; ++j) cin >> v[i][j];
if (n == 2) {
if (v[0][0] == v[1][0] || v[1][1] == v[0][1])
cout << "-1" << endl;
else {
int a = v[1][0] - v[0][0];
int b = v[1][1] - v[0][1];
int s = a * b;
if (s > 0)
cout << s << endl;
else
cout << s * -1 << endl;
}
}
if (n == 3 || n == 4) {
for (i = 0; i < n; ++i)
for (j = i + 1; j < n; ++j)
if (v[i][0] == v[j][0]) m = v[i][1] - v[j][1];
for (int g = 0; g < n; ++g)
for (int h = g + 1; h < n; ++h)
if (v[g][1] == v[h][1]) w = v[g][0] - v[h][0];
int k = m * w;
if (k == 0) cout << "-1" << endl;
if (k > 0) cout << k << endl;
if (k < 0) cout << k * -1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int k = 1, mx = 1;
for (int i = 0; i < n; i++) {
if (i == 0) continue;
if (arr[i] != arr[i - 1]) {
k++;
} else {
if (k > mx) {
mx = k;
}
if (k % 2) {
for (int j = i - k; j < i; j++) {
arr[j] = arr[i - k];
}
} else {
for (int j = i - k; j < i; j++) {
if (j < i - (k / 2)) {
arr[j] = arr[i - k];
} else {
arr[j] = arr[i - 1];
}
}
}
k = 1;
}
}
if (k > mx) {
mx = k;
}
if (k % 2) {
for (int j = n - k; j < n; j++) {
arr[j] = arr[n - k];
}
} else {
for (int j = n - k; j < n; j++) {
if (j < n - (k / 2)) {
arr[j] = arr[n - k];
} else {
arr[j] = arr[n - 1];
}
}
}
cout << (mx - 1) / 2 << "\n";
for (int i = 0; i < n; i++) {
cout << arr[i];
if (i != n - 1) {
cout << " ";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
long long n, num[200005], bit[200005] = {0};
void modify(long long index, long long v) {
long long i;
for (i = index; i <= n; i += i & -i) bit[i] += v;
}
long long query(long long index) {
long long i, ans = 0;
for (i = index; i; i -= i & -i) ans += bit[i];
return ans;
}
int main() {
long long i, j, q, a, b;
scanf("%lld%lld", &n, &q);
for (i = 1; i <= n; i++) scanf("%lld", &num[i]);
for (i = 1; i <= n; i++)
for (j = i; j <= n; j += j & -j) bit[j] += num[i];
while (q--) {
scanf("%lld%lld", &a, &b);
modify(a, b - num[a]);
num[a] = b;
long long l = 1, val = query(1);
bool check = 0;
if (!num[1]) {
puts("1");
continue;
}
while (l <= n) {
long long left = l - 1, right = n + 1, mid;
while (right - left > 1) {
mid = (left + right) / 2;
if (query(mid) < val * 2)
left = mid;
else
right = mid;
}
if (query(right) == 2 * query(right - 1)) {
check = 1;
printf("%lld\n", right);
break;
}
val = query(right);
l = right;
}
if (!check) puts("-1");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, cnt;
int main() {
;
ios::sync_with_stdio(false);
cin.tie(0);
;
string s;
cin >> s;
long long ans = s.size();
sort(s.begin(), s.end());
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1])
cnt++;
else
ans += cnt * (cnt + 1), cnt = 0;
}
ans += cnt * (cnt + 1);
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxa = 55;
const int Maxb = 615;
const int Maxc = 615;
const int nil = 305;
const int Inf = 1000000000;
struct pos {
int x, y, z;
pos(int x = 0, int y = 0, int z = 0): x(x), y(y), z(z) {}
bool operator <(const pos &u) const {
if (x != u.x) return x < u.x;
if (y != u.y) return y < u.y;
return z < u.z;
}
};
typedef pair <int, pos> ip;
string s;
int dist[Maxa][Maxb][Maxc];
int main()
{
cin >> s;
reverse(s.begin(), s.end());
s += "000";
fill((int*)dist, (int*)dist + Maxa * Maxb * Maxc, Inf);
dist[int(s.length()) - 1][nil][nil] = 0;
priority_queue <ip> Q;
Q.push(ip(0, pos(int(s.length()) - 1, nil, nil)));
while (!Q.empty()) {
pos v = Q.top().second;
int d = -Q.top().first; Q.pop();
if (dist[v.x][v.y][v.z] != d) continue;
if (v.x == 0 && v.y == nil) { printf("%d\n", d); return 0; }
pos u;
if (v.x > 0) {
u = pos(v.x - 1, nil + (v.y - nil) * 10 + int(s[v.x - 1] - '0') - (v.z - nil), v.z);
if (0 <= u.x && 0 <= u.y && u.y < Maxb)
if (d < dist[u.x][u.y][u.z]) {
dist[u.x][u.y][u.z] = d;
Q.push(ip(-d, u));
}
}
u = pos(v.x, v.y + 1, v.z - 1);
int cand = d + v.x + 1;
if (0 <= u.y && u.y < Maxb && 0 <= u.z && u.z < Maxc)
if (cand < dist[u.x][u.y][u.z]) {
dist[u.x][u.y][u.z] = cand;
Q.push(ip(-cand, u));
}
u = pos(v.x, v.y - 1, v.z + 1);
cand = d + v.x + 1;
if (0 <= u.y && u.y < Maxb && 0 <= u.z && u.z < Maxc)
if (cand < dist[u.x][u.y][u.z]) {
dist[u.x][u.y][u.z] = cand;
Q.push(ip(-cand, u));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k, a;
set<int> s;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a;
s.insert(a);
}
if (s.size() > k) {
cout << "-1\n";
} else {
cout << n * k << endl;
for (int i = 0; i < n; i++) {
for (int b : s) cout << b << " ";
for (int j = 0; j < k - (int)s.size(); j++) {
cout << 1 << " ";
}
}
cout << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct P {
string name;
int a, h;
bool operator<(const P &b) const { return a < b.a; }
};
P p[5005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> p[i].name >> p[i].a;
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
if (p[i].a > i) {
puts("-1");
return 0;
}
p[i].h = i - p[i].a;
for (int j = 0; j < i; j++)
if (p[j].h >= p[i].h) {
p[j].h++;
}
}
for (int i = 0; i < n; i++) {
cout << p[i].name << " " << (p[i].h + 1) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const long long INFINITE = (long long)1e15;
vector<pair<int, int> > e[MAXN];
vector<pair<int, long long> > e2[MAXN];
long long cost[MAXN][MAXN];
int n, m, x, y, u, v, w;
bool visit[MAXN];
long long d[MAXN];
void gao(int st, int le, int cs) {
for (int i = 0; i < n; ++i) d[i] = INFINITE;
priority_queue<pair<long long, int> > q;
d[st] = 0;
for (int i = 0; i < n; ++i) visit[i] = 0;
q.push(make_pair(-d[st], st));
while (!q.empty()) {
u = q.top().second;
q.pop();
if (visit[u]) continue;
if (d[u] > le) return;
cost[st][u] = min(cost[st][u], (long long)cs);
if (u != st) e2[st].push_back(make_pair(u, cost[st][u]));
visit[u] = true;
for (int i = 0; i < e[u].size(); i++) {
v = e[u][i].first;
w = e[u][i].second;
if (d[u] + w < d[v]) {
d[v] = d[u] + w;
q.push(make_pair(-d[v], v));
}
}
}
}
long long dijkstra(int st, int ed) {
for (int i = 0; i < n; ++i) d[i] = INFINITE;
priority_queue<pair<long long, int> > q;
d[st] = 0;
for (int i = 0; i < n; ++i) visit[i] = 0;
q.push(make_pair(-d[st], st));
while (!q.empty()) {
u = q.top().second;
q.pop();
if (visit[u]) continue;
if (u == ed) return d[ed];
visit[u] = true;
for (int i = 0; i < e2[u].size(); i++) {
v = e2[u][i].first;
long long w = e2[u][i].second;
if (d[u] + w < d[v]) {
d[v] = d[u] + w;
q.push(make_pair(-d[v], v));
}
}
}
return -1;
}
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
--x;
--y;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &u, &v, &w);
--u;
--v;
e[u].push_back(make_pair(v, w));
e[v].push_back(make_pair(u, w));
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) cost[i][j] = INFINITE;
cost[i][i] = 0;
}
int t, c;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &t, &c);
gao(i, t, c);
}
cout << dijkstra(x, y) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long INF = 1e18;
const long long inf = -1e18;
const long long MOD = 1e9 + 7;
const long long base = 1000 * 1000 * 1000;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void solve() {
int n, m;
string s;
cin >> n >> m >> s;
if (n == 1 && m >= 1) {
cout << 0;
return;
}
if (m > 0) {
if (s[0] != '1') {
s[0] = '1';
m--;
}
}
for (int i = 1; i < s.size(); ++i) {
if (s[i] - '0' > 0 && m > 0) {
s[i] = '0';
m--;
}
}
cout << s;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-7;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, -1, 1, 0};
long long power(long long x, long long y) {
long long ans = 1;
x = x;
while (y > 0) {
if (y & 1) ans = (ans * x);
y = y >> 1;
x = (x * x);
}
return ans;
}
long long sqr(long long x) { return x * x; }
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <class T>
inline void chmax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void chmin(T &x, T y) {
x = min((x), (y));
}
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <typename T>
T powm(T a, T b, long long m) {
T cnt = 1;
while (b > 0) {
if (b % 2 == 1) cnt = (cnt * a) % m;
b /= 2;
a = (a * a) % m;
}
return cnt % m;
}
long long ncr(long long n, long long r) {
long long ans = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
ans *= (n - i);
ans /= (i + 1);
}
return ans;
}
const int MOD = 1000000007;
const int N = 200005;
struct compare {
bool operator()(const int &a, const int &b) const { return a > b; }
};
void prec() {}
void run() {
int n, m;
cin >> n >> m;
vector<bool> vis(3 * n);
vector<int> res;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
if (!vis[u] && !vis[v]) {
res.push_back(i + 1);
vis[u] = vis[v] = true;
}
}
if (res.size() >= n) {
cout << "Matching\n";
for (int i = 0; i < n; i++) {
cout << res[i] << " ";
}
cout << "\n";
} else {
cout << "IndSet\n";
int j = 0;
for (int i = 0; i < n; i++) {
while (vis[j]) j++;
cout << j + 1 << " ";
vis[j] = true;
}
cout << "\n";
}
}
int32_t main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int tc = 1;
cin >> tc;
prec();
for (long long i = 0; i < tc; ++i) run();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MAX = 110;
int cur = 0, vis[MAX], prime[MAX], state[MAX];
vector<int> C;
int dp[MAX][1 << 17], a[MAX], b[MAX], n, res[MAX][1 << 17];
void init() {
for (int i = 2; i < MAX; i++) {
if (!vis[i]) prime[cur++] = i;
for (int j = i; j < MAX; j += i) vis[j] = 1;
}
memset(state, 0, sizeof(state));
for (int i = 2; i < 70; i++) {
for (int j = 0; j < 18; j++) {
if (i % prime[j] == 0) state[i] |= (1 << j);
}
}
}
int dfs(int pos, int s) {
if (pos > n) return 0;
if (~dp[pos][s]) return dp[pos][s];
int ans = inf;
for (int i = 1; i < 60; i++) {
if (s & state[i]) continue;
int t = dfs(pos + 1, s | state[i]) + abs(i - a[pos]);
if (ans > t) {
ans = t;
res[pos][s] = i;
}
}
return dp[pos][s] = ans;
}
int main() {
init();
while (scanf("%d", &n) == 1) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(dp, -1, sizeof(dp));
dfs(1, 0);
int s = 0;
for (int i = 1; i <= n; i++) {
C.push_back(res[i][s]);
int k = res[i][s];
s = s | (state[k]);
}
for (int i = 0; i < C.size(); i++) {
printf("%d ", C[i]);
}
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, cu = 1, nu, p;
cin >> n;
long long temp = n;
for (i = 1;; i++) {
nu = (pow(10, i) - pow(10, i - 1)) * cu;
if (temp - nu >= 0)
temp -= nu;
else
break;
cu++;
}
cu = temp / i;
if (cu == 0)
p = pow(10, i - 1);
else
p = pow(10, i - 1) + cu;
temp %= i;
if (temp == 0) p--;
string s = to_string(p);
if (temp == 0)
cout << s[s.size() - 1];
else
cout << s[temp - 1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
int a[100010];
a[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (i > 1) a[i] += a[i - 1];
}
int s = 1, ans = 0;
for (int e = 1; e <= n; e++) {
if (a[e] - a[s - 1] <= t && e - s + 1 > ans)
ans = e - s + 1;
else
++s;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool equal(string a, string b) {
for (int o = 0; o <= 3; ++o) {
bool same = true;
for (int i = 0; i < 4; ++i) {
if (a[i] != b[i]) {
same = false;
break;
}
}
if (same) return true;
string c = a;
a[0] = c[2];
a[1] = c[0];
a[2] = c[3];
a[3] = c[1];
}
return false;
}
int main() {
int n;
cin >> n;
vector<string> amulets(n);
for (int i = 0; i < n; ++i) {
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
string s = s1 + s2;
amulets[i] = s;
}
vector<string> piles;
for (int i = 0; i < n; ++i) {
string s = amulets[i];
bool found = false;
for (int j = 0; j < piles.size(); ++j) {
if (equal(s, piles[j])) {
found = true;
break;
}
}
if (!found) piles.push_back(s);
}
cout << piles.size() << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1010;
int n;
bool flag[NMAX];
int main() {
scanf("%d", &n);
int a = 1, b = 1, c;
flag[1] = true;
while (true) {
c = a + b;
if (c >= NMAX) break;
a = b;
b = c;
flag[b] = 1;
}
for (int i = 1; i <= n; i++) {
if (flag[i])
printf("O");
else
printf("o");
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
pair<int, int> p[N][2];
bool check(bool b) {
map<int, vector<int>> add, rem;
set<int> st;
multiset<int> s, e;
for (int i = 0; i < n; i++) {
add[p[i][b].first].push_back(i);
rem[p[i][b].second].push_back(i);
st.insert(p[i][b].first);
st.insert(p[i][b].second);
}
for (auto i : st) {
for (auto j : add[i]) {
s.insert(-p[j][!b].first);
e.insert(p[j][!b].second);
}
for (auto j : add[i]) {
int mn = *e.begin(), mx = -(*s.begin());
if (p[j][!b].first > mn || p[j][!b].second < mx) {
return 0;
}
}
for (auto j : rem[i]) {
s.erase(-p[j][!b].first);
e.erase(p[j][!b].second);
}
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i][0].first >> p[i][0].second >> p[i][1].first >> p[i][1].second;
}
if (check(1) && check(0)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string grid[55];
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = (0); i <= ((n)-1); i++) cin >> grid[i];
int up = 111, left = 111, down = -1, right = -1;
for (int i = (0); i <= ((n)-1); i++)
for (int j = (0); j <= ((n)-1); j++)
if (grid[i][j] == '4') {
up = min(up, i);
down = max(down, i);
left = min(left, j);
right = max(right, j);
}
if (down < 0) {
cout << "No";
return 0;
}
for (int i = (0); i <= ((n)-1); i++)
for (int j = (0); j <= ((n)-1); j++) {
if (i >= up && i <= down && j >= left && j <= right) {
if (grid[i][j] != '4') {
cout << "No";
return 0;
}
} else if (i == up - 1 && j >= left && j <= right ||
i == down + 1 && j >= left && j <= right ||
j == left - 1 && i >= up && i <= down ||
j == right + 1 && i >= up && i <= down) {
if (grid[i][j] != '2') {
cout << "No";
return 0;
}
} else if (i == up - 1 && (j == left - 1 || j == right + 1) ||
i == down + 1 && (j == left - 1 || j == right + 1)) {
if (grid[i][j] != '1') {
cout << "No";
return 0;
}
} else if (grid[i][j] != '0') {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100003;
int n, d;
int a[MaxN];
long long pre[MaxN], f[MaxN];
int ans;
long long s;
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) {
pre[i] = pre[i - 1] + a[i];
if (pre[i] > d) return puts("-1"), 0;
}
f[n] = pre[n];
for (int i = n - 1; i >= 1; --i) f[i] = max(pre[i], f[i + 1]);
for (int i = 1; i <= n; ++i) f[i] = d - f[i];
ans = 0, s = 0;
for (int i = 1; i <= n; ++i)
if (a[i] == 0 && pre[i] + s < 0) {
ans++;
s = f[i];
if (pre[i] + s < 0) return puts("-1"), 0;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int max_n = 1000, max_m = 1000, max_k = 1000;
int n, m, k[max_m], c[max_m][max_k];
std::vector<int> values;
int count_must_be_chosen[max_m];
bool has_value_may_be_chosen[max_m];
double C[max_m + 1][max_m + 1], f[max_m][max_m + 1];
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n >> m;
for (int i = 0; i < m; i++) {
std::cin >> k[i];
for (int j = 0; j < k[i]; j++) {
std::cin >> c[i][j];
values.push_back(c[i][j]);
}
}
std::sort(values.begin(), values.end(), [](int a, int b) { return a > b; });
int value_may_be_chosen = values[n - 1];
std::memset(count_must_be_chosen, 0, sizeof count_must_be_chosen);
std::memset(has_value_may_be_chosen, false, sizeof has_value_may_be_chosen);
for (int i = 0; i < m; i++) {
for (int j = 0; j < k[i]; j++) {
if (c[i][j] > value_may_be_chosen) count_must_be_chosen[i]++;
if (c[i][j] == value_may_be_chosen) has_value_may_be_chosen[i] = true;
}
}
int size = (int)values.size(), may_be_chosen = 0, total_may_be_chosen = 0;
for (int i = 0; i < size; i++) {
if (values[i] == value_may_be_chosen) {
if (i < n) may_be_chosen++;
total_may_be_chosen++;
}
if (values[i] < value_may_be_chosen) break;
}
for (int i = 0; i <= max_k; i++) C[i][0] = C[i][i] = 1;
for (int i = 1; i <= max_k; i++)
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
for (int i = 0; i < m; i++) {
for (int j = 0; j <= may_be_chosen; j++) {
f[i][j] = (i > 0 ? f[i - 1][j] : (j > 0 ? 0 : 1)) /
C[k[i]][count_must_be_chosen[i]];
if (has_value_may_be_chosen[i] && j > 0)
f[i][j] += (i > 0 ? f[i - 1][j - 1] : (j == 1 ? 1 : 0)) /
C[k[i]][count_must_be_chosen[i] + 1];
}
}
std::cout << std::fixed << std::setprecision(9)
<< f[m - 1][may_be_chosen] / C[total_may_be_chosen][may_be_chosen]
<< '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class vertex {
public:
bool mark;
int comp;
vector<pair<int, bool>> to;
};
int n, k, m;
vertex f[2000];
int sz[2000];
int counter = 1;
int maxInv = 0;
bool checkComponent(int c) {
for (int i = 1; i <= n; i++) {
if (f[i].comp == c) {
for (int j = 0; j < f[i].to.size(); j++) {
if (f[f[i].to[j].first].comp == c && f[i].to[j].second == false)
return false;
}
}
}
return true;
}
void dfs(int v) {
f[v].mark = true;
f[v].comp = counter;
sz[counter]++;
for (auto w : f[v].to) {
if (w.second == 1 && f[w.first].mark == false) {
dfs(w.first);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
int a, b;
for (int i = 0; i <= k - 1; i++) {
cin >> a >> b;
f[a].to.push_back({b, 1});
f[b].to.push_back({a, 1});
}
cin >> m;
for (int i = 0; i <= m - 1; i++) {
cin >> a >> b;
f[a].to.push_back({b, 0});
f[b].to.push_back({a, 0});
}
for (int i = 1; i <= n; i++) {
if (f[i].mark == false) {
dfs(i);
counter++;
}
}
int compN = counter - 1;
for (int i = 1; i <= compN; i++) {
if (checkComponent(i)) {
if (sz[i] > maxInv) maxInv = sz[i];
}
}
cout << maxInv;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ex_gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0 && b == 0) return -1;
if (b == 0) {
x = 1ll;
y = 0;
return a;
}
long long temp = ex_gcd(b, a % b, y, x);
y -= a / b * x;
return temp;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long A, B, C;
cin >> A >> B >> C;
C = -C;
long long xx, yy;
long long d = ex_gcd(A, B, xx, yy);
if (C % d)
cout << -1 << endl;
else {
long long bei = C / d;
cout << bei * xx << " " << bei * yy << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool sbs = false;
bool break1;
string str, str1, zxc, final1, final2;
long long t, iman, len;
long long first;
long long last;
long long n1, n2, n3;
long long m1, m2, m3, n, m;
long long all = 0, l, l1, l2;
long double x;
long long z, z1, xx;
void fex(unsigned long long x, unsigned long long y) {
all = x;
z = 0;
if (x % 2 == 0) {
all += (2 * y);
} else if (x % 3 == 0) {
all += 3;
all += (2 * (y - 1));
} else if (x % 5 == 0) {
all += 5;
all += (2 * (y - 1));
} else if (x % 7 == 0) {
all += 7;
all += (2 * (y - 1));
} else {
all *= 2;
all += (2 * (y - 1));
}
cout << all << endl;
}
int main() {
cin >> n;
while (n--) {
z = 2;
cin >> n1 >> n2;
all = n1;
if (n1 % 2 == 0) {
z = 2;
} else {
for (long long int i = 3; i * i <= n1; i += 2) {
if (n1 % i == 0) {
z = i;
break;
}
}
}
if (z == 0 || n1 % z != 0) z = n1;
all += z;
all += (2 * (n2 - 1));
cout << all << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << "," << a.second << ")";
}
template <class A>
ostream &operator<<(ostream &out, const vector<A> &a) {
for (const A &it : a) out << it << " ";
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
return in >> a.first >> a.second;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &i : a) in >> i;
return in;
}
ifstream cinn("in.txt");
ofstream coutt("out.txt");
long long poww(const long long &a, long long b,
const long long &m = 1000000007) {
if (b == 0) return 1;
long long first = poww(a, b / 2, m);
first = first * first % m;
if (b & 1) first = first * a % m;
return first;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool xx(long long a, long long li) {
if (a >= 0 && a < li) return true;
return false;
}
long long pw(long long a, long long b, long long p) {
if (b == 0) return 1;
long long t = pw(a, b / 2, p);
if (b % 2)
return (((a * t) % p) * t) % p;
else
return ((t * t) % p);
}
const long long N = 1e6;
vector<long long> prime;
bool ok = false;
vector<bool> isprime(N + 1);
vector<long long> adj[N];
void sieve() {
for (long long i = 2; i <= N; i++) isprime[i] = true;
isprime[0] = isprime[1] = false;
for (long long i = 2; i * i <= N; i++) {
if (isprime[i]) {
for (long long j = i * i; j <= N; j += i) {
isprime[j] = false;
}
}
}
for (long long i = 0; i <= N; i++) {
if (isprime[i]) {
prime.push_back(i);
}
}
}
long long f = 0;
long long dp[(long long)1e6 + 5];
void fun(long long n) {
if (n < 0) return;
if (n == 0) {
dp[n] = 1;
f = 1;
return;
}
if (dp[n] != -1) {
f = dp[n];
return;
}
dp[n] = f;
fun(n - 2020);
dp[n] = f;
fun(n - 2021);
dp[n] = f;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, c, m, h, a, b, k, f1, f2, t1, t2, i, j, ans = 0, d;
cin >> n >> m;
c = 0;
for (i = 0; i < 61; i++) {
h = 1LL << i;
h--;
for (j = 0; j < i - 1; j++) {
k = 1LL << j;
f = h ^ k;
if (f >= n && f <= m) {
c++;
}
}
}
cout << c << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)(1e5 + 1e1);
const double PI = acos(-1.0);
long long n, ans, q[MAXN], w[MAXN], z, x, c;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> q[i] >> w[i];
}
sort(q + 1, q + n + 1);
sort(w + 1, w + n + 1);
z = max((abs(q[n] - q[1])), (abs(w[n] - w[1])));
cout << ((z) * (z));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int ms = 1005;
int n, k;
int a[ms], dp[ms][ms];
int solve(int x) {
dp[0][0] = 1;
int li = 0;
for (int i = 1; i <= n; ++i) {
while (a[i] - a[li + 1] >= x) li++;
dp[i][0] = dp[i - 1][0];
for (int j = 1; j <= k && j <= i; ++j) {
dp[i][j] = dp[i - 1][j] + dp[li][j - 1];
dp[i][j] %= mod;
}
}
return dp[n][k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i * (k - 1) <= a[n]; i++) {
ans = ans + solve(i);
ans %= mod;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> p(n, 0);
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
p[i] = aux - 1;
}
vector<long long int> dp(n + 1, 0);
for (int i = 1; i < n + 1; i++) {
dp[i] = (long long int)(dp[i - 1] * (long long int)2 - dp[p[i - 1]] + 2 +
1000000007) %
1000000007;
}
cout << dp[n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k;
cin >> n >> k;
vector<long long> arr(n);
for (auto &i : arr) cin >> i;
long long curr = 0, ans = n * (n - 1) / 2 + n, mx = (1 << k) - 1;
map<long long, long long> st = {{0, 1}};
for (auto i : arr) {
curr ^= i;
if (st[curr] > st[curr ^ mx]) curr ^= mx;
ans -= st[curr];
st[curr]++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int t, n, a[N], k, dif, ans;
int Get() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
int i, x;
bool jg;
t = Get();
while (t--) {
n = Get(), k = Get();
jg = 0;
dif = ans = 1;
for (i = 1; i <= n; i++) {
a[i] = Get();
if (i != 1 && x != a[i]) jg = 1, dif++;
x = a[i];
}
if (!jg) {
cout << "1\n";
continue;
}
if (k == 1 && jg) {
cout << "-1\n";
continue;
}
dif -= k;
k--;
ans += ceil((double)dif / k);
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
if (flag) x = -x;
}
using namespace std;
const int P = 1004535809;
const int base = 131;
inline long long quickpow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % P;
x = x * x % P;
k >>= 1;
}
return res;
}
int n, h[101000], K;
long long jzppw[101000 + 101000];
long long *pw = jzppw + 101000;
inline void init() {
const int ibase = quickpow(base, P - 2);
pw[0] = 1;
const int up = n;
for (int i = 1; i <= up; ++i) pw[i] = pw[i - 1] * base % P;
for (int i = -1; i >= -up; --i) pw[i] = pw[i + 1] * ibase % P;
}
struct Str {
long long ha;
int len;
Str() { ha = len = 0; }
Str(long long jzp, int zzz) { ha = jzp, len = zzz; }
inline bool operator==(const Str &a) const {
return ha == a.ha && len == a.len;
}
inline Str operator+(const Str &a) const {
return Str((ha * pw[a.len] + a.ha) % P, len + a.len);
}
inline Str operator-(const Str &a) const {
return Str(((ha - a.ha * pw[len - a.len]) % P + P) % P, len - a.len);
}
};
struct Data {
int ls, rs;
Str lb, rb;
bool isw;
Data() {
ls = rs = isw = 0;
lb = rb = Str();
}
} dat[101000 << 2];
Str query_R(int len, int cur) {
if (len == dat[cur].rb.len) return dat[cur].rb;
if (!len) return Str();
int l = dat[dat[cur].rs].rb.len;
if (l < len)
return dat[dat[cur].rs].rb +
(query_R(len - l + dat[dat[cur].rs].lb.len, dat[cur].ls) -
dat[dat[cur].rs].lb);
return query_R(len, dat[cur].rs);
}
Str query_L(int len, int cur) {
if (len == dat[cur].lb.len) return dat[cur].lb;
if (!len) return Str();
int l = dat[dat[cur].ls].lb.len;
if (l < len)
return dat[dat[cur].ls].lb +
(query_L(len - l + dat[dat[cur].ls].rb.len, dat[cur].rs) -
dat[dat[cur].ls].rb);
return query_L(len, dat[cur].ls);
}
inline void pushup(int cur) {
if (dat[dat[cur].ls].isw || dat[dat[cur].rs].isw)
return dat[cur].isw = true, void();
dat[cur].isw = false;
if (dat[dat[cur].ls].rb.len > dat[dat[cur].rs].lb.len) {
dat[cur].lb = dat[dat[cur].ls].lb;
Str str = query_R(dat[dat[cur].rs].lb.len, dat[cur].ls);
if (str == dat[dat[cur].rs].lb)
dat[cur].rb =
dat[dat[cur].rs].rb + (dat[dat[cur].ls].rb - dat[dat[cur].rs].lb);
else
dat[cur].isw = true;
} else {
dat[cur].rb = dat[dat[cur].rs].rb;
Str str = query_L(dat[dat[cur].ls].rb.len, dat[cur].rs);
if (str == dat[dat[cur].ls].rb)
dat[cur].lb =
dat[dat[cur].ls].lb + (dat[dat[cur].rs].lb - dat[dat[cur].ls].rb);
else
dat[cur].isw = true;
}
}
int root, ttot;
void build(int L, int R, int &cur) {
cur = ++ttot;
if (L == R)
return h[L] > 0 ? dat[cur].rb = Str(h[L], 1) : dat[cur].lb = Str(-h[L], 1),
void();
int mid = (L + R) >> 1;
build(L, mid, dat[cur].ls);
build(mid + 1, R, dat[cur].rs);
pushup(cur);
}
void modify(int L, int R, int pos, int v, int cur) {
if (L == R) {
dat[cur].lb = dat[cur].rb = Str();
v > 0 ? dat[cur].rb = Str(v, 1) : dat[cur].lb = Str(-v, 1);
return;
}
int mid = (L + R) >> 1;
if (pos <= mid)
modify(L, mid, pos, v, dat[cur].ls);
else
modify(mid + 1, R, pos, v, dat[cur].rs);
pushup(cur);
}
int stk[111], stop;
void dfs_get(int L, int R, int l, int r, int cur) {
if (l <= L && R <= r) return stk[++stop] = cur, void();
int mid = (L + R) >> 1;
if (l <= mid) dfs_get(L, mid, l, r, dat[cur].ls);
if (r > mid) dfs_get(mid + 1, R, l, r, dat[cur].rs);
}
Str seq[111];
Str query_jzp(int nw, int len) {
if (!len) return Str();
if (len == seq[nw].len) return seq[nw];
if (len <= dat[stk[nw]].rb.len) return query_R(len, stk[nw]);
return dat[stk[nw]].rb +
(query_jzp(nw - 1, len - dat[stk[nw]].rb.len + dat[stk[nw]].lb.len) -
dat[stk[nw]].lb);
}
inline bool Query(int l, int r) {
stop = 0;
dfs_get(1, n, l, r, root);
for (int i = 1; i <= stop; ++i) {
if (dat[stk[i]].isw) return false;
if (dat[stk[i]].lb.len > seq[i - 1].len) return false;
if (dat[stk[i]].lb == query_jzp(i - 1, dat[stk[i]].lb.len)) {
seq[i] = dat[stk[i]].rb + (seq[i - 1] - dat[stk[i]].lb);
} else
return false;
}
return seq[stop].len == 0;
}
int main() {
read(n);
read(K);
init();
for (int i = 1; i <= n; ++i) read(h[i]);
build(1, n, root);
int q;
read(q);
while (q--) {
int op;
read(op);
if (op == 1) {
int p, v;
read(p), read(v);
modify(1, n, p, v, root);
} else {
int l, r;
read(l), read(r);
puts(Query(l, r) ? "Yes" : "No");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
int n;
map<long long, int> mp;
set<long long> st;
long long res = 0;
void add(long long p) {
auto R = st.lower_bound(p);
auto L = --R;
R++;
int pL = 0, pR = 0;
if (mp.count(*R)) pR = mp[*R];
if (mp.count(*L)) pL = mp[*L];
if (pL && pL == pR) mp[p] = pL;
st.insert(p);
}
bool accept(long long p) {
auto it = st.lower_bound(p);
auto L = --it;
it++;
auto R = ++it;
it--;
int pL = 0, pR = 0;
if (mp.count(*R)) pR = mp[*R];
if (mp.count(*L)) pL = mp[*L];
if (pL && pL == pR) return false;
if (!mp.count(p)) res++;
while (!mp.count(*L)) {
mp[*L] = 1;
L--;
}
while (!mp.count(*R)) {
mp[*R] = 2;
R++;
}
st.erase(p);
mp.erase(p);
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
st.insert(-INF);
st.insert(INF);
mp[-INF] = 1;
mp[INF] = 2;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
long long p;
cin >> s >> p;
if (s == "ADD")
add(p);
else {
if (!accept(p)) {
cout << 0;
return 0;
}
}
}
long long ans = 1;
for (int i = 0; i < res; i++) ans = ans * 2 % MOD;
ans *= (st.size() - mp.size() + 1);
ans %= MOD;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 1 << 19;
int A[N], B[N], w[N], inv[N], len, len1, len2, pos[N], res[N], f[N], g[N];
void init() {
int op = len >> 1, k = N / len;
for (int i = 0, j = 0; i < len; ++i, j += k) {
w[i] = f[j];
inv[i] = g[j];
pos[i] = pos[i >> 1] >> 1 | (i & 1 ? op : 0);
}
}
void NTT(int *a, int *omg) {
for (int i = (0); i < (len); ++i)
if (i < pos[i]) swap(a[i], a[pos[i]]);
for (int i = 2; i <= len; i <<= 1) {
int m = i >> 1;
for (int *p = a; p != a + len; p += i) {
for (int j = (0); j < (m); ++j) {
int t = 1ll * omg[len / i * j] * p[j + m] % mod;
p[j + m] = p[j] - t;
if (p[j + m] < 0) p[j + m] += mod;
p[j] += t;
if (p[j] >= mod) p[j] -= mod;
}
}
}
}
int quick(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int a[N], n, k;
vector<int> quickNTT(int *a, int b, int l) {
len = l;
res[0] = 1;
for (int i = (1); i < (len); ++i) res[i] = 0;
init();
NTT(res, w);
NTT(a, w);
while (b) {
if (b & 1)
for (int i = (0); i < (len); ++i) res[i] = 1ll * res[i] * a[i] % mod;
for (int i = (0); i < (len); ++i) a[i] = 1ll * a[i] * a[i] % mod;
b >>= 1;
}
vector<int> g;
NTT(res, inv);
int lenni = quick(len, mod - 2);
for (int i = (0); i < (len); ++i) g.push_back(1ll * res[i] * lenni % mod);
return g;
}
int main() {
int num = quick(3, (mod - 1) / N), ni = quick(num, mod - 2);
f[0] = g[0] = 1;
for (int i = (1); i < (N); ++i)
f[i] = 1ll * f[i - 1] * num % mod, g[i] = 1ll * g[i - 1] * ni % mod;
scanf("%d%d", &n, &k);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
int cnt = 0;
for (int i = (0); i < (n); ++i)
if (a[i] ^ a[(i + 1) % n]) ++cnt;
A[0] = 1, A[1] = k - 2, A[2] = 1;
vector<int> g = quickNTT(A, cnt, N);
long long ans = 0;
for (int i = (0); i < (g.size()); ++i)
if (i > cnt) ans += g[i];
ans %= mod;
ans = ans * quick(k, n - cnt) % mod;
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int ara[a];
bool f = false;
for (int l = 0; l < a; l++) {
cin >> ara[l];
if (ara[l] > b) f = true;
}
if (f == false)
cout << a;
else {
int max = -1;
for (int l = 0; l < a; l++) {
if (ara[l] / b > max && ara[l] % b == 0) {
max = ara[l] / b;
} else if (ara[l] % b != 0) {
if (ara[l] / b + 1 > max) max = ara[l] / b + 1;
}
}
for (int l = a - 1; l >= 0; l--) {
if (max == (ara[l] / b) && ara[l] % b == 0) {
cout << l + 1;
break;
} else if (max == (ara[l] / b + 1) && ara[l] % b != 0) {
cout << l + 1;
break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a = 1000000, b = 0, d, q;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
if (i > 0) {
if (max(c, d) < a) {
a = max(c, d);
}
} else {
a = c;
}
d = c;
}
if (a > d)
cout << d << endl;
else
cout << a << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int T;
cin >> T;
for (int i = 0; i < T; i++) {
int N, M, K;
cin >> N >> M >> K;
if (M == 0) {
cout << "0\n";
} else if (M <= (N / K)) {
cout << M << endl;
} else {
if ((M - (N / K)) % (K - 1) == 0) {
cout << (N / K) - ((M - (N / K)) / (K - 1)) << endl;
} else {
cout << (N / K) - ((M - (N / K)) / (K - 1)) - 1 << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t, *a;
cin >> t;
while (t--) {
cin >> n;
a = new long long int[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int i = n / 2 - 1, j = n / 2;
if (n % 2 == 1) {
cout << a[j] << " ";
j++;
}
while (i >= 0) {
cout << a[i] << " " << a[j] << " ";
i--, j++;
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int mod = 1e9 + 7;
const int maxn = 20;
const int N = 2e5 + 100;
const int M = 3e5 + 10;
const long long mm = (1LL << 32);
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
x = f ? -x : x;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
T y = 1;
int len = 1;
for (; y <= x / 10; y *= 10) ++len;
for (; len; --len, x %= y, y /= 10) putchar(x / y + 48);
}
long long qpow(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return ans;
}
bool isprime(long long n) {
for (int i = 2; i <= sqrt(n + 0.5); ++i) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
if (isprime(n))
cout << 1;
else if (n % 2 == 0)
cout << 2;
else if (isprime(n - 2))
cout << 2;
else
cout << 3;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, r;
cin >> n >> r;
double x = acos(-1) / n;
double b = x / 2;
double c = acos(-1) - x - b;
double y = r * sin(b) / sin(c);
double z = y * sin(x);
double s = r * z * 0.5;
cout << fixed << setprecision(24) << s * 2 * n;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[50010];
int main() {
long long n;
long long sum = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long long t = 0;
long long aver = sum / n;
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += abs(t);
t += a[i] - aver;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9';) {
if (ch == '-') f = -1;
ch = getchar();
}
for (; ch >= '0' && ch <= '9';) {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
const int N = 2e5 + 5;
int n, a[N];
long long p[N], sum[N];
double go(int mid, int k) {
double ret = sum[n] - sum[n - k];
ret += sum[mid] - sum[mid - k - 1];
ret /= (2 * k + 1);
ret -= a[mid];
return ret;
}
int main() {
int i, j, k;
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + 1 + n);
sum[0] = 0;
int l = 1, r = 0;
double ret = -10;
for (i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
for (i = 2; i < n; ++i) {
k = 0;
for (j = 20; j >= 0; --j) {
k += 1 << j;
if (i > n - k || i - k - 1 < 0 || go(i, k) < go(i, k - 1)) k -= 1 << j;
}
if (ret < go(i, k)) {
ret = go(i, k);
l = i;
r = k;
}
}
printf("%d\n", 2 * r + 1);
for (i = l - r; i <= l; ++i) printf("%d ", a[i]);
for (i = n - r + 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> graph[N];
int store[N], ct[N], n;
void dfs(int v, int prev) {
ct[v] = 1;
for (int i = 0; i < graph[v].size(); i++) {
int u = graph[v][i];
if (graph[v][i] != prev) {
dfs(u, v);
if ((n - ct[u]) % 2 == 0 && ct[u] % 2 == 0) {
store[v]++;
}
store[v] += store[u];
ct[v] += ct[u];
}
}
}
int main() {
cin >> n;
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
if (n % 2 == 1) {
cout << "-1";
return 0;
} else {
dfs(1, 0);
cout << store[1];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
std::vector<std::pair<long long, long long>> answer;
std::set<std::pair<long long, long long>> tmp;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long x;
std::cin >> x;
long long X = (long long)x * (long long)6;
for (long long n = (long long)1; n <= (long long)3e6 + 7; ++n) {
if (X % n) continue;
if (X % (n + (long long)1)) continue;
long long m = n + (X / (n * (n + (long long)1))) - (long long)1;
if (m % (long long)3) continue;
if (m / 3 < n) continue;
tmp.insert({n, m / 3});
tmp.insert({m / 3, n});
}
for (auto it : tmp) answer.push_back(it);
std::cout << answer.size() << "\n";
std::sort(answer.begin(), answer.end());
for (auto it : answer) std::cout << it.first << " " << it.second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long a, b, k, ans, m;
for (int i = 0; i < t; i++) {
cin >> a >> b >> k;
m = k / 2;
ans = (a - b) * m;
ans += k % 2 == 0 ? 0 : a;
cout << ans << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3e5, mxSTS = 19 * mxN + 1;
int n, a[mxN], nxt[mxN], d[mxN];
int sts, lc[mxSTS], rc[mxSTS], v[mxSTS], rt[mxN];
void upd(int &i, int l1, int x, int l2 = 0, int r2 = n - 1) {
if (!i) {
i = sts++;
lc[i] = 0;
rc[i] = 0;
}
if (l2 == r2) {
v[i] = x;
return;
}
int m2 = (l2 + r2) / 2;
if (l1 <= m2)
upd(lc[i], l1, x, l2, m2);
else
upd(rc[i], l1, x, m2 + 1, r2);
}
int qry(int i, int l1, int l2 = 0, int r2 = n - 1) {
if (!i) return -1;
if (l2 == r2) return v[i];
int m2 = (l2 + r2) / 2;
if (l1 <= m2)
return qry(lc[i], l1, l2, m2);
else
return qry(rc[i], l1, m2 + 1, r2);
}
void solve() {
cin >> n;
long long ans = 0;
sts = 1;
for (int i = 0; i < n; ++i) {
cin >> a[i], --a[i];
nxt[i] = -1;
d[i] = 0;
rt[i] = 0;
if (i) {
int b = qry(rt[i - 1], a[i]);
if (~b) {
if (b > 0) {
rt[i] = rt[b - 1];
d[i] = d[b - 1];
}
++d[i];
}
}
upd(rt[i], a[i], i);
ans += d[i];
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const long double DEL = 1e-12;
const int mod = 1000000007;
const int LIM = 100005;
int fpow(int x, int n) {
int res = 1;
while (n) {
if (n & 1) {
res = res * x % mod;
}
x = x * x % mod;
n >>= 1;
}
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sieve(int n) {
bool prime[5 * LIM];
memset(prime, true, sizeof(prime));
int rootn = (int)sqrt(n);
for (int p = 2; p <= rootn; p++)
if (prime[p] == true)
for (int i = p * p; i <= n; i += p) prime[i] = false;
prime[1] = 0;
}
int cnt, sum, mid, mx, mn, a[3 * LIM];
int n, m, d, q, t, i, j, k, l, r, x, y, z;
bool f, f1, f2;
string s;
vector<vector<int>> v(3 * LIM);
vector<bool> vis(3 * LIM);
int boss, corner;
vector<int> ans(3 * LIM);
void dfs(int i, int len, int par) {
vis[i] = 1;
a[i] = boss;
if (len > l) {
corner = i;
l = len;
}
for (auto j : v[i]) {
if (j != par) {
dfs(j, (len + 1), i);
}
}
}
int bossof(int i) {
while (i != a[i]) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void unite(int x, int y) {
x = bossof(x);
y = bossof(y);
ans[x] = max(max(ans[x], ans[y]), 1 + (ans[x] + 1) / 2 + (ans[y] + 1) / 2);
a[y] = x;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
while (m--) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for ((i) = 1; (i) <= (n); (i)++) {
if (!vis[i]) {
boss = i;
l = -1;
dfs(i, 0, 0);
l = -1;
dfs(corner, 0, 0);
ans[i] = l;
}
}
while (q--) {
cin >> z;
if (z == 1) {
cin >> x;
cout << ans[bossof(x)];
cout << "\n";
} else {
cin >> x >> y;
if (bossof(x) != bossof(y)) {
unite(x, y);
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a;
map<string, string> gems;
map<string, string>::iterator it;
vector<string> data;
vector<string> data_need;
void need(int a) {
cout << 6 - data.size() << endl;
for (int k = 0; k < a; k++) {
if (data[k] == "red") {
it = gems.find("red");
if (it != gems.end()) gems.erase(it);
}
if (data[k] == "purple") {
it = gems.find("purple");
if (it != gems.end()) gems.erase(it);
}
if (data[k] == "yellow") {
it = gems.find("yellow");
if (it != gems.end()) gems.erase(it);
}
if (data[k] == "orange") {
it = gems.find("orange");
if (it != gems.end()) gems.erase(it);
}
if (data[k] == "blue") {
it = gems.find("blue");
if (it != gems.end()) gems.erase(it);
}
if (data[k] == "green") {
it = gems.find("green");
if (it != gems.end()) gems.erase(it);
}
}
for (it = gems.begin(); it != gems.end(); ++it) {
cout << it->second << endl;
}
}
int main() {
gems["purple"] = "Power";
gems["green"] = "Time";
gems["blue"] = "Space";
gems["orange"] = "Soul";
gems["red"] = "Reality";
gems["yellow"] = "Mind";
cin >> a;
for (int z = 0; z < a; z++) {
string temp;
cin >> temp;
data.push_back(temp);
}
need(a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int Me, He, M[100], H[100], DefPos;
bool att[100];
int barrima() {
sort(M, M + Me);
bool taken[100];
int totDestroyed = 0, totDamage = 0;
memset(taken, 0, sizeof taken);
for (int i = 0; i < He; i++) {
if (att[i]) continue;
for (int j = 0; j < Me; j++) {
if (taken[j]) continue;
if (M[j] <= H[i]) continue;
taken[j] = 1;
totDestroyed++;
break;
}
}
if (totDestroyed != DefPos) return 0;
for (int i = 0; i < He; i++) {
if (!att[i]) continue;
for (int j = 0; j < Me; j++) {
if (taken[j]) continue;
if (M[j] < H[i]) continue;
taken[j] = 1;
totDestroyed++;
totDamage += (M[j] - H[i]);
break;
}
}
if (totDestroyed != He) return 0;
for (int i = 0; i < Me; i++)
if (!taken[i]) totDamage += M[i];
return totDamage;
}
int KillHim() {
vector<int> v;
for (int i = 0; i < He; i++)
if (att[i]) v.push_back(H[i]);
sort(v.begin(), v.end());
sort(M, M + Me);
int Maxi = 0;
for (int K = 1; K <= v.size(); K++) {
int totKilled = 0, i = Me - 1, totDamage = 0;
while (totKilled++ != K) {
if (M[i] < v[totKilled - 1]) break;
totDamage += M[i] - v[totKilled - 1];
i--;
}
Maxi = max(Maxi, totDamage);
}
return Maxi;
}
int main() {
cin >> He >> Me;
for (int i = 0; i < He; i++) {
string s;
cin >> s >> H[i];
if (s == "ATK")
att[i] = 1;
else
DefPos++;
}
for (int i = 0; i < Me; i++) cin >> M[i];
cout << max(barrima(), KillHim()) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct pfx {
int s[3];
};
int operator-(pfx x, pfx y) {
int ret = 0;
for (int(i) = (0); (i) < (3); ++(i)) ret += max(0, x.s[i] - y.s[i]);
return ret;
}
const int maxn = 80;
const int inf = 1ll << 25;
int n, mn = inf, dp[maxn][maxn][maxn][3];
char s[maxn], t[maxn];
pfx vkx[3][maxn];
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n;
pfx tt;
tt.s[0] = tt.s[1] = tt.s[2] = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
char c;
int x;
cin >> c, x = (c == 'V' ? 0 : c == 'K' ? 1 : 2);
++tt.s[x], vkx[x][tt.s[x]] = tt;
}
for (int(v) = (0); (v) < (n + 1); ++(v))
for (int(k) = (0); (k) < (n + 1); ++(k))
for (int(x) = (0); (x) < (n + 1); ++(x))
for (int(i) = (0); (i) < (3); ++(i)) dp[v][k][x][i] = inf;
dp[0][0][0][2] = 0;
for (int(v) = (0); (v) < (n); ++(v))
for (int(k) = (0); (k) < (n); ++(k))
for (int(x) = (0); (x) < (n); ++(x)) {
if (v + k + x >= n) continue;
for (int(i) = (0); (i) < (3); ++(i))
for (int(j) = (0); (j) < (3); ++(j))
if (!(i == 0 && j == 1)) {
pfx nn;
nn.s[0] = v + (j == 0), nn.s[1] = k + (j == 1),
nn.s[2] = x + (j == 2);
if (nn.s[0] > tt.s[0] || nn.s[1] > tt.s[1] || nn.s[2] > tt.s[2])
continue;
dp[nn.s[0]][nn.s[1]][nn.s[2]][j] =
min(dp[nn.s[0]][nn.s[1]][nn.s[2]][j],
dp[v][k][x][i] + (nn - vkx[j][nn.s[j]]));
}
}
for (int(i) = (0); (i) < (3); ++(i))
mn = min(mn, dp[tt.s[0]][tt.s[1]][tt.s[2]][i]);
cout << mn;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
int t = x - y;
if (t + z > 0 && t - z > 0)
cout << "+";
else if (t + z < 0 && t - z < 0)
cout << "-";
else if (t + z == 0 && t - z == 0)
cout << "0";
else
cout << "?";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, s, d[400003], fact[400003], f, g, h, j, k, l, i, n, m,
mod = 1000000007;
pair<int, int> p[400002];
long long xar(long long a, long long b) {
int res = 1;
while (b) {
if (b % 2) res = (res * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return res;
}
long long cee(int n, int m) {
return (fact[n] * xar((fact[m] * fact[n - m]) % mod, mod - 2)) % mod;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
for (i = 0; i < n; i++) {
scanf("%d", &p[2 * i].first);
p[2 * i].second = i;
scanf("%d", &p[2 * i + 1].first);
p[2 * i + 1].first++;
p[2 * i + 1].second = i;
}
sort(p, p + 2 * n);
k = p[0].first;
d[p[0].second] = 1;
l++;
for (i = 1; i < 2 * n; i++) {
if (l >= m)
j = cee(l, m);
else
j = 0;
f = (f + j * (p[i].first - k) % mod) % mod;
if (d[p[i].second])
l--;
else
l++;
d[p[i].second] = 1;
k = p[i].first;
}
cout << f;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
char a, b;
cin >> s1 >> s2;
if (s1.length() != s2.length()) {
cout << "NO" << endl;
return 0;
}
int f1 = 0, f2 = 0;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] == '1') f1 = 1;
if (s2[i] == '1') f2 = 1;
}
if (f1 == f2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Matrix {
int a[20][20], n;
void clear(int _n = 0) { n = _n, memset(a, 0, sizeof(a)); }
Matrix(int _n = 0) { clear(_n); }
void unit() {
clear(n);
for (int i = 0; i < n; i++) a[i][i] = 1;
}
Matrix operator*(const Matrix &m) const {
Matrix res(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j])
for (int k = 0; k < n; k++)
res.a[i][k] = ((long long)a[i][j] * m.a[j][k] + res.a[i][k]) % MOD;
return res;
}
Matrix operator+(const Matrix &m) const {
Matrix res(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res.a[i][j] = (a[i][j] + m.a[i][j]) % MOD;
return res;
}
};
struct Vector {
Matrix mat[15];
int n;
void clear(int _n = 0, int _m = 0) {
n = _n;
for (int i = 0; i < n; i++) mat[i].clear(_m);
}
Vector(int _n = 0, int _m = 0) { clear(_n, _m); }
Vector operator*(const Vector &v) const {
Vector res(n, mat[0].n);
for (int i = 0; i < n; i++)
for (int j = 0; j <= i; j++)
res.mat[i] = res.mat[i] + mat[j] * v.mat[i - j];
return res;
}
} base, res;
int main() {
int n, K, m;
scanf("%d%d%d", &n, &K, &m);
base.clear(K + 1, 1 << m);
res.clear(K + 1, 1 << m);
res.mat[0].unit();
for (int i = 0; i < 1 << m; i++) {
base.mat[0].a[i][i >> 1] = 1;
base.mat[1].a[i][i >> 1 | 1 << m >> 1] = __builtin_popcount(i) + 1;
}
for (int b = n; b; b >>= 1) {
if (b & 1) res = res * base;
base = base * base;
}
int ans = 0;
for (int i = 0; i < 1 << m; i++) ans = (res.mat[K].a[0][i] + ans) % MOD;
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tab[n];
int s = 0, x, m = -1;
for (int i = 0; i < n; i++) {
cin >> x;
s += x;
m = max(m, x);
}
int i = m, c = n * i - s;
while (c <= s) {
i++;
c = n * i - s;
}
cout << i;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const bool OJ = true;
const long long inf = 1LL << 60;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (long long i = 0; i < (((long long)((v).size()))); i++) os << v[i] << " ";
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (long long i = 0; i < (((long long)((v).size()))); i++) is >> v[i];
return is;
}
template <class A, class B>
istream& operator>>(istream& is, tuple<A, B>& p) {
is >> get<0>(p) >> get<1>(p);
return is;
}
long long n, l;
vector<long long> a;
vector<double> p;
bool flg[205][205][205];
double dp[205][205][205];
double solve(long long i, long long won, long long bag) {
if (i == n) {
return won >= l && bag >= 0;
}
if (flg[i][won][bag]) return dp[i][won][bag];
flg[i][won][bag] = true;
double ans = 0;
if (a[i] == -1) {
ans = p[i] * solve(i + 1, won + 1, bag - 1) +
(1.0 - p[i]) * solve(i + 1, won, bag);
} else {
ans = p[i] * solve(i + 1, won + 1, min(200LL, bag + a[i])) +
(1.0 - p[i]) * solve(i + 1, won, bag);
}
return dp[i][won][bag] = ans;
}
void run() {
long long k;
cin >> n >> l >> k;
p = vector<double>(n);
for (long long i = 0; i < (n); i++) {
cin >> p[i];
p[i] *= 0.01;
}
a = vector<long long>(n);
cin >> a;
memset(flg, false, sizeof(flg));
cout << fixed << setprecision(9) << solve(0, 0, k) << endl;
}
int main(int argc, char* argv[]) {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, kecil, tamp1 = 0, tamp2 = 0, tambah = 0;
cin >> n;
cin >> m;
tamp1 = n;
tamp2 = m;
while (n != 0) {
n = tamp1;
if (tambah >= 1) m += tamp2;
if (m > n) {
cout << -1;
return 0;
}
for (int i = 0; i < m; i++) {
if (n == m - i)
n -= 1;
else
n -= 2;
}
tambah++;
}
cout << m;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, cnt = 0;
cin >> a >> b;
while (b > a) {
if (b % 2 == 0) {
b /= 2;
cnt++;
} else {
b++;
cnt++;
}
}
cout << abs(cnt + a - b);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long int M = 1000000007;
long long int inv(long long int a, long long int b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
pair<long long int, long long int> neigh[4] = {
{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n;
cin >> n;
long long int x;
cin >> x;
long long int pos;
cin >> pos;
long long int les = x - 1;
long long int mor = n - x;
long long int res = 1;
long long int left = 0;
long long int right = n;
while (left < right) {
long long int mid = (left + right) / 2;
if (mid <= pos) {
if (pos != mid) res = res * (les--) % M;
left = mid + 1;
} else {
res = res * (mor--) % M;
right = mid;
}
}
for (long long int i = les + mor; i >= (1); i--) {
res = res * i % M;
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int x, i, sum = 0;
scanf("%d", &x);
if (x < 0) x = -x;
for (i = 0; sum < x || sum % 2 != x % 2; sum += ++i)
;
printf("%d", i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[55][55];
bitset<55> b[55];
int main() {
int i, j, ii, jj;
scanf("%d %d\n", &n, &m);
for (i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (a[i][j] == 'B') {
for (ii = 1; ii <= n; ++ii) b[ii] &= 0;
for (jj = j; jj <= m && a[i][jj] == 'B'; ++jj) b[i][jj] = 1;
for (jj = j; jj && a[i][jj] == 'B'; --jj) b[i][jj] = 1;
for (jj = j; jj <= m; ++jj)
if (b[i][jj]) {
for (ii = i; ii <= n && a[ii][jj] == 'B'; ++ii) b[ii][jj] = 1;
}
for (jj = j; jj; --jj)
if (b[i][jj]) {
for (ii = i; ii <= n && a[ii][jj] == 'B'; ++ii) b[ii][jj] = 1;
}
for (ii = i; ii <= n && a[ii][j] == 'B'; ++ii) b[ii][j] = 1;
for (ii = i + 1; ii <= n; ++ii)
if (b[ii][j]) {
for (jj = j; jj <= m && a[ii][jj] == 'B'; ++jj) b[ii][jj] = 1;
for (jj = j; jj && a[ii][jj] == 'B'; --jj) b[ii][jj] = 1;
}
for (ii = i; ii <= n; ++ii)
for (jj = 1; jj <= m; ++jj)
if (a[ii][jj] == 'B' && b[ii][jj] == 0) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, t;
cin >> x >> y >> z;
t = x;
while (t > 0) {
if (y - t * 2 >= 0 && z - t * 4 >= 0) {
t = t + t * 2 + t * 4;
break;
} else
t--;
}
if (t == 0)
cout << 0;
else
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int b[N];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < m; ++i) {
scanf("%d", b + i);
}
sort(a, a + n);
sort(b, b + m);
if (n > m) {
printf("YES\n");
} else {
int dd = 1;
int i = n - 1, j = m - 1;
while (1) {
if (i < 0) break;
if (a[i] <= b[j]) {
j--;
i--;
} else {
dd = 0;
break;
}
}
if (dd) {
printf("NO\n");
} else {
printf("YES\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
T inline SQR(const T& a) {
return a * a;
}
template <typename T>
T inline ABS(const T& a) {
return a < 0 ? -a : a;
}
const double EPS = 1e-9;
inline int SGN(double a) {
return ((a > EPS) ? (1) : ((a < -EPS) ? (-1) : (0)));
}
inline int CMP(double a, double b) { return SGN(a - b); }
using namespace std;
const long long mod = 1000000007LL;
long long a[2222];
long long mlt[2222];
long long extended_gcd(long long* a, long long b) {
long long x = 0ll, lastx = 1ll;
long long y = 1ll, lasty = 0ll;
long long temp, quot, rem;
while (b) {
quot = (*a) / b;
rem = (*a) % b;
*a = b;
b = rem;
temp = x;
x = lastx - quot * x;
lastx = temp;
temp = y;
y = lasty - quot * y;
lasty = temp;
}
return lastx;
}
long long inverse(long long a, long long m) {
long long x = extended_gcd(&a, m);
return ((x + m) % m);
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
int N, k;
cin >> N >> k;
for (int i = 0; i < N; ++i) cin >> a[i];
for (int i = 0; i < N; ++i)
if (a[i] >= mod) a[i] %= mod;
if (k == 0) {
for (int i = 0; i < N; ++i) {
if (i) cout << " ";
cout << a[i];
}
cout << "\n";
return 0;
}
mlt[0] = 1LL;
mlt[1] = k % mod;
long long num = k;
long long den = 1;
for (int i = 2; i <= N - 1; ++i) {
num++;
den++;
mlt[i] = (((mlt[i - 1] * num) % mod) * inverse(den, mod)) % mod;
}
for (int i = 0; i < N; ++i) {
long long s = 0;
if (i) cout << " ";
for (int j = 0; j < i + 1; ++j) {
s += (mlt[j] * a[i - j]) % mod;
if (s >= mod) s -= mod;
}
cout << s;
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
int n, m, ans;
int main() {
cin >> n >> m;
for (int a = 0; a < N; a++)
for (int b = 0; b < N; b++)
if (a * a + b == n && a + b * b == m) ans++;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, ara[100000 + 10], arac[100000 + 10], ara2[100000 + 10],
ara3[100000 + 10], dp1[100000 + 10], dp2[100000 + 10];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ara[i];
ara2[i] = ara[i];
ara3[i] = ara[i];
arac[i] = ara[i];
}
for (int i = 0; i + 1 < n; i++) {
if (ara[i + 1] <= ara[i]) ara[i + 1] = ara[i] + 1;
}
for (int i = n - 1; i - 1 >= 0; i--) {
if (ara2[i - 1] <= ara2[i]) ara2[i - 1] = ara2[i] + 1;
}
for (int i = 0; i < n; i++) {
dp1[i] = abs(ara3[i] - ara[i]);
dp2[i] = abs(ara3[i] - ara2[i]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += min(dp1[i], dp2[i]);
arac[i] += min(dp1[i], dp2[i]);
}
int l = 0;
for (int i = 0; i + 1 < n; i++) {
if (arac[i] == arac[i + 1]) l++;
}
if (l) l++;
while (l > 2) {
l -= 2;
ans += 2;
}
if (l == 2) ans++;
cout << ans << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.