solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(0);
int znaki;
cin >> znaki;
vector<char> wektor(znaki);
int lewe = 0;
int prawe = 0;
int pytajniki = 0;
for (int i = 0; i < znaki; i++) {
cin >> wektor[i];
if (wektor[i] == '(') lewe += 1;
if (wektor[i] == ')') prawe += 1;
if (wektor[i] == '?') pytajniki += 1;
}
if (znaki % 2 == 1) {
cout << ":(\n";
return 0;
}
int lewe_do_postawienia = (znaki / 2) - lewe;
int prawe_do_postawienia = (znaki / 2) - prawe;
int obecna_wartosc = 0;
for (int i = 0; i < znaki - 1; i++) {
if (wektor[i] == '(') {
obecna_wartosc += 1;
} else if (wektor[i] == ')') {
obecna_wartosc -= 1;
if (obecna_wartosc <= 0) {
cout << ":(\n";
return 0;
}
} else {
if (lewe_do_postawienia > 0) {
wektor[i] = '(';
lewe_do_postawienia -= 1;
obecna_wartosc += 1;
} else {
wektor[i] = ')';
prawe_do_postawienia -= 1;
obecna_wartosc -= 1;
if (obecna_wartosc <= 0) {
cout << ":(\n";
return 0;
}
}
}
}
if (obecna_wartosc == 1 &&
(wektor[znaki - 1] == ')' || wektor[znaki - 1] == '?')) {
wektor[znaki - 1] = ')';
for (int i = 0; i < znaki; i++) {
cout << wektor[i];
}
cout << "\n";
} else {
cout << ":(\n";
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, count = 0;
cin >> n;
string s;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == s[i + 1]) count++;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int x) {
if (x == 0 || x == 1) return false;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
int main() {
string s, m;
cin >> s >> m;
string sol;
for (int i = 0; i < s.size(); ++i) {
int a = s[i] - '0';
int b = m[i] - '0';
sol.push_back((a ^ b) + '0');
}
cout << sol << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, j = 0, c = 0;
char s1[10000], s2[10000], s3[10000];
scanf("%s %s", s1, s2);
n = strlen(s1);
for (i = n - 1; i >= 0; i--) {
s3[j++] = s1[i];
}
for (i = 0; i < n; i++) {
if (s2[i] == s3[i]) c++;
}
if (c == n)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long sqr(long long x) { return x * x; }
long long sqr(int x) { return (long long)x * x; }
double sqr(double x) { return x * x; }
long double sqr(long double x) { return x * x; }
const int N = 100179;
int main() {
ios::sync_with_stdio(false);
cout.precision(15);
int n;
double h;
cin >> n >> h;
for (int i = 1; i < n; ++i) cout << h * sqrt(1.0 * i / n) << " ";
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long cmp(long long n, long long k) {
string a = "";
while (n > 0) {
a += (n % 2 + '0');
n = n / 2;
}
for (long long i = a.length(); i < k; i++) a += '0';
string s = "";
for (long long i = 0; i < k; i++) {
if (a[i] == '0')
s += '1';
else
s += '0';
}
long long ans = 0;
long long Ans = 1;
for (long long i = 0; i < k; i++) {
ans += (s[i] - '0') * Ans;
Ans *= 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
map<long long, long long> pam;
long long a[n];
long long pre[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
pre[i] = a[i];
else
pre[i] = pre[i - 1] ^ a[i];
}
if (pre[0] == 0) pre[0] = cmp(0, k);
pam[pre[0]]++;
long long ans = 1;
for (long long i = 1; i < n; i++) {
long long v1 = pre[i];
long long v2 = cmp(pre[i], k);
ans += (i + 1);
if (v1 == 0 or v2 == 0) {
v1 = 0;
v2 = cmp(0, k);
if (pam[v1] + 1 <= pam[v2]) {
pam[v1]++;
ans -= pam[v1];
} else {
ans -= pam[v2];
pam[v2]++;
}
} else {
if (pam[v1] <= pam[v2]) {
ans -= pam[v1];
pam[v1]++;
} else {
ans -= pam[v2];
pam[v2]++;
}
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int val, color;
} f[600015];
bool cmp(node x, node y) { return x.val < y.val; }
int a[7], n, b[100005], cnt[100005];
int main() {
for (int i = 1; i <= 6; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
for (int j = 1; j <= 6; j++) {
f[6 * (i - 1) + j] = (node){b[i] - a[j], i};
}
}
int now = 0, num = 0, ans = 2e9;
bool flag = true;
sort(f + 1, f + 6 * n + 1, cmp);
for (int i = 0; i < 6 * n; i++) {
cnt[f[i].color]--;
if (cnt[f[i].color] == 0) num--;
while (num != n) {
if (now >= 6 * n) {
flag = false;
break;
}
now++;
cnt[f[now].color]++;
if (cnt[f[now].color] == 1) num++;
}
if (!flag) break;
ans = min(ans, f[now].val - f[i + 1].val);
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int toNumber(string s) {
int Number;
if (!(istringstream(s) >> Number)) Number = 0;
return Number;
}
string toString(int number) {
ostringstream ostr;
ostr << number;
return ostr.str();
}
int main() {
int n;
cin >> n;
vector<vector<int> > ve(n);
pair<int, int> ed[n];
for (int i = 0; i < (int)(n - 1); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
ve[a].push_back(b);
ve[b].push_back(a);
ed[i] = make_pair(a, b);
}
int col[n];
for (int i = 0; i < (int)(n); i++) cin >> col[i];
int pos[2];
pos[0] = -1;
for (int i = 0; i < (int)(n - 1); i++) {
if (col[ed[i].first] != col[ed[i].second]) {
pos[0] = ed[i].first;
pos[1] = ed[i].second;
}
}
if (pos[0] == -1) {
cout << "YES" << endl;
cout << 1 << endl;
return 0;
}
for (int i = 0; i < (int)(2); i++) {
int root = pos[i];
bool si = true;
queue<pair<int, int> > q;
bool vis[n];
for (int i = 0; i < (int)(n); i++) vis[i] = false;
vis[root] = true;
q.push(make_pair(root, col[root]));
while (!q.empty()) {
pair<int, int> ac = q.front();
q.pop();
for (int i = 0; i < (int)(ve[ac.first].size()); i++) {
if (vis[ve[ac.first][i]]) continue;
vis[ve[ac.first][i]] = true;
if (ac.first != root && col[ac.first] != col[ve[ac.first][i]]) {
si = false;
}
q.push(make_pair(ve[ac.first][i], col[ve[ac.first][i]]));
}
if (!si) break;
}
if (si) {
cout << "YES" << endl;
cout << root + 1 << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m, k, dp[1 << 23], a[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[a[i] ^ ((1 << 23) - 1)] = a[i];
}
for (int i = (1 << 23) - 1; i >= 0; i--) {
if (dp[i] == 0) {
for (int j = 0; j < 23; j++) {
if (dp[i | (1 << j)]) {
dp[i] = dp[i | (1 << j)];
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
if (dp[a[i]])
printf("%d ", dp[a[i]]);
else
printf("-1 ");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char a[1111], b[1111];
int sa[30], sb[30];
int main() {
int n;
gets(a);
gets(b);
int lena = strlen(a), lenb = strlen(b);
memset(sa, 0, sizeof(sa));
memset(sb, 0, sizeof(sb));
for (int i = 0; i < lena; i++) {
sa[a[i] - 'a']++;
}
for (int i = 0; i < lenb; i++) {
sb[b[i] - 'a']++;
}
int ans = 0;
int i;
for (i = 0; i < 26; i++) {
if (sb[i] < sa[i])
ans += sb[i];
else
ans += sa[i];
if (sa[i] == 0 && sb[i] != 0) break;
}
if (ans == 0 || i < 26)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long MOD = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double PI = 3.141592653589793116, EPS = 1e-9,
GOLD = ((1 + sqrt(5)) / 2);
vector<long long> HashMod = {1000000007LL, 1000000009LL, 1000000021LL,
1000000033LL};
template <class T>
int getbit(T s, int i) {
return (s >> 1) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
vector<long long> a(14);
void VarInput() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
for (long long i = 0; i < 14; i++) cin >> a[i];
}
void ProSolve() {
long long ans = 0;
for (long long i = 0; i < 14; i++) {
if (!a[i]) continue;
vector<long long> clone = a;
long long score = 0;
long long rem = clone[i];
clone[i] = 0;
for (long long j = 0; j < 14; j++) clone[j] += rem / 14;
rem %= 14;
long long ptr1 = (i + 1) % 14;
while (rem > 0) {
clone[ptr1]++;
rem--;
ptr1 = (ptr1 + 1) % 14;
}
for (long long j = 0; j < 14; j++) {
if (clone[j] % 2 == 0) score += clone[j];
}
ans = max(ans, score);
}
cout << ans;
}
int main() {
VarInput();
ProSolve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double E = 2.718281828459;
const int INF = 2e9;
const long long LINF = 1e18 + 5;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 1;
const int MN = 1e6 + 2;
int mark[505][505];
int tt[505];
set<int> ans;
set<int>::iterator it;
int dp[505];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &tt[i]);
}
sort(tt, tt + n);
for (int i = 0; i < 505; ++i)
for (int j = 0; j < 505; ++j) mark[i][j] = INF;
for (int i = 0; i < 505; ++i) dp[i] = INF;
mark[0][0] = -1;
dp[0] = -1;
dp[tt[0]] = 0;
for (int x = 0; x < 505; ++x) {
for (int i = 1; i < n; ++i) {
if (tt[i] > x) break;
if (dp[x - tt[i]] < i) {
dp[x] = min(dp[x], i);
}
}
}
for (int x = 0; x < 505; ++x) {
if (dp[x] != INF) mark[0][x] = dp[x];
}
for (int val = 1; val < 505; ++val) {
for (int x = 0; x <= val; ++x) {
for (int i = 0; i < n; ++i) {
if (tt[i] > val) continue;
if (mark[x][val - tt[i]] < i) {
mark[x][val] = min(mark[x][val], i);
}
if (x >= tt[i] && mark[x - tt[i]][val - tt[i]] < i) {
mark[x][val] = min(mark[x][val], i);
}
}
}
}
for (int i = 1; i < 505; ++i) {
if (mark[i][k] != INF) {
ans.insert(i);
}
}
ans.insert(0);
printf("%d\n", ans.size());
for (it = ans.begin(); it != ans.end(); ++it) {
printf("%d ", *it);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + "," +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug() { cerr << endl; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cerr << " " << to_string(H);
debug(T...);
}
struct Fast_power {
long long integer(long long n, long long e,
long long my_mod = 9223372036854775807LL) {
long long ans = 1;
while (e) {
if (e & 1)
ans = (ans * n) % my_mod, e--;
else
n = (n * n) % my_mod, e >>= 1;
}
return ans;
}
vector<vector<long long>> matrix_multiply(vector<vector<long long>> a,
vector<vector<long long>> b) {
vector<vector<long long>> c(a.size(), vector<long long>(b[0].size(), 0));
for (int i = 0; i < a.size(); i++)
for (int q = 0; q < b[0].size(); q++) {
long long num = 0;
for (int e = 0; e < a[0].size(); i++) num += a[i][e] * b[e][q];
c[i][q] = num;
}
return c;
}
};
struct Euclidean {
int gcdi(int a, int b) { return b ? gcdi(b, a % b) : a; }
double gcdf(double a, double b, double accuracy) {
return b <= accuracy ? a : gcdf(b, fmod(a, b), accuracy);
}
};
const int maxnD = 100000 + 5;
const long long INFD = 0x3f3f3f3f;
;
struct Dijkstra {
struct Edge {
int from, to;
long long dist;
};
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode &rhs) const { return d > rhs.d; }
};
vector<Edge> edges;
vector<int> G[maxnD];
bool done[maxnD];
long long d[maxnD];
int p[maxnD], n;
void init(int n) {
this->n = n;
for (int i = 0; i <= n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, long long dist) {
edges.push_back((Edge){from, to, dist});
int m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> q;
memset(d, INFD, sizeof(d));
d[s] = 0;
memset(done, 0, sizeof(done));
q.push((HeapNode){0, s});
while (!q.empty()) {
HeapNode x = q.top();
q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < G[u].size(); i++) {
Edge &e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
q.push((HeapNode){d[e.to], e.to});
}
}
}
}
};
const int maxnL = 500000 + 5;
const int INFL = 0x3f3f3f3f;
struct LIS {
int g[maxnL], a[maxnL], d[maxnL];
void lis(int n) {
for (int i = 1; i <= n; i++) g[i] = INFL;
for (int i = 1; i < n; i++) {
int k = lower_bound(g + 1, g + n + 1, a[i]) - g;
g[k] = a[i];
}
}
};
const int maxnS = 200000 + 5;
struct SegmentTree {
int a[maxnS];
int sumv[maxnS * 4], minv[maxnS * 4], maxv[maxnS * 4], addv[maxnS * 4],
setv[maxnS * 4];
int lc, rc, v;
int _min, _max, _sum;
void build(int l, int r, int o) {
if (l == r) return void(sumv[o] = minv[o] = maxv[o] = a[l]);
build(l, (l + r) >> 1, o << 1);
build(((l + r) >> 1) + 1, r, o << 1 | 1);
}
void maintain(int l, int r, int o) {
sumv[o] = minv[o] = maxv[o] = a[l];
if (r > l) {
sumv[o] = sumv[o << 1] + sumv[o << 1 | 1];
minv[o] = min(minv[o << 1], minv[o << 1 | 1]);
maxv[o] = max(maxv[o << 1], maxv[o << 1 | 1]);
}
minv[o] += addv[o], maxv[o] += addv[o], sumv[o] += addv[o] * (r - l + 1);
}
void update(int l, int r, int o) {
if (l >= lc && r <= rc)
addv[o] += v;
else {
int m = (l + r) >> 1;
if (lc <= m) update(l, (l + r) >> 1, o << 1);
if (rc > m) update(((l + r) >> 1) + 1, r, o << 1 | 1);
}
maintain(l, r, o);
}
void query(int l, int r, int o, int add) {
if (lc <= l && r <= rc) {
_sum += sumv[o] + add * (r - l + 1);
_min = min(_min, minv[o] + add);
_max = max(_max, maxv[o] + add);
} else {
int m = (l + r) >> 1;
if (lc <= m) query(l, m, o << 1, add + addv[o]);
if (rc > m) query(m + 1, r, o << 1 | 1, add + addv[o]);
}
}
};
const int maxnB = 100000 + 5;
struct BIT {
int c[maxnB], n;
int lowbit(int x) { return x & -x; }
int sum(int x) {
int ret = 0;
while (x > 0) {
ret += c[x];
x -= lowbit(x);
}
return ret;
}
void add(int x, int d) {
while (x <= n) {
c[x] += d;
x += lowbit(x);
}
}
};
const int INF = 0x3f3f3f3f;
const int maxn = 100000 + 5;
const long long mod = 1000000000 + 7;
long long a[maxn], n;
vector<int> G[maxn];
vector<long long> ans;
long long dfs(int u, int fa) {
long long num = 1;
for (int i = 0; i < G[u].size(); i++)
if (G[u][i] != fa) num += dfs(G[u][i], u);
if (fa != -1) ans.push_back((n - num) * num);
return num;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
cin >> n;
for (int i = 1; i <= n; i++) G[i].clear();
ans.clear();
int f1, f2;
for (int i = 0; i < n - 1; i++)
cin >> f1 >> f2, G[f1].push_back(f2), G[f2].push_back(f1);
int m;
cin >> m;
for (int i = 0; i < m; i++) cin >> a[i];
if (m < n - 1)
for (int i = m; i < n - 1; i++) a[i] = 1;
sort(a, a + max((long long)m, n - 1));
int pos;
for (int i = 1; i <= n; i++)
if (G[i].size() == 1) {
pos = i;
break;
}
dfs(pos, -1);
sort(ans.begin(), ans.end());
long long sum = 0, sum2 = ans[n - 2];
for (int i = n - 2; i < max(n - 1, (long long)m); i++)
sum2 = (sum2 * a[i]) % mod;
for (int i = 0; i < n - 2; i++) sum = (sum + a[i] * ans[i] % mod) % mod;
sum = (sum + sum2) % mod;
cout << sum << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int layout[500 * 500];
for (int i = 0; i < 500 * 500; i++) layout[i] = 0;
int curr = 250 * 500;
layout[curr] = 1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'U') {
curr -= 500;
} else if (s[i] == 'D') {
curr += 500;
} else if (s[i] == 'L') {
curr -= 1;
} else {
curr += 1;
}
layout[curr]++;
}
int count = 0;
for (int i = 0; i < 500 * 500; i++) {
if (layout[i] > 1) {
int l = layout[i];
count += l * (l - 1) / 2;
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 9; i >= 0; --i) {
cout << i << endl;
string s;
getline(cin, s);
if (s == "great!" or s == "don't think so" or s == "not bad" or
s == "cool" or s == "don't touch me!") {
cout << "normal" << endl;
return 0;
}
if (s == "don't even" or s == "terrible" or s == "worse" or s == "no way" or
s == "go die in a hole" or s == "are you serious?") {
cout << "grumpy" << endl;
return 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long arr[n + 3][m + 5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
vector<pair<long long, int> > rows, cols;
if (n <= 4 || m <= 4) {
}
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = 0; j < m; j++) {
sum += arr[i][j];
}
rows.emplace_back(sum, i);
}
sort(rows.rbegin(), rows.rend());
for (int j = 0; j < m; j++) {
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += arr[i][j];
}
cols.emplace_back(sum, j);
}
sort(cols.rbegin(), cols.rend());
vector<long long> options;
long long sum = 0;
for (int i = 0; i < min(4, (int)rows.size()); i++) sum += rows[i].first;
options.push_back(sum);
sum = 0;
for (int i = 0; i < min(4, (int)cols.size()); i++) sum += cols[i].first;
options.push_back(sum);
if (n <= 4 || m <= 4) {
sort(options.rbegin(), options.rend());
cout << options[0] << endl;
return 0;
}
sum = 0;
for (int i = 0; i < rows.size(); i++) {
priority_queue<long long> pq;
long long temp = rows[i].first, cnt = 0;
for (int j = 0; j < cols.size(); j++) {
pq.push(cols[j].first - arr[rows[i].second][cols[j].second]);
}
while (pq.size() && cnt < 3) {
temp += pq.top();
pq.pop();
cnt++;
}
sum = max(temp, sum);
}
options.push_back(sum);
sum = 0;
for (int i = 0; i < cols.size(); i++) {
priority_queue<long long> pq;
long long temp = cols[i].first, cnt = 0;
for (int j = 0; j < rows.size(); j++) {
pq.push(rows[j].first - arr[rows[j].second][cols[i].second]);
}
while (pq.size() && cnt < 3) {
temp += pq.top();
pq.pop();
cnt++;
}
sum = max(temp, sum);
}
options.push_back(sum);
sum = 0;
for (int i = 0; i < rows.size() - 1; i++) {
for (int k = i + 1; k < rows.size(); k++) {
priority_queue<long long> pq;
long long temp = rows[i].first + rows[k].first, cnt = 0;
for (int j = 0; j < cols.size(); j++) {
pq.push(cols[j].first - arr[rows[k].second][cols[j].second] -
arr[rows[i].second][cols[j].second]);
}
while (pq.size() && cnt < 2) {
temp += pq.top();
pq.pop();
cnt++;
}
sum = max(temp, sum);
}
}
options.push_back(sum);
sort(options.rbegin(), options.rend());
cout << options[0] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxn = 1e5 + 5;
int n;
int a[maxn];
long long ans;
vector<pair<int, int> > vec;
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", a + i);
if (n == 1) {
if (!(a[0] & 1) || (!a[0]))
puts("cslnb");
else
puts("sjfnb");
return 0;
}
sort(a, a + n);
int same = 0;
for (int i = (0); i < (n - 1); ++i)
if (a[i] == a[i + 1]) ++same;
long long res = 0, emp = 0;
if (same > 1) {
puts("cslnb");
return 0;
} else if (same == 1) {
for (int i = (0); i < (n - 1); ++i)
if (a[i] == a[i + 1]) {
if ((i && a[i] - 1 == a[i - 1]) || a[i] - 1 < 0) {
puts("cslnb");
return 0;
} else
--a[i], ++res;
}
}
for (int i = 0, j = 0; i < n;) {
for (; j < n && a[j] == a[i] + j - i; ++j)
;
vec.push_back(make_pair(a[i], a[j - 1]));
i = j;
}
for (int i = (0); i < (vec.size()); ++i) {
if (!i) {
emp += vec[i].first - 0;
res += (vec[i].second - vec[i].first + 1) * emp;
} else {
emp += vec[i].first - vec[i - 1].second - 1;
res += (vec[i].second - vec[i].first + 1) * emp;
}
}
if (res & 1)
puts("sjfnb");
else
puts("cslnb");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int num[maxn];
int main() {
long long w, m;
memset(num, 0, sizeof(num));
cin >> w >> m;
long long cnt;
for (cnt = 1;; cnt++) {
if (!(m / (int)(pow(w, cnt) + 0.1))) {
break;
}
}
for (int i = cnt; i >= 0; i--) {
num[i] = m / (long long)(pow(w, i) + 0.1);
m %= (long long)(pow(w, i) + 0.1);
}
bool flag = true;
for (int i = 0; i <= cnt; i++) {
if (num[i] >= w) {
num[i] -= w;
num[i + 1] += 1;
}
if (num[i] == 1 || num[i] == 0) continue;
if (num[i] == w - 1) {
num[i + 1] += 1;
continue;
}
flag = false;
break;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e10;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 2e5 + 5;
vector<long long> v[N];
long long a[N];
long long dp[N][2];
void dfs(long long z, long long p) {
dp[z][1] = -INF;
for (long long x : v[z]) {
if (x == p) continue;
dfs(x, z);
long long tmp = max(dp[z][1] + dp[x][1], dp[z][0] + dp[x][0]);
amax(dp[z][1], max(dp[z][1] + dp[x][0], dp[z][0] + dp[x][1]));
amax(dp[z][0], tmp);
}
amax(dp[z][1], dp[z][0] + a[z]);
}
void solve() {
long long n;
cin >> n;
for (long long i = 1; i < n + 1; i++) {
long long p;
cin >> p >> a[i];
if (p != -1) v[p].push_back(i);
}
dfs(1, 0);
cout << max(dp[1][0], dp[1][1]);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num;
cin >> num;
vector<int> vec;
stack<int> stk;
while (num > 0) {
stk.push(num % 2);
num /= 2;
}
while (!stk.empty()) {
vec.push_back(stk.top());
stk.pop();
}
int oper = 0;
vector<int> ans;
int check = count(vec.begin(), vec.end(), 1);
while (check < vec.size()) {
oper++;
if (oper % 2 == 1) {
int zero = -1;
for (int i = 0; i <= vec.size() - 1; i++) {
if (zero == -1 && vec[i] == 0) zero = i;
if (zero != -1) {
if (vec[i] == 1)
vec[i] = 0;
else
vec[i] = 1;
}
}
ans.push_back(zero);
} else {
vec[vec.size() - 1]++;
for (int i = vec.size() - 1; i >= 1; i--) {
if (vec[i] > 1) {
vec[i] = 0;
vec[i - 1]++;
}
}
}
check = count(vec.begin(), vec.end(), 1);
}
cout << oper << endl;
for (int i = 0; i <= (int)ans.size() - 1; i++) {
cout << vec.size() - ans[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200100;
const int MAX4 = MAX * 4;
int N, Q, l, r, x;
int A[MAX];
int b[MAX4], e[MAX4], lo[MAX4], hi[MAX4];
void init(int n, int beg, int end) {
b[n] = beg;
e[n] = end;
if (beg == end) {
lo[n] = hi[n] = beg;
return;
}
int m = beg + (end - beg) / 2;
init(2 * n, beg, m);
init(2 * n + 1, m + 1, end);
lo[n] = lo[2 * n];
if (A[lo[2 * n + 1]] < A[lo[n]]) lo[n] = lo[2 * n + 1];
hi[n] = hi[2 * n];
if (A[hi[2 * n + 1]] > A[hi[n]]) hi[n] = hi[2 * n + 1];
}
pair<int, int> query(int n) {
if (b[n] >= l && e[n] <= r) {
return {lo[n], hi[n]};
}
pair<int, int> ret;
if (e[2 * n] >= l) {
ret = query(2 * n);
if (b[2 * n + 1] <= r) {
pair<int, int> tmp = query(2 * n + 1);
if (A[tmp.first] < A[ret.first]) ret.first = tmp.first;
if (A[tmp.second] > A[ret.second]) ret.second = tmp.second;
}
return ret;
} else
return query(2 * n + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q;
for (int I = 0; I < N; I++) cin >> A[I];
init(1, 0, N - 1);
for (int q = 0; q < Q; q++) {
cin >> l >> r >> x;
l--;
r--;
pair<int, int> sol = query(1);
if (A[sol.first] != x)
cout << sol.first + 1 << "\n";
else if (A[sol.second] != x)
cout << sol.second + 1 << "\n";
else
cout << -1 << "\n";
};
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
long long x = (r) / d;
if (d >= l)
cout << (x + 1) * d << endl;
else
cout << d << endl;
}
}
| 1 |
#include <bits/stdc++.h>
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
template <class E>
struct Graph {
vector<vector<E> > adj;
Graph(int N) : adj(N) {}
virtual void add_edge(int v, E e) { adj[v].push_back(e); }
vector<E> &operator[](int v) { return adj[v]; }
inline int size() { return adj.size(); }
};
struct NormalEdge {
int to;
NormalEdge(int to) : to(to) {}
};
struct UWGraph : public Graph<NormalEdge> {
UWGraph(int N) : Graph(N) {}
void add_edge(int v, int e) { adj[v].push_back({e}); }
};
const int N_MAX = 100010;
bool finished[N_MAX], seen[N_MAX];
stack<int> st;
int pos = -1;
template <class E>
void dfs(int v, int p, Graph<E> &G) {
st.push(v);
seen[v] = true;
for (auto e : G[v]) {
if (e.to == p) continue;
if (finished[e.to]) continue;
if (seen[e.to] && !finished[e.to]) {
pos = e.to;
return;
}
dfs(e.to, v, G);
if (pos != -1) return;
}
finished[v] = true;
st.pop();
}
template <class E>
vector<int> getCycle(int v, Graph<E> &G) {
vector<int> ret;
for (int i = 0; i < (int)(G.size()); i++)
if (!seen[i]) {
dfs(i, -1, G);
if (pos != -1) break;
}
if (pos == -1) return ret;
while (!st.empty()) {
int u = st.top();
st.pop();
ret.push_back(u);
if (u == pos) break;
}
reverse((ret.begin()), (ret.end()));
return ret;
}
int color[N_MAX];
template <class E>
int colorDFS(int v, int c, Graph<E> &G) {
int ret = (c == 0);
color[v] = c;
for (auto e : G[v]) {
if (color[e.to] != -1) continue;
ret += colorDFS(e.to, 1 - c, G);
}
return ret;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
UWGraph G(K);
for (int i = 0; i < (int)(M); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
if (a >= K || b >= K) continue;
G.add_edge(a, b);
G.add_edge(b, a);
}
auto cycle = getCycle(0, G);
int L = cycle.size();
if (cycle.empty()) {
cout << "1\n";
memset(color, -1, sizeof(color));
int val = 0;
for (int i = 0; i < (int)(K); i++)
if (color[i] == -1) {
val += colorDFS(i, 0, G);
}
int col = (val >= (K + 1) / 2) ? 0 : 1;
vector<int> ans;
for (int i = 0; i < (int)(K); i++)
if (color[i] == col) ans.push_back(i + 1);
for (int i = 0; i < (int)((K + 1) / 2); i++) {
if (i > 0) cout << " ";
cout << ans[i];
}
cout << "\n";
} else {
cout << "2\n";
cout << L << "\n";
for (int i = 0; i < (int)(L); i++) {
if (i > 0) cout << " ";
cout << cycle[i] + 1;
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double PI = acos(-1.0);
const long double da = PI / 6;
struct Point {
long double x, y, angle, dist;
};
bool operator<(const Point& lhs, const Point& rhs) {
return lhs.angle < rhs.angle;
}
long double ans;
int n;
Point p[3010], pp[3010];
int k;
long double tree[20010];
int N;
int findL(long double x) {
int l = 0, r = k - 1;
while (r - l > 1) {
int m = (l + r) >> 1;
if (pp[m].angle > x - eps)
r = m;
else
l = m;
}
if (pp[l].angle > x - eps)
return l;
else if (pp[r].angle > x - eps)
return r;
return -1;
}
int findR(long double x) {
int l = 0, r = k - 1;
while (r - l > 1) {
int m = (l + r) >> 1;
if (pp[m].angle < x + eps)
l = m;
else
r = m;
}
if (pp[r].angle < x + eps)
return r;
else if (pp[l].angle < x + eps)
return l;
return -1;
}
long double getmax(int i, int L, int R, int qL, int qR) {
if (L == qL && R == qR) {
return tree[i];
} else {
int M = (L + R) >> 1;
long double res = 0;
if (qL <= M) res = max(res, getmax(i * 2, L, M, qL, min(M, qR)));
if (qR > M) res = max(res, getmax(i * 2 + 1, M + 1, R, max(M + 1, qL), qR));
return res;
}
}
void check(long double qL, long double qR, long double dist) {
int iL = findL(qL);
int iR = findR(qR);
if (iL == -1 || iR == -1 || iL > iR) return;
if (getmax(1, 0, N - 1, iL, iR) > dist - eps) {
ans = dist;
}
}
void process() {
N = 1;
while (N < k) N <<= 1;
for (int i = 0; i < (int)(N); i++) tree[N + i] = pp[i].dist;
for (int i = N - 1; i >= 1; i--) tree[i] = max(tree[i * 2], tree[i * 2 + 1]);
}
void naive() {
long double ans = 0;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(i); j++)
for (int k = 0; k < (int)(j); k++) {
long double a = sqrt((p[j].x - p[i].x) * (p[j].x - p[i].x) +
(p[j].y - p[i].y) * (p[j].y - p[i].y));
long double b = sqrt((p[j].x - p[k].x) * (p[j].x - p[k].x) +
(p[j].y - p[k].y) * (p[j].y - p[k].y));
long double c = sqrt((p[k].x - p[i].x) * (p[k].x - p[i].x) +
(p[k].y - p[i].y) * (p[k].y - p[i].y));
long double z = min(min(a, b), c);
if (z > ans) ans = z;
}
ans *= 0.5;
printf("%.8f - naive\n", double(ans));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); i++) cin >> p[i].x >> p[i].y;
for (int i = 0; i < (int)(n); i++) {
k = 0;
for (int j = 0; j < (int)(n); j++)
if (j != i) {
pp[k] = p[j];
pp[k].angle = atan2(p[j].y - p[i].y, p[j].x - p[i].x);
if (pp[k].angle < 0) pp[k].angle += 2 * PI;
pp[k].dist = sqrt((p[j].x - p[i].x) * (p[j].x - p[i].x) +
(p[j].y - p[i].y) * (p[j].y - p[i].y));
k++;
}
sort(pp, pp + k);
process();
for (int j = 0; j < (int)(k); j++) {
if (pp[j].dist < ans) continue;
long double left = pp[j].angle - da - da + eps;
long double right = pp[j].angle + da + da - eps;
if (left > 0) {
long double qR = left;
long double qL = 0;
if (right > 2 * PI) qL = right - 2 * PI;
check(qL, qR, pp[j].dist);
}
if (right < 2 * PI) {
long double qL = right;
long double qR = 2 * PI;
if (left < 0) qR = 2 * PI + left;
check(qL, qR, pp[j].dist);
}
}
}
ans *= 0.5;
printf("%.8f\n", double(ans));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct my_struct {
int value = 1000000007;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
unordered_map<int, my_struct> hash;
int N = n;
while (N--) {
long long a, b;
cin >> a >> b;
my_struct aa;
aa.value = a + b;
hash[a] = aa;
if (hash[a + b].value == a) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, val;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> val;
if (val) {
cout << "HARD";
return 0;
}
}
cout << "EASY";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, s, d, f, g, h, j, k, l, i, n, m;
string x, z;
int main() {
cin >> n;
cin >> x >> z;
for (i = 0; i < 2 * n; i++) {
if (x[i] == z[i] && x[i] == '1') k++;
if (x[i] == '1' && z[i] == '0') f++;
if (x[i] == '0' && z[i] == '1') g++;
}
if (k % 2 == 1) s++;
if (g - f - s > 1) cout << "Second";
if (g - f - s < 0) cout << "First";
if (g - f - s == 0 || g - f - s == 1) cout << "Draw";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
bool cmp(int a, int b) { return a > b; }
int main() {
int n, k;
long long t;
cin >> n >> k >> t;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n - 1, cmp);
long long sum = 0;
for (int i = 0; i < k - 1; i++) sum += b[i];
for (int i = 0; i < n; i++) {
if (a[i] >= b[k - 1]) {
if (sum + b[k - 1] > t) {
cout << i + 1 << endl;
return 0;
}
} else {
if (a[i] + sum > t) {
cout << i + 1 << endl;
return 0;
}
}
}
cout << n << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 10007;
const int M = 20;
string s;
double a[105], b[105];
int main() {
int i, j, t, n, p;
while (~scanf("%d%d", &n, &t)) {
cin >> s;
for (i = 0; i < n; ++i) {
if (s[i] == '.') {
p = i;
break;
}
}
if (i == n) {
cout << s << endl;
return 0;
}
j = -1;
while (t--) {
if (j == -1) {
j = p + 1;
}
while (j < n && s[j] < '5') {
++j;
}
if (j == n) {
for (int i = 0; i < n; ++i) cout << s[i];
cout << endl;
return 0;
}
if (j == p + 1) {
j = p - 1;
if (s[j] != '9') {
s[j]++;
} else {
while (j > 0 && s[j] == '9') {
s[j] = '0';
--j;
}
if (s[j] == '9') {
cout << "1";
s[j] = '0';
} else {
++s[j];
}
}
for (int i = 0; i < p; ++i) cout << s[i];
cout << endl;
return 0;
} else if (j > p + 1) {
s[j - 1]++;
s[j] = '0';
n = j;
--j;
}
}
for (int i = 0; i < n; ++i) cout << s[i];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
string s, a, b;
int n;
int main() {
m["void"];
m["errtype"] = -1;
cin >> n;
while (n--) {
cin >> s;
if (s == "typedef") {
string t = "";
int cur = 0;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) {
if (isalpha(a[i]))
t += a[i];
else if (a[i] == '&')
cur--;
else
cur++;
}
if (m.find(t) == m.end() || m[t] < 0 || m[t] + cur < 0)
m[b] = -1;
else
m[b] = m[t] + cur;
} else {
cin >> a;
string t = "";
int cur = 0;
for (int i = 0; i < a.size(); i++) {
if (isalpha(a[i]))
t += a[i];
else if (a[i] == '&')
cur--;
else
cur++;
}
if (m.find(t) == m.end() || m[t] < 0 || m[t] + cur < 0)
puts("errtype");
else
cout << "void" << string(m[t] + cur, '*') << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(i, k, n) for (i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define ll long long
#define si(x) scanf("%d", &x)
#define sl(x) scanf("%lld", &x)
#define ss(s) scanf("%s", s)
#define pi(x) printf("%d\n", x)
#define pl(x) printf("%lld\n", x)
#define ps(s) printf("%s\n", s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << ", " << #y << "=" << y << endl
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define N 1000000007
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
bool arr[2000];
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
cin >> t;
while (t--){
int i;
ll n;
cin >> n;
if(n & 1) cout << -1 << "\n";
else {
if(n <= 4000){
cout << n / 2 << "\n";
for(int i = 0 ; i < n / 2 ; i++){
cout << 1 << " ";
}
cout << "\n";
} else {
cout << 2000 << "\n";
fill(arr , arr + 2000 , 1);
n -= 4000;
bool* ptr = arr + 1;
ll cur = 4;
while(n > 0){
// cout << n << " ";
if(*(ptr - 1) == 0) cur *= 2;
if(n - (cur - 2) >= 0){
n -= (cur - 2);
*ptr = 0;
// cur *= 2;
ptr++;
} else{
// cout << "thi ";
cur = 4;
ptr++;
*ptr = 0;
n -= (cur - 2);
ptr++;
}
}
// cout << "\n";
fo(i , 2000){
cout << arr[i] << " ";
}
cout << "\n";
}
}
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline int add(int x, int y) {
x += y;
if (x >= mod) return x - mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) return x + mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int power(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
inline int inv(int x) { return power(x, mod - 2); }
void solve() {
long long n, m, i, j, k, x, y, z, l, r;
cin >> n >> k;
long long a[n];
long long sum = 0;
r = 0;
l = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
r++;
} else {
l++;
}
}
long long mx = -1000000;
for (i = 0; i < k; i++) {
long long e = 0, s = 0;
for (j = i; j < n; j += k) {
if (a[j] == 1) {
e++;
} else {
s++;
}
}
long long temp = max((r - e) - (l - s), (l - s) - (r - e));
mx = max(temp, mx);
}
cout << mx << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[10000] = {};
int main() {
int n, d;
cin >> n >> d;
string s;
cin >> s;
for (int i = 0; i < n; i++) dp[i] = 1000000;
dp[0] = 0;
for (int i = 1; i < n; i++) {
if (s[i] == '0') continue;
for (int j = 1; j <= min(i, d); j++) {
dp[i] = min(dp[i], dp[i - j] + 1);
}
}
cout << (dp[n - 1] == 1000000 ? -1 : dp[n - 1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
cin >> w >> h;
int u[2], d[2];
for (int i = 0; i < 2; i++) cin >> u[i] >> d[i];
while (h > 0) {
w += h;
if (h == d[0]) w -= u[0];
if (h == d[1]) w -= u[1];
if (w < 0) w = 0;
h--;
}
cout << w;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x;
double y;
double t;
double p;
};
bool compare(node a, node b) { return a.t < b.t; }
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<node> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i].x >> A[i].y >> A[i].t >> A[i].p;
}
sort(A.begin(), A.end(), compare);
double dp[n + 1];
dp[0] = 0;
for (int i = 1; i < n + 1; ++i) {
dp[i] = A[i - 1].p;
}
for (int i = 2; i < n + 1; ++i) {
for (int j = 1; j < i; ++j) {
if (sqrt((A[i - 1].x - A[j - 1].x) * (A[i - 1].x - A[j - 1].x) +
(A[i - 1].y - A[j - 1].y) * (A[i - 1].y - A[j - 1].y)) <=
A[i - 1].t - A[j - 1].t)
dp[i] = max(dp[i], A[i - 1].p + dp[j]);
}
}
double ans = 0;
for (int i = 0; i < n + 1; ++i) {
if (dp[i] > ans) {
ans = dp[i];
}
}
printf("%.8f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, int n) {
if (n == 0) return 1;
if ((n % 2) == 0)
return power(a * a, n / 2);
else
return a * power(a * a, n / 2);
}
bool is_vow(char a) {
return ((a == 'a') || (a == 'e') || (a == 'i') || (a == 'o') || (a == 'u') ||
(a == 'y'));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
string ans;
vector<int> v(26);
char a = ':';
if (!is_vow(s[0])) {
ans += s[0];
} else {
v[s[0] - 'a']++;
a = s[0];
}
for (int i = 1; i < s.size(); i++) {
if (is_vow(s[i])) {
if (s[i] == a) {
v[s[i] - 'a']++;
} else {
if (a != ':') {
if ((a == 'e') || (a == 'o')) {
if (v[a - 'a'] == 2) {
ans += a;
ans += a;
} else {
ans += a;
}
} else {
ans += a;
}
v[a - 'a'] = 0;
}
a = s[i];
v[a - 'a'] = 1;
}
} else {
if (a != ':') {
if ((a == 'e') || (a == 'o')) {
if (v[a - 'a'] == 2) {
ans += a;
ans += a;
} else {
ans += a;
}
} else {
ans += a;
}
v[a - 'a'] = 0;
}
a = ':';
ans += s[i];
}
}
if (a != ':') {
if ((a == 'e') || (a == 'o')) {
if (v[a - 'a'] == 2) {
ans += a;
ans += a;
} else {
ans += a;
}
} else {
ans += a;
}
v[a - 'a'] = 0;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long num[1 << 20], a[1 << 20];
char s[20][100001];
void FWT(long long x1[], int n) {
int i, j, d, m;
long long x, y;
for (d = 1; n > d; d <<= 1) {
for (m = d << 1, i = 0; n > i; i += m) {
for (j = 0; d > j; j++) {
x = x1[i + j];
y = x1[i + j + d];
x1[i + j] = x + y;
x1[i + j + d] = x - y;
}
}
}
}
void UFWT(long long x1[], int n) {
int d, m, i, j;
long long x, y;
for (d = 1; n > d; d <<= 1) {
for (m = d << 1, i = 0; n > i; i += m) {
for (j = 0; d > j; j++) {
x = x1[i + j];
y = x1[i + j + d];
x1[i + j] = (x + y) / 2;
x1[i + j + d] = (x - y) / 2;
}
}
}
}
void Convolution(long long x1[], long long x2[], int len) {
int i;
FWT(x1, len);
FWT(x2, len);
for (i = 0; len > i; i++) {
x1[i] = x1[i] * x2[i];
}
UFWT(x1, len);
}
int main() {
int n, m, i, i1, temp, k;
long long ans = 0x3f3f3f3f;
scanf("%d %d", &n, &m);
memset(num, 0, sizeof(num));
for (i = 0; n > i; i++) {
scanf("%s", s[i]);
}
for (i = 0; m > i; i++) {
temp = 0;
for (i1 = 0; n > i1; i1++) {
temp = temp | ((s[i1][i] - '0') << (n - i1 - 1));
}
num[temp]++;
}
for (i = 0; (1 << n) > i; i++) {
temp = i;
k = 0;
while (temp != 0) {
k = k + temp % 2;
temp = temp / 2;
}
a[i] = min(k, n - k);
}
Convolution(a, num, 1 << n);
for (i = 0; (1 << n) > i; i++) {
ans = min(ans, a[i]);
}
printf("%lld", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
int dp[45][64][64];
int main() {
cin >> m >> n;
if (n < m) swap(m, n);
memset(dp, 63, sizeof(dp));
int g = (1 << m);
for (int k = 0; k < g; k++) dp[1][0][k] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g; j++) {
for (int k = 0; k < g; k++) {
if (dp[i][j][k] == 63) continue;
for (int z = 0; z < g; z++) {
int t = j | k | z | ((k << 1)) | (k >> 1);
t = (g - 1) & t;
if (t == (g - 1))
dp[i + 1][k][z] =
min(dp[i + 1][k][z], dp[i][j][k] + __builtin_popcount(k));
}
}
}
}
int ans = n * m;
for (int i = 0; i < (1 << m); i++) ans = min(ans, dp[n + 1][i][0]);
cout << n * m - ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool visited[100005];
int hrs[100005];
stack<int> stk;
vector<int> adjlist[100005], revlist[100005], sccs[100005];
int scccnt = 0, sccof[100005];
void dfs(int node) {
visited[node] = true;
for (int i = 0; i < adjlist[node].size(); i++) {
int child = adjlist[node][i];
if (!visited[child]) {
dfs(child);
}
}
stk.push(node);
}
void dfs2(int node, bool scc) {
visited[node] = true;
sccof[node] = scccnt;
if (scc) sccs[scccnt].push_back(node);
for (int i = 0; i < revlist[node].size(); i++) {
int child = revlist[node][i];
if (!visited[child]) {
dfs2(child, scc);
}
}
}
int n, m, h;
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> hrs[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (hrs[u] + 1 == hrs[v] || (hrs[u] == h - 1 && hrs[v] == 0)) {
adjlist[u].push_back(v);
revlist[v].push_back(u);
}
if (hrs[v] + 1 == hrs[u] || (hrs[v] == h - 1 && hrs[u] == 0)) {
adjlist[v].push_back(u);
revlist[u].push_back(v);
}
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
visited[i] = 0;
}
int mn = 1e9, mnind = 1e9;
while (stk.size() > 0) {
int node = stk.top();
if (!visited[node]) {
scccnt++;
dfs2(node, 1);
bool check = true;
for (int i = 0; i < sccs[scccnt].size(); i++) {
int nd = sccs[scccnt][i];
for (int j = 0; j < adjlist[nd].size(); j++) {
if (sccof[adjlist[nd][j]] != scccnt) {
check = false;
break;
}
}
if (!check) break;
}
if (sccs[scccnt].size() < mn && check) {
mn = sccs[scccnt].size();
mnind = scccnt;
}
}
stk.pop();
}
cout << mn << "\n";
for (int i = 0; i < sccs[mnind].size(); i++) {
cout << sccs[mnind][i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e3 + 7;
int arr[MaxN], visited[MaxN];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < (int)n; ++i) {
cin >> arr[i];
}
int res = 0, hacked = 0;
int turn = 0;
while (true) {
if (turn) {
turn = 0;
for (int i = n - 1; i >= 0; --i) {
if (arr[i] <= hacked && !visited[i]) {
visited[i] = true;
++hacked;
}
}
} else {
turn = 1;
for (int i = 0; i < n; ++i) {
if (arr[i] <= hacked && !visited[i]) {
visited[i] = true;
++hacked;
}
}
}
if (hacked >= n) break;
++res;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <long long MOD>
class ModInt {
public:
ModInt() : value(0) {}
ModInt(long long val) : value(val < 0 ? MOD + val % MOD : val % MOD) {}
ModInt& operator+=(ModInt that) {
value = value + that.value;
if (value >= MOD) value -= MOD;
return *this;
}
ModInt& operator-=(ModInt that) {
value -= that.value;
if (value < 0) value += MOD;
return *this;
}
ModInt& operator*=(ModInt that) {
value = value * that.value % MOD;
return *this;
}
ModInt& operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt operator^(long long k) const {
ModInt n = *this, res = 1;
while (k) {
if (k & 1) res *= n;
n *= n;
k >>= 1;
}
return res;
}
ModInt inverse() const {
long long a = value, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
long long toll() const { return value; }
int toi() const { return (int)value; }
private:
long long value;
};
const int MAX = (int)1e6 + 99;
int N, K, M, last[26];
string S;
char S_[MAX];
ModInt<1000000007ll> dp[2 * MAX];
void solve() {
M = (int)(S).size();
for (auto&(c) : (S)) c -= 'a';
dp[0] = 1;
for (int i = 1; i <= M; ++i) {
dp[i] = dp[i - 1] * 2;
int x = S.at(i - 1);
if (last[x]) dp[i] -= dp[last[x] - 1];
last[x] = i;
}
for (int i = M + 1; i <= M + N; ++i) {
dp[i] = dp[i - 1] * 2;
int x = -1, far = i + 1;
for (int(j) = (0); (j) < (int)(K); ++(j)) {
if (last[j] < far) {
far = last[j];
x = j;
}
}
if (last[x]) dp[i] -= dp[last[x] - 1];
last[x] = i;
}
ModInt<1000000007ll> ans = dp[N + M];
cout << ans.toi() << endl;
}
int main() {
cin >> N >> K;
scanf("%s", S_);
S = string(S_);
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m, i;
cin >> n >> m;
if (n == 1)
cout << 0 << endl;
else if (n == 2)
cout << m << endl;
else
cout << 2 * m << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool f(int a) {
bool b(0);
while (a > 0) {
if (a % 10 == 7) b = 1;
a /= 10;
}
return b;
}
int main() {
int x;
cin >> x;
int h, m;
cin >> h >> m;
if (f(h) || f(m)) {
cout << 0;
} else {
int res(0);
for (;; res++) {
if (f(h) || f(m)) break;
if (m - x >= 0)
m -= x;
else {
if (h == 0)
h = 23;
else
h--;
m = 60 + m - x;
}
}
cout << res;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int LG = 21;
const int N = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
using namespace std;
void solve(long long n) {
for (long long st = max(1LL, n / 3 - 3); st <= min(n, n / 3 + 3); st++) {
long long okay = 1;
for (long long c = 1; okay && c <= 1 && c <= n; c++) {
long long L = 0, R = n;
map<long long, long long> vis;
long long we = st, fl = 1;
vis[we] = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
if (vis[we] || !(1 <= we && we <= n)) {
okay = 0;
break;
}
vis[we] = 1;
if (M >= c)
R = M;
else
L = M;
}
}
for (long long c = max(1ll, n); okay && c <= n; c++) {
long long L = 0, R = n;
map<long long, long long> vis;
long long we = st, fl = 1;
vis[we] = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
if (vis[we] || !(1 <= we && we <= n)) {
okay = 0;
break;
}
vis[we] = 1;
if (M >= c)
R = M;
else
L = M;
}
}
if (okay) {
cout << "? " << st << endl;
long long x;
cin >> x;
long long fl = 1;
long long L = 0, R = n;
long long we = st;
long long anytime = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
cout << "? " << we << endl;
cin >> x;
if (x)
R = M, anytime = 1;
else
L = M;
}
cout << "= " << R << endl;
return;
}
}
cout << "bad " << n << endl;
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
solve(n);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, x[2 * 100005], cnt;
long long y[2 * 100005];
map<long long, int> d;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
y[i] = y[i - 1] + x[i];
d[y[i]]++;
if (y[i] != 0) cnt++;
}
long long s = 0;
for (int i = 1; i <= n; i++) {
s += x[i];
if (cnt > n - d[s]) cnt = n - d[s];
}
printf("%d", cnt);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char a[100];
cin >> s;
int j = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] != '+') {
a[j] = s[i];
j++;
}
}
sort(a, a + j);
for (int i = 0; i < j; i++) {
if (i == j - 1)
cout << a[i] << endl;
else
cout << a[i] << "+";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-4;
const double pi = 4 * atan(double(1));
const int N = 2020;
char buf[N];
int tmp[N], num[N];
bitset<N> val[N], used[N];
vector<int> ans;
inline void build(int num) {
int n = (int)strlen(buf);
for (int i = 0; i < n; ++i) {
tmp[i] = buf[i] - '0';
}
reverse(tmp, tmp + n);
int ptr = 0;
while (n > 0) {
if (tmp[0] % 2 != 0) {
val[num].set(ptr);
}
++ptr;
int ost = 0;
for (int j = n - 1; j >= 0; --j) {
tmp[j] += ost * 10;
ost = tmp[j] % 2;
tmp[j] /= 2;
}
while (n > 0 && tmp[n - 1] == 0) {
--n;
}
}
}
int main() {
int n;
cin >> n;
gets(buf);
for (int i = 0; i < N; ++i) {
num[i] = -1;
}
for (int i = 0; i < n; ++i) {
gets(buf);
build(i);
bool good = true;
for (int j = 0; j < N; ++j) {
if (!val[i].test(j)) {
continue;
}
if (num[j] == -1) {
num[j] = i;
good = false;
break;
}
val[i] ^= val[num[j]];
used[i] ^= used[num[j]];
}
if (good) {
ans.clear();
for (int j = 0; j < N; ++j) {
if (used[i].test(j)) {
ans.push_back(j);
}
}
printf("%d", int((ans).size()));
for (int j = 0; j < int((ans).size()); ++j) {
printf(" %d", ans[j]);
}
puts("");
} else {
used[i].set(i);
puts("0");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<pair<int, int>, int> > v;
char c[1005][1005];
for (int i = 0; i < n; i++) scanf("%s", c[i]);
int num[1005][1005];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) num[i][j] = 10000;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
if (c[i][j] == '.') sum = 0;
num[i][j] = min(num[i][j], sum);
if (c[i][j] == '*') sum++;
}
sum = 0;
for (int j = m - 1; j >= 0; j--) {
if (c[i][j] == '.') sum = 0;
num[i][j] = min(num[i][j], sum);
if (c[i][j] == '*') sum++;
}
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
if (c[i][j] == '.') sum = 0;
num[i][j] = min(num[i][j], sum);
if (c[i][j] == '*') sum++;
}
sum = 0;
for (int i = n - 1; i >= 0; i--) {
if (c[i][j] == '.') sum = 0;
num[i][j] = min(num[i][j], sum);
if (c[i][j] == '*') sum++;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (num[i][j]) {
v.push_back(make_pair((make_pair((i + 1), (j + 1))), (num[i][j])));
}
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
if (sum) {
c[i][j] = '.';
sum--;
}
if (num[i][j]) {
c[i][j] = '.';
sum = max(sum, num[i][j]);
}
}
sum = 0;
for (int j = m - 1; j >= 0; j--) {
if (sum) {
c[i][j] = '.';
sum--;
}
if (num[i][j]) {
c[i][j] = '.';
sum = max(sum, num[i][j]);
}
}
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
if (sum) {
c[i][j] = '.';
sum--;
}
if (num[i][j]) {
c[i][j] = '.';
sum = max(sum, num[i][j]);
}
}
sum = 0;
for (int i = n - 1; i >= 0; i--) {
if (sum) {
c[i][j] = '.';
sum--;
}
if (num[i][j]) {
c[i][j] = '.';
sum = max(sum, num[i][j]);
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (c[i][j] == '*') {
printf("-1\n");
return 0;
}
}
printf("%d\n", v.size());
for (auto it : v)
printf("%d %d %d\n", it.first.first, it.first.second, it.second);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void binomialCoeff(long long int n, long long int k) {
long long int C[n + 1][k + 1];
long long int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
long long x = C[n][k - 2] + C[n][k - 1];
x = x + C[n][k];
cout << x;
}
int main() {
long long int n;
cin >> n;
;
binomialCoeff(n, 7);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000001000;
const long long INFL = 2000000000000001000;
int solve();
int main() {
srand(2317);
cout.precision(10);
cout.setf(ios::fixed);
int tn = 1;
cin >> tn;
for (int i = 0; i < tn; ++i) solve();
}
const int maxn = 1005;
char s[3][maxn];
bool d[maxn][3];
bool can(int i, int j, int nj) {
int ri = i * 3;
assert(s[j][ri] == '.');
if (s[j][ri + 1] != '.') return false;
if (s[nj][ri + 1] != '.') return false;
if (s[nj][ri + 2] != '.' || s[nj][ri + 3] != '.') return false;
return true;
}
int solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < int(3); ++i) {
fill(s[i], s[i] + maxn, '.');
for (int j = 0; j < int(maxn); ++j) d[j][i] = false;
}
for (int i = 0; i < int(3); ++i) {
scanf("%s", s[i]);
s[i][n] = '.';
}
int pos = 0;
while (s[pos][0] != 's') ++pos;
s[pos][0] = '.';
d[0][pos] = true;
for (int i = 0; i < int(n - 1); ++i)
for (int j = 0; j < int(3); ++j) {
if (!d[i][j]) continue;
for (int dj = int(-1); dj < int(2); ++dj) {
if (j + dj < 0 || j + dj >= 3) continue;
if (!can(i, j, j + dj)) continue;
d[i + 1][j + dj] = true;
}
}
if (d[n - 1][0] || d[n - 1][1] || d[n - 1][2])
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int t, n, i, a[2020], sum, f1, f2;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
sum = 0;
f1 = 0;
f2 = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
if (a[i] % 2 == 1)
f1 = 1;
else
f2 = 1;
}
if (sum % 2 == 1)
printf("YES\n");
else {
if (f1 == 1 && f2 == 1)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, z = 0, w = 0;
cin >> n >> m;
if (n == 1 || n == 3 || n == 5 || n == 7 || n == 8 || n == 10 || n == 12)
z = 31;
else if (n == 2)
z = 28;
else
z = 30;
z += m - 1;
w = z / 7;
if (z % 7 != 0) w++;
cout << w;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::max;
using std::min;
int n, m, Cn, flag;
double D, Sumd[200005];
struct point {
double x, y;
friend point operator+(point t1, point t2) {
return {t1.x + t2.x, t1.y + t2.y};
}
friend point operator-(point t1, point t2) {
return {t1.x - t2.x, t1.y - t2.y};
}
friend point operator*(point t1, double t2) { return {t1.x * t2, t1.y * t2}; }
} A[200005], B[200005];
struct info {
double l, r;
} C[200005 << 1];
double F(double x) { return x * x; }
double Dist(point p1, point p2) {
return sqrt(F(p1.x - p2.x) + F(p1.y - p2.y));
}
void insert(double l, double r) {
if (r - l < 1e-7) return;
if (r - l > D) return void(flag = 1);
int x = floor(l / D), y = floor(r / D);
l -= x * D, r -= y * D;
if (x ^ y)
C[++Cn] = {0, r}, C[++Cn] = {l, D};
else
C[++Cn] = {l, r};
}
bool Judge(double mid) {
double t = 0, Lim1, Lim2, Min, a, b, c, kx, ky, bx, by, delta, x1, x2;
int i = 1, j;
point now1 = A[1], now2;
flag = Cn = 0;
for (j = 1; Sumd[j + 1] < D + 1e-7; j++)
;
now2 = A[j] + B[j] * (D - Sumd[j]);
for (; i <= n; t = Min) {
Lim1 = Sumd[i + 1], Lim2 = Sumd[j + 1] - D, Min = min(Lim1, Lim2);
kx = B[i].x - B[j].x, ky = B[i].y - B[j].y, bx = now1.x - now2.x,
by = now1.y - now2.y;
a = F(kx) + F(ky), b = 2 * kx * bx + 2 * ky * by,
c = F(bx) + F(by) - F(mid);
if (a > 1e-7) {
delta = F(b) - 4 * a * c;
if (delta > 0) {
delta = sqrt(delta), x1 = (-b - delta) * .5 / a,
x2 = (-b + delta) * .5 / a;
insert(t, min(Min, t + x1)), insert(max(t, t + x2), Min);
} else
insert(t, Min);
} else {
if (fabs(b) > 1e-7) {
x1 = -c / b;
if (b > 1e-7)
insert(max(t, t + x1), Min);
else
insert(t, min(Min, t + x1));
} else if (c > 1e-7)
insert(t, Min);
}
if (Lim1 < Min + 1e-7)
now1 = A[++i];
else
now1 = now1 + B[i] * (Min - t);
if (Lim2 < Min + 1e-7)
now2 = A[++j];
else
now2 = now2 + B[j] * (Min - t);
if (flag) return 0;
}
std::sort(C + 1, C + 1 + Cn, [](info t1, info t2) { return t1.l < t2.l; }),
t = 0;
for (int i = 1; i <= Cn; i++) {
if (C[i].l - t > 1e-7) return 1;
t = max(t, C[i].r);
}
if (D - t > 1e-7) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &A[i].x, &A[i].y);
for (int i = 1; i <= n; i++) {
A[i + n] = A[i],
B[i] = B[i + n] = (A[i + 1] - A[i]) * (1. / Dist(A[i], A[i + 1]));
Sumd[i + 1] = Sumd[i] + Dist(A[i], A[i + 1]);
}
for (int i = 2; i <= n; i++) Sumd[i + n] = Sumd[i] + Sumd[n + 1];
D = Sumd[n + 1] / m;
double l = 0, r = D, mid;
for (; r - l > 1e-7;) mid = (l + r) * .5, Judge(mid) ? r = mid : l = mid;
printf("%lf\n", l);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char c[n][m];
int i, j, k, l, t;
int temp1, temp2, temp3, temp4;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j] == 'S') {
temp1 = i;
temp2 = j;
}
if (c[i][j] == 'E') {
temp3 = i;
temp4 = j;
}
}
}
int v = temp1, w = temp2;
string s;
cin >> s;
int count = 0, flag;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
for (k = 0; k < 4; k++) {
for (l = 0; l < 4; l++) {
flag = 0;
v = temp1;
w = temp2;
if (i != j && j != k && k != l && i != k && i != l && j != l) {
for (t = 0; t < s.length(); t++) {
if ((s[t] - 48) == i) {
v++;
if (v == temp3 && w == temp4) {
flag = 1;
break;
}
if (v >= n) {
flag = 0;
break;
}
if (c[v][w] == '#') {
flag = 0;
break;
}
} else if ((s[t] - 48) == j) {
v--;
if (v == temp3 && w == temp4) {
flag = 1;
break;
}
if (v < 0) {
flag = 0;
break;
}
if (c[v][w] == '#') {
flag = 0;
break;
}
} else if ((s[t] - 48) == k) {
w++;
if (v == temp3 && w == temp4) {
flag = 1;
break;
}
if (w >= m) {
flag = 0;
break;
}
if (c[v][w] == '#') {
flag = 0;
break;
}
} else if ((s[t] - 48) == l) {
w--;
if (v == temp3 && w == temp4) {
flag = 1;
break;
}
if (w < 0) {
flag = 0;
break;
}
if (c[v][w] == '#') {
flag = 0;
break;
}
}
}
if (v == temp3 && w == temp4) flag = 1;
if (flag == 1) count++;
}
}
}
}
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using pii = std::pair<long long, long long>;
using namespace std;
const long long maxn = 2e5 + 5;
long long n, k, c[maxn], shiftedc[maxn], stable[maxn];
char x, ans[2] = {'B', 'W'};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> x;
c[i] = (x == 'W');
}
long long start = -1;
for (long long i = 0; i < n; i++)
if (c[i] == c[(i + 1) % n]) {
start = i;
break;
}
if (start == -1) {
long long flip = k & 1;
for (long long i = 0; i < n; i++) cout << ans[c[i] ^ flip];
cout << "\n";
return 0;
}
for (long long i = 0; i < n; i++) shiftedc[i] = c[(start + i) % n];
for (long long i = 0; i < n; i++) {
stable[i] = 1;
if (i == n - 1 || shiftedc[i] == shiftedc[i + 1]) continue;
long long j = i;
while (j < n && shiftedc[j] != shiftedc[(j + 1) % n]) j++;
j--;
assert(i <= j);
if (j == i) continue;
i++;
long long steps = 0, origj = j;
while (j >= i && steps < k) {
shiftedc[i] = shiftedc[(i - 1 + n) % n];
shiftedc[j] = shiftedc[(j + 1) % n];
stable[i] = 1;
stable[j] = 1;
steps++;
i++;
j--;
}
i = origj;
}
for (long long i = 0; i < n; i++) c[i] = shiftedc[(i - start + n) % n];
long long flip = k & 1;
for (long long i = 0; i < n; i++)
if (stable[(i - start + n) % n])
cout << ans[c[i]];
else
cout << ans[c[i] ^ flip];
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<pair<int, int> > L, R;
int whereL[30013], whereR[30013];
long long cost[30013][2];
long long dp[30013];
const long long INF = -3.1e16;
inline long long match(int a, int b) {
if (a <= 0 || b <= 0 || a > n || b > n) return INF;
return (long long)L[a].first * R[b].first;
}
inline void update(int i) {
if (i <= 0 || i > n) return;
cost[i][0] = match(i, i + 1) + match(i + 1, i);
cost[i][1] = max(match(i, i + 1) + match(i + 1, i + 2) + match(i + 2, i),
match(i, i + 2) + match(i + 1, i) + match(i + 2, i + 1));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i <= n; i++) {
L.push_back(make_pair(0, i));
R.push_back(make_pair(0, i));
}
for (int i = 1; i <= n; i++) scanf("%d", &L[i].first);
for (int i = 1; i <= n; i++) scanf("%d", &R[i].first);
sort(L.begin(), L.end());
sort(R.begin(), R.end());
for (int i = 1; i <= n; i++) {
whereL[L[i].second] = i;
whereR[R[i].second] = i;
}
for (int i = 1; i <= n; i++) update(i);
for (int Q = 0; Q < q; Q++) {
int a, b;
scanf("%d%d", &a, &b);
swap(R[whereR[a]].second, R[whereR[b]].second);
swap(whereR[a], whereR[b]);
for (int i = -2; i <= 0; i++) {
update(whereL[a] + i);
update(whereR[a] + i);
update(whereL[b] + i);
update(whereR[b] + i);
}
dp[n + 1] = 0;
for (int i = n; i; i--) {
dp[i] = max(dp[i + 2] + cost[i][0], dp[i + 3] + cost[i][1]);
if (L[i].second != R[i].second)
dp[i] = max(dp[i], (long long)L[i].first * R[i].first + dp[i + 1]);
}
printf("%lld\n", dp[1]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r, x, y, x_, y_;
cin >> r >> x >> y >> x_ >> y_;
cout << ceil((sqrt(pow(x - x_, 2) + pow(y - y_, 2)) / 2.0) / r) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool re(vector<int> v, int sum, int ind, bool b) {
if (ind == v.size()) return 1;
int s = 0;
for (int i = ind; i < v.size(); i++) {
s += v[i];
if (s > sum) return 0;
if (s == sum) return re(v, sum, i + 1, 0);
}
if (s > 0 || b)
return 0;
else
return 1;
}
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
v.push_back(c - 48);
}
int s = 0;
bool b = 0;
for (int i = 0; i < n - 1; i++) {
s += v[i];
if (re(v, s, i + 1, 1)) {
b = 1;
break;
}
}
if (b)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const bool DBG = 1;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
const int INF = 1e8;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int T;
cin >> T;
for (int t = (1); t < (T + 1); t++) {
string second;
cin >> second;
int p1 = 0;
vector<int> cnt(3);
int best = INF;
for (int p2 = 0; p2 < second.size(); p2++) {
cnt[second[p2] - '1']++;
if (cnt[0] && cnt[1] && cnt[2]) {
while (cnt[0] && cnt[1] && cnt[2]) {
cnt[second[p1] - '1']--;
p1++;
}
p1--;
cnt[second[p1] - '1']++;
best = min(best, p2 - p1 + 1);
}
}
if (best == INF) {
cout << 0 << endl;
} else {
cout << best << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double sum = 0, grade[5], point[5], k[5], worry[5], hack, unhack;
double max[5] = {500, 1000, 1500, 2000, 2500};
double time[5];
for (int i = 0; i < 5; i++) {
cin >> time[i];
}
for (int i = 0; i < 5; i++) {
cin >> worry[i];
}
cin >> hack >> unhack;
for (int i = 0; i < 5; i++) {
k[i] = time[i] / 250;
point[i] = 0.3 * max[i];
grade[i] = ((1 - k[i]) * max[i] - 50 * worry[i]);
if (grade[i] <= point[i]) {
grade[i] = point[i];
}
}
for (int i = 0; i < 5; i++) {
sum += grade[i];
}
sum = sum + hack * 100 - unhack * 50;
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, ans = 0;
cin >> t;
while (t--) {
string s;
cin >> s;
if (s == "Icosahedron") ans += 20;
if (s == "Dodecahedron") ans += 12;
if (s == "Octahedron") ans += 8;
if (s == "Cube") ans += 6;
if (s == "Tetrahedron") ans += 4;
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize ("O2,unroll-loops")
using namespace std;
typedef long long ll;
#define all(x) x.begin(), x.end()
#define pb push_back
const int MAXN=200010, LOG=18, SGM=26;
ll out, ans;
int n, m, k, u, v, x, y, t, a, b;
map<vector<int>, vector<string>> fuck;
int TR[MAXN][SGM], ts;
int par[LOG][MAXN];
int inc[MAXN], dest[MAXN];
vector<int> vec[MAXN];
string S[MAXN];
inline int Lcp(string &x, string &y){
int res=0;
while (res<m && x[res]==y[res]) res++;
return res;
}
int Count(vector<int> &vec, int l, int r){ // [l...r)
return lower_bound(all(vec), r)-lower_bound(all(vec), l);
}
int GetPar(int v, int k){
for (int i=0; (1<<i)<=k; i++) if (k&(1<<i)) v=par[i][v];
return v;
}
ll Solve(){
if (m==1) return 1ll*n*(n-1)/2;
sort(S, S+n);
ll res=0;
ts=0;
memset(TR[0], 0, sizeof(TR[0]));
vec[0].clear();
for (int i=0; i<n; i++){
vec[0].pb(i);
int v=0;
for (int j=m-1; ~j; j--){
int c=S[i][j]-'a';
if (!TR[v][c]){
TR[v][c]=++ts;
par[0][ts]=v;
vec[ts].clear();
memset(TR[ts], 0, sizeof(TR[ts]));
}
v=TR[v][c];
vec[v].pb(i);
}
dest[i]=v;
}
for (int i=1; i<=ts; i++) sort(all(vec[i]));
for (int j=1; j<LOG; ++j) for (int i=1; i<=ts; i++) par[j][i]=par[j-1][par[j-1][i]];
for (int i=0; i<n; i++){
inc[m-1]=m-1;
for (int j=m-2; ~j; j--){
if (S[i][j]<=S[i][j+1]) inc[j]=inc[j+1];
else inc[j]=j;
}
int l=i+1;
for (int lcp=m-1; ~lcp; lcp--){
int dwn=l-1, up=n;
while (up-dwn>1){
int mid=(dwn+up)>>1;
int tmp=Lcp(S[i], S[mid]);
if (tmp<lcp) up=mid;
else dwn=mid;
}
int r=up;
if (l==r) continue ;
res+=Count(vec[GetPar(dest[i], inc[lcp]+1)], l, r);
l=r;
}
}
return res;
}
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin>>n;
for (int i=0; i<n; i++){
cin>>S[i];
vector<int> shit(26, 0);
for (char ch:S[i]) shit[ch-'a']++;
fuck[shit].pb(S[i]);
}
m=S[0].size();
out=1337ll*n*(n-1)/2;
for (auto p:fuck){
n=0;
for (string s:p.second) S[n++]=s;
out-=1337ll*n*(n-1)/2;
out+=2ll*n*(n-1)/2;
ans+=Solve();
}
cout<<out-ans<<"\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, Q;
int h[N], tot;
struct Edge {
int v, w, next;
} e[N * 2];
int mdis, rt;
int pre[N], dis[N], maxdis[N], son[N], top[N];
int lis[N], cnt, pos[N], sum[N];
inline int max(int x, int y) { return x > y ? x : y; }
inline int min(int x, int y) { return x < y ? x : y; }
inline void addEdge(int u, int v, int w) {
e[++tot] = (Edge){v, w, h[u]};
h[u] = tot;
e[++tot] = (Edge){u, w, h[v]};
h[v] = tot;
}
void dfs1(int u, int fa, int dis) {
if (dis > mdis) {
mdis = dis;
rt = u;
}
for (int i = h[u], v; i; i = e[i].next)
if ((v = e[i].v) != fa) dfs1(v, u, dis + e[i].w);
}
void dfs2(int u, int fa) {
pre[u] = fa;
maxdis[u] = dis[u];
for (int i = h[u], v; i; i = e[i].next)
if ((v = e[i].v) != fa) {
dis[v] = dis[u] + e[i].w;
dfs2(v, u);
maxdis[u] = max(maxdis[u], maxdis[v]);
if (!son[u] || maxdis[v] > maxdis[son[u]]) son[u] = v;
}
}
void dfs3(int u, int fa, int Top) {
top[u] = Top;
if (!son[u]) {
lis[++cnt] = u;
return;
}
dfs3(son[u], u, Top);
for (int i = h[u], v; i; i = e[i].next)
if ((v = e[i].v) != fa && v != son[u]) dfs3(v, u, v);
}
int query(int x, int y) {
int m = y * 2 - 1;
if (m >= cnt) return sum[cnt];
if (pos[top[x]] <= m) return sum[m];
int u = x;
while (pos[top[u]] > m) u = pre[top[u]];
return sum[m] + maxdis[x] - dis[u] -
min(min(sum[m] - sum[m - 1], maxdis[u] - dis[u]), dis[u]);
}
bool cmp(int x, int y) {
return dis[x] - dis[pre[top[x]]] > dis[y] - dis[pre[top[y]]];
}
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addEdge(u, v, w);
}
mdis = -1;
rt = -1;
dfs1(1, 0, 0);
dfs2(rt, 0);
dfs3(rt, 0, rt);
sort(lis + 1, lis + 1 + cnt, cmp);
for (int i = 1; i <= cnt; i++) {
pos[top[lis[i]]] = i;
sum[i] = sum[i - 1] + dis[lis[i]] - dis[pre[top[lis[i]]]];
}
int ans = 0, x, y;
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &x, &y);
x = (x + ans - 1) % n + 1;
y = (y + ans - 1) % n + 1;
printf("%d\n", ans = query(x, y));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a + 1 == b)
cout << a << '9' << endl << b << '0';
else if (a == 9 && b == 1)
cout << "9 10";
else if (a == b)
cout << a << '1' << endl << b << "2";
else
cout << "-1";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read(int f = 1, int x = 0, char ch = ' ') {
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
const int N = 1e2 + 5;
int n, ans, c[26], f[N][N];
char s[N], t[N];
int main() {
for (int q = read(); q; --q) {
n = read(), ans = n, scanf("%s", s + 1), scanf("%s", t + 1);
for (int i = 1; i <= n; ++i) ++c[s[i] - 'a'];
for (int i = 1; i <= n; ++i) --c[t[i] - 'a'];
for (int i = 0; i < 26; ++i)
if (c[i]) ans = -1, c[i] = 0;
if (~ans)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
f[i][j] = 0;
if (s[i] == t[j])
for (int k = 0; k < i; ++k) f[i][j] = max(f[i][j], f[k][j - 1] + 1);
ans = min(ans, n - f[i][j]);
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
struct node {
int key;
int prior;
node* left;
node* right;
long long m[5];
int cnt;
node() {}
node(int kkey, int pprior) {
key = kkey;
prior = pprior;
left = NULL;
right = NULL;
cnt = 1;
memset(m, 0, sizeof(m));
m[0] = key;
}
};
long long get_med(node*& t, int i) {
if (t == NULL) return 0;
return t->m[i];
}
int cnt(node*& t) {
if (t == NULL) return 0;
return t->cnt;
}
void upd_cnt(node*& t) {
if (t == NULL) return;
t->cnt = cnt(t->left) + cnt(t->right) + 1;
}
void upd_med(node*& t) {
if (t == NULL) return;
for (int i = 0; i < 5; ++i) {
t->m[i] =
get_med(t->left, i) + get_med(t->right, (4 - cnt(t->left) % 5 + i) % 5);
}
t->m[cnt(t->left) % 5] += t->key;
}
void split(node* t, int x, node*& left, node*& right) {
if (t == NULL) {
left = NULL;
right = NULL;
} else if (t->key > x) {
split(t->left, x, left, t->left);
right = t;
} else {
split(t->right, x, t->right, right);
left = t;
}
upd_cnt(t);
upd_med(t);
}
void merge(node* left, node* right, node*& t) {
if (left == NULL) {
t = right;
} else if (right == NULL) {
t = left;
} else if (left->prior > right->prior) {
merge(left->right, right, left->right);
t = left;
} else {
merge(left, right->left, right->left);
t = right;
}
upd_cnt(t);
upd_med(t);
}
void add(node*& t, node* n) {
if (t == NULL) {
t = n;
} else if (t->prior < n->prior) {
split(t, n->key, n->left, n->right);
t = n;
} else if (n->key < t->key) {
add(t->left, n);
} else {
add(t->right, n);
}
upd_cnt(t);
upd_med(t);
}
void del(node*& t, int key) {
if (t->key == key) {
merge(t->left, t->right, t);
} else if (key < t->key) {
del(t->left, key);
} else {
del(t->right, key);
}
upd_cnt(t);
upd_med(t);
}
node* Tree = NULL;
int main() {
char s[10];
int n, i;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
int x;
scanf("%s", s);
if (strcmp(s, "add") == 0) {
scanf("%d", &x);
node* tt = new node(x, rand());
add(Tree, tt);
} else if (strcmp(s, "del") == 0) {
scanf("%d", &x);
del(Tree, x);
} else {
printf("%I64d\n", get_med(Tree, 2));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, T;
int p[200050];
map<int, int> cnt;
int main(void) {
vector<int> odds, evens;
set<int> s;
int oc = 0, ec = 0;
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &p[i]);
s.insert(p[i]);
if (cnt.find(p[i]) == cnt.end())
cnt[p[i]] = 1;
else
cnt[p[i]]++;
if (p[i] % 2 == 0)
ec++;
else
oc++;
}
for (int i = 1; i <= N * 2; i++) {
int e = i * 2;
int o = i * 2 - 1;
if (odds.size() < N && s.find(o) == s.end() && o <= M) {
odds.push_back(o);
}
if (evens.size() < N && s.find(e) == s.end() && e <= M) {
evens.push_back(e);
}
}
int op = 0, ep = 0;
if (oc > ec && evens.size() < (oc - ec) / 2) {
cout << -1;
return 0;
}
if (oc < ec && odds.size() < (ec - oc) / 2) {
cout << -1;
return 0;
}
int ans = 0;
for (int i = 1; i <= N; i++) {
int t = p[i];
if (cnt[p[i]] > 1) {
if (op == odds.size() && ep == evens.size()) {
cout << -1;
return 0;
}
if (p[i] % 2 == 0 && ec > oc) {
if (op == odds.size()) {
cout << -1;
return 0;
}
p[i] = odds[op];
op++;
ec--;
oc++;
ans++;
} else if (p[i] % 2 == 0 && ec <= oc) {
if (ep == evens.size()) {
cout << -1;
return 0;
}
p[i] = evens[ep];
ep++;
ans++;
} else if (p[i] % 2 == 1 && oc > ec) {
if (ep == evens.size()) {
cout << -1;
return 0;
}
p[i] = evens[ep];
ep++;
ec++;
oc--;
ans++;
} else if (p[i] % 2 == 1 && oc <= ec) {
if (op == odds.size()) {
cout << -1;
return 0;
}
p[i] = odds[op];
op++;
ans++;
}
cnt[t]--;
}
}
for (int i = 1; i <= N; i++) {
if (ec > oc && p[i] % 2 == 0) {
if (op == odds.size()) {
cout << -1;
return 0;
}
p[i] = odds[op];
op++;
ec--;
oc++;
ans++;
} else if (ec < oc && p[i] % 2 == 1) {
if (ep == evens.size()) {
cout << -1;
return 0;
}
p[i] = evens[ep];
ep++;
ec++;
oc--;
ans++;
}
}
if (ec != oc) {
printf("-1");
return 0;
}
printf("%d\n", ans);
for (int i = 1; i <= N; i++) {
printf("%d ", p[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<string, string> > vect;
string d1, d2;
for (int i = 0; i < n; i++) {
cin >> d1 >> d2;
vect.push_back(make_pair(d1, d2));
}
for (int i = 0; i < n; i++) {
if (vect[i].second == "rat") cout << vect[i].first << endl;
}
for (int i = 0; i < n; i++) {
if (vect[i].second == "woman" || vect[i].second == "child")
cout << vect[i].first << endl;
}
for (int i = 0; i < n; i++) {
if (vect[i].second == "man") cout << vect[i].first << endl;
}
for (int i = 0; i < n; i++) {
if (vect[i].second == "captain") cout << vect[i].first << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
int t, n, m, ans, len;
int a[N], b[N], c[N], f[N], x[N], y[N], res[N];
vector<int> g[N];
queue<int> q;
void topo() {
for (int i = 1; i <= n; ++i)
if (a[i] >= b[i]) f[i] = 1, q.push(i);
int cnt = 0;
while (!q.empty()) {
int tmp = q.front();
q.pop();
++cnt;
for (int i = 0; i < g[tmp].size(); ++i) {
int u = g[tmp][i];
if (!c[u]) c[u] = 1, res[++len] = u;
--b[x[u]], --b[y[u]];
if (a[x[u]] >= b[x[u]] && !f[x[u]]) f[x[u]] = 1, q.push(x[u]);
if (a[y[u]] >= b[y[u]] && !f[y[u]]) f[y[u]] = 1, q.push(y[u]);
}
}
if (cnt == n) {
puts("ALIVE");
for (int i = m; i >= 1; --i) cout << res[i] << " ";
} else
puts("DEAD");
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
cin >> x[i] >> y[i];
++b[x[i]], ++b[y[i]];
g[x[i]].push_back(i);
g[y[i]].push_back(i);
}
topo();
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int min = 0, i, j, mini, maxi, minj, maxj, m, n;
char a[50][50];
scanf("%d%d", &m, &n);
mini = m;
minj = n;
maxi = 0;
maxj = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
scanf(" %c", &a[i][j]);
if (a[i][j] == '*') {
if (j < minj) {
minj = j;
}
if (j > maxj) {
maxj = j;
}
if (i > maxi) {
maxi = i;
}
if (i < mini) {
mini = i;
}
}
}
}
for (i = mini; i <= maxi; i++) {
for (j = minj; j <= maxj; j++) {
printf("%c", a[i][j]);
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int N = 2e5 + 10;
struct Barrier {
int start, end;
Barrier() {}
Barrier(int start) : start(start), end(start) {}
};
int n, m, second, d;
int a[N];
int bn = 0;
Barrier barriers[N];
vector<pair<int, int> > res;
void bad() {
printf("IMPOSSIBLE\n");
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scanf("%d %d %d %d\n", &n, &m, &second, &d);
for (int i = 1; i <= n; i++) {
scanf("%d ", &a[i]);
}
sort(a + 1, a + n + 1);
barriers[++bn] = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] - barriers[bn].end - 2 < second) {
barriers[bn].end = a[i];
} else {
barriers[++bn] = a[i];
}
}
int xCur = 0;
for (int i = 1; i <= bn; i++) {
int dist = barriers[i].start - xCur - 1;
if (dist < second) {
bad();
}
res.push_back({1, barriers[i].start - xCur - 1});
dist = barriers[i].end - barriers[i].start + 2;
if (dist > d) {
bad();
}
res.push_back({2, barriers[i].end - barriers[i].start + 2});
xCur = barriers[i].end + 1;
}
if (xCur < m) {
res.push_back({1, m - xCur});
}
for (pair<int, int> it : res) {
if (it.first == 1) {
printf("RUN ");
} else {
printf("JUMP ");
}
printf("%d\n", it.second);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2)
cout << -1;
else
for (int i = n; i >= 1; i--) cout << i << " ";
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned;
using lint = long long;
using ulint = unsigned long long;
using ldouble = long double;
using point = complex<double>;
using doublex = complex<ldouble>;
const double E = 1e-9, pi = 2 * acos(0);
const ldouble PI = 2 * acosl(0);
bool solve(int testNumber) {
int n;
if (scanf("%d", &n) == EOF) return false;
vector<int> A(n), D(n);
for (int i = 0; i < n; i++) scanf("%d %d", &A[i], &D[i]);
int ans = 0;
auto cmp = [&](int i, bool ti, int j, bool tj) {
int a = A[i] + (ti ? D[i] : 0), b = A[j] + (tj ? D[j] : 0);
if (a != b) return a > b;
return i < j;
};
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
vector<int> id = {0, 1, 2, 3};
vector<int> vetI = {i, i, j, j};
vector<bool> vetB = {false, true, false, true};
do {
bool valid = true;
for (int k = 0; k < 4; k++)
for (int l = k + 1; l < 4; l++)
if ((id[k] < id[l]) != cmp(vetI[k], vetB[k], vetI[l], vetB[l]))
valid = false;
if (valid) break;
} while (next_permutation(id.begin(), id.end()));
int a = id[0], b = id[1], c = id[2], d = id[3];
bool flag = (a < b) == (c < d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
if (a > c) {
swap(a, c);
swap(b, d);
}
if (b > d)
ans++;
else if (b > c)
ans += 1 + flag;
}
printf("%d\n", ans);
return true;
}
void init() {}
int main() {
init();
for (int i = 1; solve(i); i++)
;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int MAX = numeric_limits<int>::max();
const int N = 1e6 + 5;
int r[N];
int siz[N];
int root(int x) {
while (x != r[x]) {
x = r[r[x]];
}
return x;
}
void joine(int x, int y) {
int r1 = root(x), r2 = root(y);
if (siz[r1] >= siz[r2]) {
r[r2] = r1;
siz[r1] += siz[r2];
} else {
r[r1] = r2;
siz[r2] += siz[r1];
}
}
int n;
pair<long long, int> p[N];
vector<int> v[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n + 1; i++) siz[i] = 1, r[i] = i;
for (int i = 0; i < n; i++) {
scanf("%lld", &p[i].first);
p[i].second = i;
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
joine(p[i].second, i);
}
for (int i = 0; i < n; i++) {
int x = root(i);
v[x].push_back(i);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i].size() > 0) ans++;
}
cout << ans << "\n";
for (int i = 0; i < n; i++) {
if (v[i].size() > 0) {
cout << v[i].size() << " ";
for (int j = 0; j < v[i].size(); j++) printf("%d ", v[i][j] + 1);
cout << "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
unordered_map<int, int> m;
map<int, int> v;
int arr[k + 5];
for (int i = 0; i < k; ++i) {
cin >> arr[i];
m[arr[i]]++;
v.insert(make_pair(arr[i], i));
}
long long a = 0;
a = n * 3LL;
a -= 2;
a -= v.size();
if (n == 1) {
a = 0;
cout << a << '\n';
return 0;
}
bool visited[100005];
memset(visited, false, sizeof visited);
for (int i = 0; i < k; ++i) {
if (visited[arr[i]]) {
m[arr[i]]--;
continue;
}
if (m[arr[i] - 1]) a--;
if (m[arr[i] + 1]) a--;
m[arr[i]]--;
visited[arr[i]] = true;
}
cout << a << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, sum = 0, arr[100000];
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] < 0 && m > 0) {
arr[i] *= -1;
m--;
}
}
sort(arr, arr + n);
while (m > 0) {
arr[0] *= -1;
m--;
}
for (long long i = 0; i < n; i++) sum = sum + arr[i];
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
long long getRes(vector<long long> arr, long long n) {
long long sum = 0;
for (long long i = 0; i < n; ++i) {
long long cur = arr[i];
long long j = i;
while (j < n && (arr[i]) * (arr[j]) > 0) {
cur = max(cur, arr[j]);
++j;
}
sum += cur;
i = j - 1;
}
return sum;
}
void solve() {
long long n;
cin >> n;
vector<long long> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
long long res = getRes(arr, n);
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int mod = 1000000007;
const int TOO_BIG = 314000000;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void print(T a) {
cout << a << endl;
exit(0);
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod; }
void sub(int &a, int b) { a = (a - b + mod) % mod; }
void mul(int &a, int b) { a = (long long)a * b % mod; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a; }
int mulv(int a, int b) { return (long long)a * b % mod; }
int read() {
int f = 1, x = 0;
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 pw(int a, int b) {
int s = 1;
for (; b; b >>= 1, a = (long long)a * a % mod)
if (b & 1) s = (long long)s * a % mod;
return s;
}
int m, n, numHeap;
int dest[N], val[N], first[N], id[N], src[N], minCost[N], maxCost[N],
curDeadChildren[N], curMinSum[N];
int nextSameSrc[N], firstBySrc[N], heap[N], heapAt[N], countByDest[N];
void Swap(int a, int b) {
int tmp = heap[a];
heap[a] = heap[b];
heap[b] = tmp;
heapAt[heap[a]] = a;
heapAt[heap[b]] = b;
}
void heapDown(int at) {
while (true) {
int i = at;
if (2 * at + 1 < numHeap &&
curMinSum[heap[2 * at + 1]] < curMinSum[heap[i]]) {
i = 2 * at + 1;
}
if (2 * at + 2 < numHeap &&
curMinSum[heap[2 * at + 2]] < curMinSum[heap[i]]) {
i = 2 * at + 2;
}
if (i == at) break;
Swap(at, i);
at = i;
}
}
void heapUp(int at) {
while (at > 0) {
int i = (at - 1) / 2;
if (curMinSum[heap[i]] > curMinSum[heap[at]]) {
Swap(at, i);
at = i;
} else
break;
}
}
signed main() {
scanf("%d%d", &m, &n);
int cnt = 0;
for (int i = (0); i <= (m - 1); i++) {
first[i] = cnt;
scanf("%d", &dest[i]);
dest[i]--;
int len;
scanf("%d", &len);
for (int j = (0); j <= (len - 1); j++) {
int cur;
scanf("%d", &cur);
if (cur < 0)
++val[i];
else {
cur--;
id[cnt] = i;
src[cnt] = cur;
cnt++;
}
}
}
first[m] = cnt;
memset(minCost, -1, sizeof(minCost));
memcpy(curMinSum, val, sizeof(val));
memset(firstBySrc, -1, sizeof(firstBySrc));
for (int i = 0; i < cnt; ++i) {
nextSameSrc[i] = firstBySrc[src[i]];
firstBySrc[src[i]] = i;
}
for (int i = 0; i < m; ++i)
if (first[i + 1] - first[i] == curDeadChildren[i]) {
heap[numHeap++] = i;
heapAt[i] = numHeap - 1;
heapUp(numHeap - 1);
}
while (numHeap > 0) {
int cur = heap[0];
Swap(0, numHeap - 1);
--numHeap;
if (numHeap > 1) heapDown(0);
heapAt[cur] = -1;
if (minCost[dest[cur]] >= 0) {
continue;
}
minCost[dest[cur]] = curMinSum[cur];
int at = firstBySrc[dest[cur]];
while (at >= 0) {
curMinSum[id[at]] += curMinSum[cur];
if (curMinSum[id[at]] >= TOO_BIG) {
curMinSum[id[at]] = TOO_BIG;
}
++curDeadChildren[id[at]];
int delta = curDeadChildren[id[at]] - (first[id[at] + 1] - first[id[at]]);
if (delta >= 0) {
heap[numHeap++] = id[at];
heapAt[id[at]] = numHeap - 1;
heapUp(numHeap - 1);
}
at = nextSameSrc[at];
}
}
memcpy(curMinSum, val, sizeof(curMinSum));
memset(curDeadChildren, 0, sizeof(curDeadChildren));
for (int i = 0; i < m; ++i) {
bool nice = true;
for (int j = first[i]; j < first[i + 1]; ++j)
if (minCost[src[j]] < 0) nice = false;
if (nice) ++countByDest[dest[i]];
}
numHeap = 0;
for (int i = 0; i < n; ++i)
if (minCost[i] >= 0 && countByDest[i] == 0) {
heap[numHeap++] = i;
}
for (int i = 0; i < m; ++i)
if (first[i + 1] - first[i] == curDeadChildren[i] &&
minCost[dest[i]] >= 0) {
maxCost[dest[i]] = max(maxCost[dest[i]], curMinSum[i]);
if (maxCost[dest[i]] >= TOO_BIG) {
maxCost[dest[i]] = TOO_BIG;
}
--countByDest[dest[i]];
if (countByDest[dest[i]] == 0) {
heap[numHeap++] = dest[i];
}
}
while (numHeap > 0) {
int cur = heap[--numHeap];
int at = firstBySrc[cur];
while (at >= 0) {
if (minCost[dest[id[at]]] >= 0) {
curMinSum[id[at]] += maxCost[cur];
if (curMinSum[id[at]] >= TOO_BIG) {
curMinSum[id[at]] = TOO_BIG;
}
++curDeadChildren[id[at]];
int delta =
curDeadChildren[id[at]] - (first[id[at] + 1] - first[id[at]]);
if (delta >= 0) {
maxCost[dest[id[at]]] = max(maxCost[dest[id[at]]], curMinSum[id[at]]);
--countByDest[dest[id[at]]];
if (countByDest[dest[id[at]]] <= 0) {
heap[numHeap++] = dest[id[at]];
}
}
}
at = nextSameSrc[at];
}
}
for (int i = (0); i <= (n - 1); i++) {
if (minCost[i] < 0) {
puts("-1 -1");
} else {
printf("%d", minCost[i]);
putchar(' ');
if (countByDest[i] > 0)
puts("-2");
else
printf("%d\n", maxCost[i]);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using tpl = tuple<int, int, int>;
using pcc = pair<char, char>;
const ll inf = 2e18;
const ll mod = 1e8;
int dr[] = {-1, 0, 1, 0};
int dc[] = {0, 1, 0, -1};
int kr[] = {-1, 1, -2, -2, -1, 1, 2, 2};
int kc[] = {-2, -2, -1, 1, 2, 2, -1, 1};
int dgr[] = {-1, -1, 1, 1};
int dgc[] = {1, -1, -1, 1};
int main() {
int n, x;
cin >> n;
vector<ll> pref(n + 2);
for (int i = 0; i < n; i++) {
cin >> x;
pref[i + 1] = pref[i] + x;
}
ll ans = 0;
if (n < 3) {
printf("0\n");
} else {
int cnt = 0;
ll sum = pref[n];
for (int i = 0; i < n - 1; i++) {
if (((2 * sum) % 3 == 0) && pref[i + 1] == ((2 * sum) / 3)) ans += cnt;
if ((sum % 3) == 0 && pref[i + 1] == (sum / 3)) cnt++;
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int M = 105;
const int MOD = 1e9 + 7;
long long read() {
long long x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
long long n, m, k, t, t1, t2, a[M];
struct Matrix {
long long n, m, a[M][M];
Matrix() {
n = m = 0;
memset(a, 0, sizeof a);
}
void clear() { memset(a, 0, sizeof a); }
Matrix operator*(const Matrix &b) const {
Matrix r;
r.n = n;
r.m = b.m;
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= m; j++)
for (long long k = 0; k <= b.m; k++)
r.a[i][k] = (r.a[i][k] + a[i][j] * b.a[j][k]) % MOD;
return r;
}
void print() {
for (long long i = 1; i <= n; i++, puts(""))
for (long long j = 1; j <= m; j++) printf("%lld ", a[i][j]);
}
} A, F;
Matrix qkpow(Matrix a, long long b) {
Matrix r;
r.n = r.m = a.n;
for (long long i = 1; i <= a.n; i++) r.a[i][i] = 1;
while (b > 0) {
if (b & 1) r = r * a;
a = a * a;
b >>= 1;
}
return r;
}
long long fast(long long a, long long b) {
long long r = 1;
while (b > 0) {
if (b & 1) r = r * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return r;
}
signed main() {
n = read();
k = read();
for (long long i = 1; i <= n; i++) {
a[i] = read();
if (!a[i]) m++;
}
for (long long i = 1; i <= m; i++)
if (!a[i]) t++;
A.n = A.m = F.n = m;
F.m = 1;
if (m == 0 || m == n) {
puts("1");
return 0;
}
t1 = m * (m - 1) / 2;
t2 = (n - m) * (n - m - 1) / 2;
long long inv = fast(n * (n - 1) / 2, MOD - 2);
for (long long i = 0; i <= m; i++) {
if (i > 0) A.a[i][i - 1] = (m - (i - 1)) * (m - (i - 1));
A.a[i][i] = t1 + t2 + i * (m - i) + (m - i) * (n - 2 * m + i);
if (i < m) A.a[i][i + 1] = (i + 1) * (n - 2 * m + (i + 1));
}
F.a[t][1] = 1;
A = qkpow(A, k);
F = A * F;
printf("%lld\n", F.a[m][1] * fast(inv, k) % MOD);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
int i;
int count = 0;
if (n == 1) {
if (str[0] == '0')
cout << 0;
else
cout << 1;
} else {
for (i = 0; i < n; i++) {
if (str[i] == '0') {
count++;
}
}
cout << 1;
for (i = 0; i < count; i++) {
cout << 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
void in(int &x);
const int N = 1e6 + 10;
string s;
int a[N];
void work() {
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
a[i + 1] = s[i] - '0';
}
int sol = 0;
for (int i = n; i >= 1; i--) {
if (a[i] == 1) {
if (i <= 1) break;
for (int j = i - 1; j >= 1; j--) {
if (a[j] == 0) {
a[j] = 1;
break;
} else {
a[j] = 0;
}
}
sol += 2;
} else {
sol++;
}
}
printf("%d\n", sol);
return;
}
int main() {
work();
return 0;
}
void in(int &x) {
bool neg = false;
register int c;
x = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) x = (x << 1) + (x << 3) + c - 48;
if (neg) x *= -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<long long int> v(n / 2 + 1, 0);
v[0] = -1e16;
for (long long int i = 1; i <= n / 2; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long int minnw = 1e17, val = 0, minusval = n;
for (long long int i = n / 2; i >= 1; i--) {
val += abs(minusval - v[i]);
minusval -= 2;
}
minnw = min(minnw, val);
val = 0;
minusval = n - 1;
for (long long int i = n / 2; i >= 1; i--) {
val += abs(minusval - v[i]);
minusval -= 2;
}
minnw = min(minnw, val);
cout << minnw << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q, C[100010], V[100010], MXL, MXH;
long long F[100010];
char ok[100010];
int main() {
scanf("%d%d", &n, &q);
for (int i = (int)0; i <= (int)n - 1; ++i) scanf("%d", V + i);
for (int i = (int)0; i <= (int)n - 1; ++i) scanf("%d", C + i);
for (int j = (int)0; j <= (int)q - 1; ++j) {
int a, b;
scanf("%d%d", &a, &b);
memset(ok, 0, sizeof(ok));
MXL = MXH = 0;
F[0] = 0;
ok[0] = 1;
for (int i = (int)0; i <= (int)n - 1; ++i) {
int c = C[i];
long long v = V[i];
long long sum = -1ll << 50;
if (MXH != c) {
if (F[MXH] + v * b > sum) sum = F[MXH] + v * b;
} else if (MXL != c) {
if (F[MXL] + v * b > sum) sum = F[MXL] + v * b;
}
if (ok[c]) {
if (F[c] + v * a > sum) sum = F[c] + v * a;
}
if (v * b > sum) sum = v * b;
if (!ok[c]) F[c] = -1ll << 50, ok[c] = 1;
if (sum > F[c]) {
F[c] = sum;
if (c == MXL || c == MXH) {
if (F[MXL] > F[MXH]) swap(MXL, MXH);
} else {
if (F[c] > F[MXH]) {
MXL = MXH, MXH = c;
} else if (F[c] > F[MXL])
MXL = c;
}
}
}
printf("%I64d\n", F[MXH]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a[12] = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
int i = 0;
string x, y, z;
int b[3];
int c[12] = {0};
cin >> x >> y >> z;
while (i < 12) {
if (a[i] == x || a[i] == y || a[i] == z) c[i]++;
i++;
}
i = 0;
for (int j = 0; j < 12; j++) {
if (c[j] == 1) {
b[i] = j;
i++;
}
}
if (((b[0] + 4) % 12 == b[1] && (b[1] + 3) % 12 == b[2]) ||
((b[1] + 4) % 12 == b[2] && (b[2] + 3) % 12 == b[0]) ||
((b[2] + 4) % 12 == b[0] && (b[0] + 3) % 12 == b[1]))
cout << "major";
else if (((b[0] + 3) % 12 == b[1] && (b[1] + 4) % 12 == b[2]) ||
((b[1] + 3) % 12 == b[2] && (b[2] + 4) % 12 == b[0]) ||
((b[2] + 3) % 12 == b[0] && (b[0] + 4) % 12 == b[1]))
cout << "minor";
else
cout << "strange";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100009;
long long n, a[maxn], b[maxn], c[maxn], in[maxn], color[maxn];
void read(long long a[]) {
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
}
void over() {
cout << -1;
exit(0);
}
vector<int> vec[maxn];
void dfs(int now, int fa, int se1, int se2) {
for (int i = 0; i < vec[now].size(); i++) {
int v = vec[now][i];
if (v == fa) continue;
color[v] = 6 - se1 - se2;
dfs(v, now, se2, color[v]);
}
}
long long ans = 1e18;
long long isok(int i, int s) {
if (s == 1)
return a[i];
else if (s == 2)
return b[i];
else
return c[i];
}
void DP(int q, int w, int e) {
long long temp = 0;
for (int i = 1; i <= n; i++)
if (color[i] == 1)
temp += isok(i, q);
else if (color[i] == 2)
temp += isok(i, w);
else
temp += isok(i, e);
ans = min(ans, temp);
}
void sovle(int q, int w, int e) {
long long temp = 0;
for (int i = 1; i <= n; i++)
if (color[i] == 1)
temp += isok(i, q);
else if (color[i] == 2)
temp += isok(i, w);
else
temp += isok(i, e);
if (temp != ans) return;
for (int i = 1; i <= n; i++)
if (color[i] == 1)
cout << q << " ";
else if (color[i] == 2)
cout << w << " ";
else
cout << e << " ";
exit(0);
}
int main() {
cin >> n;
read(a), read(b), read(c);
for (int i = 1; i < n; i++) {
int l, r;
scanf("%d%d", &l, &r);
in[l]++, in[r]++;
vec[l].push_back(r);
vec[r].push_back(l);
}
for (int i = 1; i <= n; i++)
if (in[i] >= 3) over();
int last;
for (int i = 1; i <= n; i++)
if (in[i] == 1) last = i;
color[last] = 1, color[vec[last][0]] = 2;
dfs(vec[last][0], last, 1, 2);
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) {
if (j == i) continue;
for (int q = 1; q <= 3; q++) {
if (q == i || q == j) continue;
DP(i, j, q);
}
}
cout << ans << endl;
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) {
if (j == i) continue;
for (int q = 1; q <= 3; q++) {
if (q == i || q == j) continue;
sovle(i, j, q);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100], n, row[55][100005], col[55][100005];
bool valid(int i, int j) {
for (int k = 0; k < n; k++) {
if (k == i) continue;
int x = a[i][j] - a[k][j];
if (x > 0 && row[i][x] && (x != a[i][j] || row[i][x] > 1)) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
row[i][a[i][j]]++;
col[j][a[i][j]]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j] != 1 && !valid(i, j)) {
printf("No\n");
return 0;
}
printf("Yes\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long N = 2750131;
long long lp[N + 1];
vector<long long> pr;
map<long long, long long> bp;
void solve() {
for (long long i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (long long j = 0;
j < (long long)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
for (long long i = 0; i < pr.size(); ++i) {
bp[pr[i]] = i + 1;
}
long long n;
cin >> n;
multiset<long long> ms;
for (long long i = 0; i < 2 * n; ++i) {
long long x;
cin >> x;
ms.insert(-x);
}
while (!ms.empty()) {
auto bg = ms.begin();
long long num = -(*bg);
if (lp[num] == num) {
long long num2 = bp[num];
ms.erase(bg);
ms.erase(ms.find(-num2));
cout << num2 << ' ';
} else {
ms.erase(ms.find(-(num / lp[num])));
ms.erase(bg);
cout << num << ' ';
}
}
cout << '\n';
}
signed main() {
fastio();
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename H>
bool chmin(H &v1, const H v2) {
if (v1 > v2) {
v1 = v2;
return true;
}
return false;
}
template <typename H>
bool chmax(H &v1, const H v2) {
if (v1 < v2) {
v1 = v2;
return true;
}
return false;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
int n;
cin >> n;
vector<int> a(n);
long long ans = LINF;
for (int i = 0; i < (n); ++i) cin >> a[i];
sort((a).begin(), (a).end());
int ub = max(1, (int)pow(a[n - 1], 1.0 / (n - 1)) + 1);
for (int i = 1; i < (ub + 1); ++i) {
long long count = 0;
for (int j = 0; j < (n); ++j) {
if (count >= ans) break;
count += (long long)abs((pow(i, j) - a[j]));
}
chmin(ans, count);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <typename T>
void read(vector<T>& arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < N; i++) cin >> arr[i];
}
template <typename T>
void read(vector<pair<T, T>>& arr, long long N) {
arr.clear();
arr.resize(N);
for (long long i = 0; i < (long long)arr.size(); i++)
cin >> arr[i].first >> arr[i].second;
}
template <typename T>
void read(vector<vector<T>>& arr, long long N, long long M) {
arr.clear();
arr.resize(N, vector<T>(M));
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) cin >> arr[i][j];
}
}
template <typename T>
void print(vector<T>& arr) {
for (auto it : arr) cout << it << ' ';
cout << '\n';
}
template <typename T>
void print(vector<pair<T, T>>& arr) {
for (auto it : arr) cout << " { " << it.first << ',' << it.second << " } ";
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& arr) {
for (auto it : arr) {
for (auto ut : it) cout << ut << ' ';
cout << '\n';
}
cout << '\n';
}
template <typename T>
void print(list<T>& arr) {
for (auto it = (arr).begin(); it != (arr).end(); it++) cout << *it << ' ';
cout << '\n';
}
template <typename T>
void print(unordered_set<T>& ss) {
for (auto it = (ss).begin(); it != (ss).end(); it++) cout << *it << ' ';
cout << '\n';
}
template <typename T>
void print(set<T>& ss) {
for (auto it = (ss).begin(); it != (ss).end(); it++) cout << *it << ' ';
cout << '\n';
}
bool lexi(string& s1, string& s2) {
long long I = s1.size(), J = s2.size(), i = 0, j = 0;
while (i < I and j < J) {
if (s1[i] > s2[j]) return true;
if (s1[i] < s2[j]) return false;
i++;
j++;
}
if (I >= J) return true;
return false;
}
struct uf {
vector<long long> par, size;
void init(long long N) {
par.resize(N, -1);
size.resize(N, 1);
}
long long root(long long a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(long long a, long long b) {
a = root(a);
b = root(b);
if (a == b) return;
if (size[a] < size[b]) {
par[a] = b;
size[b] += size[a];
} else {
par[b] = a;
size[a] += size[b];
}
}
bool same(long long a, long long b) {
if (root(a) == root(b)) return true;
return false;
}
};
struct seg_tree {
vector<long long> make;
long long siz;
vector<long long> arr;
void init(vector<long long>& a, bool max, bool range) {
arr.clear();
make.clear();
arr = a;
siz = arr.size();
make.resize(4 * siz);
if (max)
build_max(0, 0, siz - 1);
else if (range)
build_range(0, 0, siz - 1);
}
long long get_max(long long L, long long R) {
return Get_max(0, 0, siz - 1, L, R);
}
void update_max(long long index, long long val) {
Update_max(0, 0, siz - 1, index, val);
return;
}
long long get_sum(long long L, long long R) {
return Get_sum(0, 0, siz - 1, L, R);
}
void update_range(long long index, long long add) {
Update_range(0, 0, siz - 1, index, add);
return;
}
long long build_range(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
long long a = build_range(2 * ind + 1, L, mid);
long long b = build_range(2 * ind + 2, mid + 1, R);
make[ind] = a + b;
return make[ind];
}
}
long long Get_sum(long long ind, long long L, long long R, long long Left,
long long Right) {
if (L > Right or R < Left) return 0;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
long long a = Get_sum(2 * ind + 1, L, mid, Left, Right);
long long b = Get_sum(2 * ind + 2, mid + 1, R, Left, Right);
return a + b;
}
void Update_range(long long ind, long long L, long long R, long long index,
long long add) {
if (L == R) {
make[ind] += add;
arr[index] += add;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= R) {
Update_range(2 * ind + 1, L, mid, index, add);
} else {
Update_range(2 * ind + 2, mid + 1, R, index, add);
}
make[ind] = make[2 * ind + 1] + make[2 * ind + 2];
}
}
long long build_max(long long ind, long long L, long long R) {
if (L == R) {
make[ind] = arr[L];
return make[ind];
} else {
long long mid = (L + R) / 2;
return make[ind] = max(build_max(2 * ind + 1, L, mid),
build_max(2 * ind + 2, mid + 1, R));
}
}
long long Get_max(long long ind, long long L, long long R, long long Left,
long long Right) {
if (R < Left or L > Right) return -1e15;
if (Left <= L and R <= Right) return make[ind];
long long mid = (L + R) / 2;
return max(Get_max(2 * ind + 1, L, mid, Left, Right),
Get_max(2 * ind + 2, mid + 1, R, Left, Right));
}
long long Update_max(long long ind, long long L, long long R, long long index,
long long val) {
if (L == R) {
arr[index] = val;
make[ind] = val;
return val;
} else {
long long mid = (L + R) / 2;
if (L <= index and index <= mid) {
make[ind] = Update_max(2 * ind + 1, L, mid, index, val);
} else {
make[ind] = Update_max(2 * ind + 2, mid + 1, R, index, val);
}
make[ind] = max(make[2 * ind + 1], make[2 * ind + 2]);
return make[ind];
}
}
};
static bool comp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.first < b.first) return true;
if (a.first == b.first) {
if (a.second < b.second) return true;
}
return false;
}
long long Max = 1e17, Min = -1e16;
long long N, M, K, D;
long long mod = 1e9 + 7;
void solve() {
cin >> N >> K;
vector<vector<long long>> arr(5, vector<long long>(N + 1, 0));
if (K % 2 == 0) {
long long j = 2, k = N - 1;
while (K > 0 and j < k) {
arr[2][j] = 1;
arr[2][k] = 1;
j++;
k--;
K -= 2;
}
j = 2, k = N - 1;
while (K > 0 and j < k) {
arr[3][j] = 1;
arr[3][k] = 1;
j++;
k--;
K -= 2;
}
if (K > 0) {
arr[2][N / 2 + 1] = 1;
arr[3][N / 2 + 1] = 1;
K -= 2;
}
} else {
long long j = 2, k = N - 1;
while (K > 0 and j < k) {
if (K >= 2) {
arr[2][j] = 1;
arr[2][k] = 1;
j++;
k--;
K -= 2;
} else {
arr[2][N / 2 + 1] = 1;
K -= 1;
goto start;
}
}
if (K >= 1) {
arr[2][N / 2 + 1] = 1;
K--;
if (K == 0) goto start;
}
j = 2, k = N - 1;
while (K > 0 and j < k) {
if (K >= 2) {
arr[3][j] = 1;
arr[3][k] = 1;
j++;
k--;
K -= 2;
} else {
arr[3][N / 2 + 1] = 1;
K--;
goto start;
}
}
if (K > 0) {
arr[3][N / 2 + 1] = 1;
K--;
goto start;
}
}
start:
if (K != 0) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
for (long long i = 1; i <= 4; i++) {
for (long long j = 1; j <= N; j++) {
if (arr[i][j] == 1)
cout << '#';
else
cout << '.';
}
cout << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start_time = chrono::high_resolution_clock::now();
bool test = 0;
if (!test)
solve();
else {
long long tt;
cin >> tt;
while (tt--) solve();
}
auto end_time = chrono::high_resolution_clock::now();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 11111;
char s[maxn];
bool f[maxn];
int len;
int sg[maxn];
int dfs(int x) {
if (x <= 0) return 0;
if (sg[x] != -1) return sg[x];
bool vis[5555] = {};
for (int i = 1; i <= x; i++) {
vis[dfs(i - 2) ^ dfs(x - i - 1)] = true;
}
for (int i = 0;; i++) {
if (!vis[i]) return sg[x] = i;
}
}
bool gao(int s, int t, int sum) {
int x = t - s + 1;
sum ^= sg[x];
for (int i = 1; i <= x; i++) {
int sg1 = dfs(i - 2);
int sg2 = dfs(x - i - 1);
if ((sum ^ sg1 ^ sg2) == 0) {
cout << s + i << endl;
return true;
}
}
return false;
}
int main() {
while (~scanf("%s", s)) {
len = strlen(s);
for (int i = 0; i < len; i++) {
if (i != 0 && i != len - 1 && s[i - 1] == s[i + 1])
f[i] = 1;
else
f[i] = 0;
}
memset(sg, -1, sizeof(sg));
dfs(len);
int start = -1;
int sum = 0;
for (int i = 0; i < len; i++) {
if (f[i]) {
if (start == -1) start = i;
} else {
if (start != -1) {
sum ^= dfs(i - start);
}
start = -1;
}
}
if (sum == 0) {
puts("Second");
continue;
}
puts("First");
start = -1;
for (int i = 0; i < len; i++) {
if (f[i]) {
if (start == -1) start = i;
} else {
if (start != -1) {
if (gao(start, i - 1, sum)) break;
}
start = -1;
}
}
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a[100001], p[100001], n, i, min = 101, total = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d %d", &a[i], &p[i]);
for (i = 0; i < n; i++) {
if (min > p[i]) {
min = p[i];
}
total = total + min * a[i];
}
printf("%d\n", total);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 50;
int n, m, x[maxn], enf;
double dp[101][100005];
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &m);
enf = n * m;
int rank = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", x + i);
rank += x[i];
}
memset(dp, 0, sizeof(dp));
dp[0][0] = m - 1;
double px = 0;
int sumup = 0;
if (m > 1) px = 1.0 / (double)(m - 1);
for (int i = 1; i <= n; ++i) {
double sum = 0;
sumup += m;
for (int j = 0; j <= sumup; ++j) {
if (j - m - 1 >= 0) sum -= dp[i - 1][j - m - 1];
if (j - x[i] < 0)
dp[i][j] = sum * px;
else
dp[i][j] = (sum - dp[i - 1][j - x[i]]) * px;
sum += dp[i - 1][j];
}
}
double ans = 1;
for (int i = 0; i < rank; ++i) ans += dp[n][i];
printf("%.10lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y;
double d, p;
};
double P(pt &p, double R) {
return p.d <= R + 1e-9 ? 1 : exp(1 - (p.d / R) * (p.d / R));
}
int main() {
double R = 0;
int N, K;
double e;
cin >> N >> K >> e;
pt p0, pts[N];
cin >> p0.x >> p0.y;
for (int i = 0; i < N; i++) {
cin >> pts[i].x >> pts[i].y;
pts[i].d = sqrt((pts[i].x - p0.x) * (pts[i].x - p0.x) +
(pts[i].y - p0.y) * (pts[i].y - p0.y));
}
double lr = 0, rr = 10000;
while (lr - rr < -1e-9) {
R = (lr + rr) / 2;
for (int i = 0; i < N; i++) pts[i].p = P(pts[i], R);
double pm[N + 1];
fill_n(pm, N + 1, 0);
pm[0] = 1 - pts[0].p;
pm[1] = pts[0].p;
for (int i = 1; i < N; i++) {
for (int k = i + 1; k > 0; k--)
pm[k] = pts[i].p * pm[k - 1] + (1 - pts[i].p) * pm[k];
pm[0] *= 1 - pts[i].p;
}
double p = 0;
for (int k = 0; k < K; k++) p += pm[k];
if (p * 1000 > e)
lr = R;
else
rr = R;
}
cout << setprecision(10) << R;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int d;
int cal(int x) { return x == d ? 1 : x + 1; }
int main() {
int n, i, a, cur, ret = 0;
scanf("%d %d", &d, &n);
scanf("%d", &a);
cur = cal(a);
for (i = 1; i < n; i++) {
scanf("%d", &a);
if (cur > 1) {
ret += d - cur + 1;
}
cur = cal(a);
}
printf("%d", ret);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 2e18 + 7;
int ar[1010];
pair<int, int> arz[1010];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (n); ++i) cin >> ar[i];
sort(ar, ar + n);
int m;
cin >> m;
for (int i = 0; i < (m); ++i) cin >> arz[i].first >> arz[i].second;
sort(arz, arz + m);
int ans = 0;
int cnt = 0;
int s = 0;
for (int i = 0; i < (n); ++i) s += ar[i];
for (int i = 0; i < (m); ++i) {
if (s > arz[i].second) continue;
cout << max(s, arz[i].first);
return 0;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
template <typename X>
inline bool minimize(X& p, X q) {
if (p <= q) return 0;
p = q;
return 1;
}
template <typename X>
inline bool maximize(X& p, X q) {
if (p >= q) return 0;
p = q;
return 1;
}
int n, m, s;
char opt[10];
vector<int> D, A, S;
multiset<int> AA;
int solve1() {
int sum = 0;
for (int i = S.size() - 1, j = 0; ~i && j < A.size() && S[i] >= A[j];)
sum += S[i--] - A[j++];
return sum;
}
int solve2() {
for (int i = D.size() - 1; ~i; --i) {
set<int>::iterator it = AA.upper_bound(D[i]);
if (it == AA.end()) return 0;
AA.erase(it);
}
int sum = 0;
for (int i = A.size() - 1; ~i; --i) {
multiset<int>::iterator it = AA.lower_bound(A[i]);
if (it == AA.end()) return 0;
sum += *it - A[i];
AA.erase(it);
}
while (!AA.empty()) {
sum += *AA.begin();
AA.erase(AA.begin());
}
return sum;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf(" %s %d", opt, &s);
if (opt[0] == 'A')
A.push_back(s);
else
D.push_back(s);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &s);
S.push_back(s);
AA.insert(s);
}
sort(A.begin(), A.end());
sort(D.begin(), D.end());
sort(S.begin(), S.end());
cout << max(solve1(), solve2()) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 755, N = 10000010, SGM = 2;
int n, m, k, u, v, x, y, t, a, b, ans;
int C[N][SGM], F[N], ts;
int pos[MAXN], up[N];
int match[MAXN * 2], dist[MAXN * 2];
bool VC[MAXN], mark[MAXN], out[MAXN];
bool edge[MAXN][MAXN];
vector<int> G[MAXN];
string S[MAXN];
queue<int> Q;
int AddTrie(string &s) {
int v = 0;
for (char ch : s) {
if (!C[v][ch - 'a']) C[v][ch - 'a'] = ++ts;
v = C[v][ch - 'a'];
}
return v;
}
void BuildAho() {
for (int i = 0; i < SGM; i++)
if (C[0][i]) Q.push(C[0][i]);
while (Q.size()) {
int v = Q.front();
Q.pop();
if (!up[v]) up[v] = up[F[v]];
for (int i = 0; i < SGM; i++) {
if (!C[v][i])
C[v][i] = C[F[v]][i];
else {
F[C[v][i]] = C[F[v]][i];
Q.push(C[v][i]);
}
}
}
}
bool bfs() {
memset(dist, 31, sizeof(dist));
for (int i = 1; i <= n; i++)
if (!match[i]) {
dist[i] = 0;
Q.push(i);
}
bool res = 0;
while (Q.size()) {
int v = Q.front();
Q.pop();
if (v <= n) {
VC[v] = 1;
for (int u : G[v])
if (dist[v] + 1 < dist[u]) {
dist[u] = dist[v] + 1;
Q.push(u);
}
continue;
}
if (!match[v]) {
res = 1;
continue;
}
dist[match[v]] = dist[v] + 1;
Q.push(match[v]);
}
return res;
}
bool dfs(int node) {
mark[node] = 1;
for (int v : G[node])
if (!match[v] ||
dist[node] + 1 == dist[v] && !mark[match[v]] && dfs(match[v])) {
match[node] = v;
match[v] = node;
return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> S[i], up[pos[i] = AddTrie(S[i])] = i;
BuildAho();
for (int i = 1; i <= n; i++) {
int v = 0;
for (char ch : S[i]) {
v = C[v][ch - 'a'];
for (int u = up[v]; u && !edge[u][i]; u = up[F[pos[u]]])
if (i != u) {
G[u].push_back(i + n);
edge[u][i] = 1;
}
}
}
while (bfs()) {
memset(VC, 0, sizeof(VC));
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; i++)
if (!match[i] && !mark[i]) ans += dfs(i);
}
for (int i = 1; i <= n; i++)
if (match[i]) {
if (VC[i])
out[match[i] - n] = 1;
else
out[i] = 1;
}
cout << n - ans << '\n';
for (int i = 1; i <= n; i++)
if (!out[i]) cout << i << ' ';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline void Boost() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
Boost();
int n;
cin >> n;
int cnt = n * n;
vector<vector<int> > v(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
int a = (i % 2 ? n - 1 : 0);
int b = (i % 2 ? -1 : 1);
for (int j = 0, y = a; j < n; ++j, y += b) {
v[y][i] = cnt--;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cout << v[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, T;
int a[200010], t[200000];
vector<pair<int, int> > can(int k) {
vector<pair<int, int> > times;
for (int i = 0; i < n; i++) {
if (a[i] >= k) times.push_back({t[i], i + 1});
}
if (times.size() < k) return {};
sort(times.begin(), times.end());
vector<pair<int, int> > resp;
long long sumt = 0;
for (int i = 0; i < k; i++) {
resp.push_back(times[i]);
sumt += times[i].first;
}
if (sumt <= T) return resp;
return {};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> T;
for (int i = 0; i < n; i++) cin >> a[i] >> t[i];
int lo = 1, hi = n;
vector<pair<int, int> > sol;
while (lo <= hi) {
int mid = (lo + hi) / 2;
vector<pair<int, int> > resp = can(mid);
if (resp.size()) {
sol = resp;
lo = mid + 1;
} else
hi = mid - 1;
}
cout << sol.size() << endl << sol.size() << endl;
;
for (auto x : sol) cout << x.second << " ";
cout << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.