solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve();
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isPrime(long long int a) {
for (int i = 2; i <= sqrt(a); i++) {
if (a % i == 0) return false;
}
return true;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
long long int a[n];
long long int i, j = 0, k = 0, sum = 0;
for (i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
if (a[i] % 2 == 0)
k++;
else
j++;
}
if (n < x) {
cout << "No"
<< "\n";
} else if (n == x) {
if (sum % 2 == 0) {
cout << "No"
<< "\n";
} else {
cout << "Yes"
<< "\n";
}
}
if (n > x) {
if (j == 0) {
cout << "No"
<< "\n";
} else if (k == 0) {
if (x % 2 == 0) {
cout << "No"
<< "\n";
} else {
cout << "Yes"
<< "\n";
}
} else {
cout << "Yes"
<< "\n";
}
}
}
return 0;
}
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
return;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
t = 1;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int b[26] = {0};
for (int i = 0; i < n; i++) {
b[s[i] - 'A']++;
}
int mn = INT_MAX;
for (int i = 0; i < k; i++) {
mn = min(mn, (b[i]));
}
cout << mn * k;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int w[300010];
vector<int> G[300010];
struct edge {
int from, to, dist;
};
vector<edge> edges;
long long res[300010];
vector<long long> tmp[300010];
void addedge(int from, int to, int dist) {
edges.push_back(edge{from, to, dist});
G[from].emplace_back(edges.size() - 1);
}
long long ans;
long long dfs(int u, int fa) {
tmp[u].emplace_back(0), tmp[u].emplace_back(0);
for (auto &v : G[u]) {
edge &e = edges[v];
if (e.to == fa) continue;
long long r = dfs(e.to, u) - e.dist;
res[u] = max(res[u], r);
tmp[u].emplace_back(r);
}
sort(tmp[u].begin(), tmp[u].end());
ans = max(ans, w[u] + tmp[u][tmp[u].size() - 1] + tmp[u][tmp[u].size() - 2]);
res[u] += w[u];
return res[u];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i < n; i++) {
int u, v, c;
cin >> u >> v >> c;
addedge(u, v, c);
addedge(v, u, c);
}
dfs(1, 0);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pii;
void solveQuestion(){
int n1,n2,n3;
cin >> n1 >> n2 >> n3;
int n = n1+n2+n3;
vector<int> arr(n);
int sum = 0;
for(int i=0;i<n;i++){
cin >> arr[i];
sum += arr[i];
}
int mini1 = 1e9,mini2 = 1e9,mini3 = 1e9,s1 = 0,s2 = 0,s3 = 0;
for(int i=0;i<n1;i++){
mini1 = min(mini1,arr[i]);
s1 += arr[i];
}
for(int i=n1;i<(n1+n2);i++){
mini2 = min(mini2,arr[i]);
s2 += arr[i];
}
for(int i=(n1+n2);i<n;i++){
mini3 = min(mini3,arr[i]);
s3 += arr[i];
}
int mini = min({mini1+mini2,mini1+mini3,mini2+mini3});
int ans = sum - 2*mini;
ans = max(ans,sum - 2*min({s1,s2,s3}));
cout<<ans<<'\n';
}
int32_t main(int32_t argc,char const* argv[]){
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
//pre();
int test = 1;
//cin>>test;
while(test--){
solveQuestion();
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10;
int n, m, f[MAXN], l[MAXN], r[MAXN], opp[MAXN], t, T, N, bel[MAXN], vis[MAXN];
vector<pair<int, pair<int, int> > > L;
int getf(int first) {
if (f[first] == first) return first;
f[first] = getf(f[first]);
return f[first];
}
void fail() { puts("IMPOSSIBLE"), exit(0); }
void check(int first, int second) {
if (!(first + second >= t && first + second <= T)) return;
++first, ++second;
memset(bel, 0, sizeof(bel));
for (int i = 1; i <= n; ++i)
if (getf(i) == i && !bel[opp[i]]) {
if (!opp[i]) {
if (l[i] <= first && first <= r[i]) bel[i] = 1;
if (l[i] <= second && second <= r[i]) bel[i] = 2;
} else {
if (l[i] <= first && first <= r[i] && l[opp[i]] <= second &&
second <= r[opp[i]])
bel[i] = 1, bel[opp[i]] = 2;
if (l[i] <= second && second <= r[i] && l[opp[i]] <= first &&
first <= r[opp[i]])
bel[i] = 2, bel[opp[i]] = 1;
}
if (!bel[i]) return;
}
puts("POSSIBLE");
printf("%d %d\n", first - 1, second - 1);
for (int i = 1; i <= n; ++i) printf("%d", bel[getf(i)]);
puts(""), exit(0);
}
void check(int p, int l, int r) {
if (l <= t - p && t - p <= r) check(p, t - p);
if (l <= T - p && T - p <= r) check(p, T - p);
check(p, l), check(p, r);
}
void check(int al, int ar, int bl, int br) {
--al, --ar, --bl, --br;
check(al, bl, br), check(ar, bl, br), check(bl, al, ar), check(br, al, ar);
}
int main() {
scanf("%d%d%d%d", &t, &T, &n, &m);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &l[i], &r[i]), f[i] = i, ++l[i], ++r[i];
for (int i = 1; i <= m; ++i) {
int first, second;
scanf("%d%d", &first, &second);
first = getf(first), second = getf(second);
if (first == second) fail();
if (!opp[first] && !opp[second])
opp[first] = second, opp[second] = first;
else if (!opp[first] || !opp[second]) {
if (!opp[first]) swap(first, second);
f[second] = opp[first];
} else {
f[opp[first]] = second, f[opp[second]] = first;
opp[first] = second, opp[second] = first;
}
}
for (int i = 1; i <= n; ++i) {
int first = getf(i);
l[first] = max(l[first], l[i]);
r[first] = min(r[first], r[i]);
if (l[first] > r[first]) fail();
if (i == first) N += 1 + !opp[i];
}
for (int i = 1; i <= n; ++i)
if (getf(i) == i && !vis[i]) {
if (!opp[i]) {
L.push_back(make_pair(1, make_pair(l[i], 0)));
L.push_back(make_pair(1, make_pair(r[i], 1)));
L.push_back(make_pair(l[i], make_pair(-l[i], 0)));
L.push_back(make_pair(l[i], make_pair(-r[i], 1)));
L.push_back(make_pair(l[i], make_pair(1, 0)));
L.push_back(make_pair(l[i], make_pair((int)1e9 + 1, 1)));
L.push_back(make_pair(r[i] + 1, make_pair(-1, 0)));
L.push_back(make_pair(r[i] + 1, make_pair(-((int)1e9 + 1), 1)));
L.push_back(make_pair(r[i] + 1, make_pair(l[i], 0)));
L.push_back(make_pair(r[i] + 1, make_pair(r[i], 1)));
L.push_back(make_pair((int)1e9 + 1, make_pair(-l[i], 0)));
L.push_back(make_pair((int)1e9 + 1, make_pair(-r[i], 1)));
} else {
int j = opp[i];
if (r[i] < l[j] || r[j] < l[i])
L.push_back(make_pair(l[i], make_pair(l[j], 0))),
L.push_back(make_pair(l[i], make_pair(r[j], 1))),
L.push_back(make_pair(r[i] + 1, make_pair(-l[j], 0))),
L.push_back(make_pair(r[i] + 1, make_pair(-r[j], 1)));
else if (l[i] <= l[j] && r[j] <= r[i]) {
vis[i] = vis[j] = 1;
L.push_back(make_pair(l[i], make_pair(l[j], 0))),
L.push_back(make_pair(l[i], make_pair(r[j], 1))),
L.push_back(make_pair(l[j], make_pair(-l[j], 0))),
L.push_back(make_pair(l[j], make_pair(-r[j], 1))),
L.push_back(make_pair(l[j], make_pair(l[i], 0))),
L.push_back(make_pair(l[j], make_pair(r[i], 1))),
L.push_back(make_pair(r[j] + 1, make_pair(-l[i], 0))),
L.push_back(make_pair(r[j] + 1, make_pair(-r[i], 1))),
L.push_back(make_pair(r[j] + 1, make_pair(l[j], 0))),
L.push_back(make_pair(r[j] + 1, make_pair(r[j], 1))),
L.push_back(make_pair(r[i] + 1, make_pair(-l[j], 0))),
L.push_back(make_pair(r[i] + 1, make_pair(-r[j], 1)));
} else if (l[i] <= l[j] && l[j] <= r[i] && r[i] <= r[j]) {
vis[i] = vis[j] = 1;
L.push_back(make_pair(l[i], make_pair(l[j], 0))),
L.push_back(make_pair(l[i], make_pair(r[j], 1))),
L.push_back(make_pair(l[j], make_pair(-l[j], 0))),
L.push_back(make_pair(l[j], make_pair(l[i], 0))),
L.push_back(make_pair(r[i] + 1, make_pair(-r[j], 1)));
L.push_back(make_pair(r[i] + 1, make_pair(r[i], 1)));
L.push_back(make_pair(r[j] + 1, make_pair(-l[i], 0)));
L.push_back(make_pair(r[j] + 1, make_pair(-r[i], 1)));
}
}
}
for (int i = 0; i < ((int)(L).size()); ++i)
L[i].second.first = -L[i].second.first;
sort((L).begin(), (L).end());
multiset<int> s[2];
N /= 2;
for (int i = 0; i < ((int)(L).size()); ++i) {
if (L[i].second.first < 0)
s[L[i].second.second].insert(-L[i].second.first);
else
s[L[i].second.second].erase(
s[L[i].second.second].lower_bound(L[i].second.first));
if (((int)(s[0]).size()) == N && ((int)(s[1]).size()) == N &&
*s[0].rbegin() <= *s[1].begin())
if (i < ((int)(L).size()) - 1 && L[i].first < L[i + 1].first)
check(L[i].first, L[i + 1].first - 1, *s[0].rbegin(), *s[1].begin());
}
fail();
fclose(stdin);
fclose(stdout);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int a, b, i;
cin >> a >> b;
if ((abs(a - b) + 1) % 2 == 0) {
long long int temp = (abs(a - b) + 1) / 2;
cout << temp * temp << endl;
} else {
long long int temp = (abs(a - b) + 1) / 2;
cout << temp * (temp + 1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c[300000], c2[300000];
pair<int, int> order[300000];
vector<pair<int, int> > occ[300000];
int last[300000], last2[300000], pos[300000];
int main() {
int i, j;
int t, n, q, k;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &q);
for (i = 0; i < q; i++) {
scanf("%d", &k), c[i].resize(k);
for (j = 0; j < k; j++) scanf("%d", &c[i][j]), c[i][j]--;
order[i] = make_pair(k, i);
}
sort(order, order + q);
for (i = 0; i < q; i++) c2[i] = c[order[i].second];
for (i = 0; i < q; i++) c[i] = c2[i];
long long int sum = 0;
for (i = 0; i < q; i++) sum += c[i].size();
long long int best = sum * q, sum2 = 0;
int p = -1, bad = 0;
for (i = 0; i < q; i++) {
sum2 += (long long int)c[i].size() * (c[i].size() - 1) / 2;
long long int x = sum2 + sum * (q - i - 1);
if (x < best) best = x, p = i;
}
for (i = 0; i <= p; i++) {
for (j = 0; j < c[i].size() - 1; j++)
occ[c[i][j]].push_back(make_pair(i, j));
}
fill(last, last + n, -1);
for (i = 0; i < n; i++) {
for (j = 0; j < occ[i].size(); j++) {
int x = c[occ[i][j].first][occ[i][j].second + 1];
for (k = occ[i][j].second + 1; k < c[occ[i][j].first].size(); k++) {
int y = c[occ[i][j].first][k];
if ((last[y] == i) && (last2[y] != x)) {
bad = 1;
break;
}
last[y] = i, last2[y] = x;
}
if (bad) break;
}
if (bad) break;
}
if (!bad) {
for (i = p + 1; i < q; i++) {
for (j = 0; j < c[i].size(); j++) pos[c[i][j]] = j + 1;
for (j = 0; j < q; j++) {
int e = c[i].size();
for (k = 0; k < c[j].size(); k++) {
if (pos[c[j][k]] != 0) {
if ((k < c[j].size() - 1) && (pos[c[j][k]] < c[i].size()) &&
(c[j][k + 1] != c[i][pos[c[j][k]]]))
e = min(e, pos[c[j][k]]);
if (pos[c[j][k]] > e) {
bad = 1;
break;
}
}
}
if (bad) break;
}
for (j = 0; j < c[i].size(); j++) pos[c[i][j]] = 0;
if (bad) break;
}
}
printf(bad ? "Human\n" : "Robot\n");
for (i = 0; i < n; i++) occ[i].clear();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long power(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x % mod;
if (n % 2 == 0) {
long long y = power(x, n / 2) % mod;
return (y * y) % mod;
}
if (n & 1) {
long long y = power(x, n - 1);
return (x % mod * y % mod) % mod;
}
return 0;
}
const long long maxn = 1000005;
void solve() {
long long n, i, j, k, m, q;
cin >> n >> m >> k;
long long ar[n];
for (i = 0; i < n; i++) cin >> ar[i];
long long sum = 0, cnt = 0, ans = 0;
for (i = n - 1; i >= 0; i--) {
if (sum + ar[i] <= k)
sum += ar[i];
else
cnt++, sum = ar[i];
if (cnt == m) break;
ans++;
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[2050][15][50];
int data[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool judge(int d, int m, int y) {
if (y <= 2015 && y >= 2013) {
if (m >= 1 && m <= 12) {
if (d >= 1 && d <= data[m - 1]) return true;
}
}
return false;
}
const int N = 1e5 + 100;
char st[N];
int getnex(int x, int n, int &len) {
int now = 0;
len = 0;
for (int i = x; i < n; i++) {
if (st[i] == '-') break;
now *= 10;
now += st[i] - '0';
len++;
if (len == 4) return now;
}
return now;
}
vector<int> G;
int main() {
scanf("%s", st);
int len = strlen(st);
for (int i = 0; i < len; i++) {
if (st[i] == '-') G.push_back(i);
}
for (int i = 0; i < len; i++) {
if (st[i] == '-') continue;
int l;
int d = getnex(i, len, l);
if (l != 2) d = 100;
int now = upper_bound(G.begin(), G.end(), i) - G.begin();
if (now == G.size()) continue;
int m = getnex(G[now] + 1, len, l);
if (l != 2) m = 100;
now = upper_bound(G.begin(), G.end(), G[now]) - G.begin();
if (now == G.size()) continue;
int y = getnex(G[now] + 1, len, l);
if (l != 4) y = 0;
if (judge(d, m, y)) {
ans[y][m][d]++;
}
}
int mx = 0;
int dd = 0, mm = 0, yy = 0;
for (int i = 2013; i <= 2015; i++) {
for (int j = 1; j <= 12; j++) {
for (int k = 1; k <= 31; k++) {
if (ans[i][j][k] > mx) {
mx = ans[i][j][k];
yy = i, mm = j, dd = k;
}
}
}
}
printf("%02d-%02d-%d\n", dd, mm, yy);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 * 1000 + 10;
int ans[MAXN][MAXN];
int main() {
int n, d, k;
scanf("%d%d%d", &n, &k, &d);
long long is = 1;
for (int i = 1; i <= d && is < n; ++i) is *= k;
if (is < n) {
puts("-1");
return 0;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < d; j++) ans[i][j] = ans[i - 1][j];
for (int j = d - 1; j >= 0; j--) {
ans[i][j] = (ans[i][j] + 1) % k;
if (ans[i][j]) break;
}
}
for (int i = 0; i < d; i++, cout << endl)
for (int j = 0; j < n; j++) cout << ans[j][i] + 1 << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
using std::cin;
using std::cout;
std::string number;
cin >> number;
if (number.find("0") != std::string::npos)
number.erase((unsigned)number.find("0"), 1);
else
number.erase(1, 1);
cout << number;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, i, l = 0, r, tmp;
string rs;
cin >> n;
r = n - 1;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
tmp = 0;
while (l != r) {
if (a[r] > tmp && (a[r] < a[l] || a[l] < tmp)) {
tmp = a[r];
rs.push_back('R');
r--;
} else if (a[l] > tmp && (a[l] < a[r] || a[r] < tmp)) {
tmp = a[l];
rs.push_back('L');
l++;
} else
break;
}
if (a[(l + r) / 2] > tmp && r == l) rs.push_back('L');
cout << rs.size() << endl << rs;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int oo = 1e9, bpr = 1e9 + 7, N = 2e5 + 100;
int n, m, q, x[N], y[N], l[N], r[N], s[N], t[N];
vector<int> g[N];
int d[1001][1001];
int ans[N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= q; ++i) {
scanf("%d%d%d%d", &l[i], &r[i], &s[i], &t[i]);
g[r[i]].emplace_back(i);
}
memset(d, -1, sizeof(d));
for (int i = 1; i <= n; ++i) d[i][i] = oo;
for (int i = 1; i <= m; ++i) {
int mxc;
for (int j = 1; j <= n; ++j) {
mxc = max(d[y[i]][j], d[x[i]][j]);
d[y[i]][j] = d[x[i]][j] = mxc;
}
d[y[i]][x[i]] = d[x[i]][y[i]] = i;
for (auto it : g[i]) {
if (d[t[it]][s[it]] >= l[it]) ans[it] = 1;
}
}
for (int i = 1; i <= q; ++i) {
if (ans[i])
puts("Yes");
else
puts("No");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = a[i] % 3;
}
int c0 = 0, c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0)
c0++;
else if (a[i] == 1)
c1++;
else
c2++;
}
int ans = c0 / 2 + min(c1, c2);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int A[N], f[3], n, s;
inline int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; ++i) scanf("%d", A + i), ++f[A[i] - 3];
int res(~0u >> 2), ri, rk, rj;
for (int i = s / n; i >= 0; --i) {
int tw = s - i * f[0], si = i * f[0];
if (tw % gcd(f[1], f[2])) continue;
for (int j = min(tw / (f[1] + f[2]), (si + res) / f[1]);
j >= i && j >= (si - res) / f[1]; --j) {
int sj = j * f[1], k = (tw - sj) / f[2], sk = k * f[2];
int w1 = sk - sj, w2 = si - sj;
if (w1 > res || w2 > res || w1 + w2 > res) break;
if (si + sj + sk != s) continue;
int cr = abs(w1) + abs(w2);
if (cr < res) res = cr, ri = i, rj = j, rk = k;
}
}
if (res == (~0u >> 2))
puts("-1");
else
printf("%d %d %d\n", ri, rj, rk);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool sortcoll(vector<long long int> &v1, vector<long long int> &v2) {
return v1[1] < v2[1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
;
vector<vector<long long int> > graph(n, vector<long long int>(n, INT_MAX));
while (m--) {
long long int x, y;
cin >> x >> y;
graph[x - 1][y - 1] = arr[y - 1];
graph[y - 1][x - 1] = arr[x - 1];
}
long long int minCost = 0;
for (int i = 0; i < n - 1; i++) {
long long int maxpos = 0;
for (int i = 1; i < n; i++) {
if (arr[i] > arr[maxpos]) maxpos = i;
}
long long int cost = 0;
vector<long long int> index;
for (int i = 0; i < n; i++) {
if (arr[i] == arr[maxpos]) index.push_back(i);
}
long long int count = 0;
for (int j = 0; j < n; j++) {
if (graph[maxpos][j] != INT_MAX) {
cost += graph[maxpos][j];
count++;
}
}
for (int k = 0; k < index.size(); k++) {
long long int temp = 0, sum = 0;
for (int j = 0; j < n; j++) {
if (graph[index[k]][j] != INT_MAX) {
temp++;
sum += graph[index[k]][j];
}
}
if (temp > count) {
count = temp;
cost = sum;
maxpos = index[k];
}
}
minCost += cost;
for (int j = 0; j < n; j++) {
if (graph[maxpos][j] != INT_MAX) {
graph[maxpos][j] = INT_MAX;
graph[j][maxpos] = INT_MAX;
}
}
arr[maxpos] = INT_MIN;
}
cout << minCost;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int N, K, f[2005][2005], g[2005][2005];
char S[2005];
void doit() {
scanf("%d%d%s", &N, &K, S + 1), f[0][0] = g[0][0] = 1;
for (int i = 1; i <= N; i++)
for (int j = 0; j <= K; j++) {
f[i][j] = 1ll * g[i - 1][j] * (S[i] - 97) % 1000000007;
for (int k = 0, t; k < i && (t = (k + 1) * (N - i + 1)) <= j; k++)
(f[i][j] += 1ll * f[i - k - 1][j - t] * (122 - S[i]) % 1000000007) %=
1000000007;
g[i][j] = (g[i - 1][j] + f[i][j]) % 1000000007;
}
printf("%d\n", g[N][K]);
}
int main() {
doit();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int ch[maxn][26], End[maxn], fail[maxn];
int num[maxn], q[maxn], head, tail, cnt;
char c[maxn];
void insert(int opt) {
int Now = 0;
for (int i = 1; c[i]; i++) {
if (!ch[Now][c[i] - 'a']) ch[Now][c[i] - 'a'] = ++cnt;
Now = ch[Now][c[i] - 'a'];
}
End[Now] += num[opt];
}
void failbuild() {
for (int i = 0; i < 26; i++)
if (ch[0][i]) q[++head] = ch[0][i];
while (tail < head) {
int Now = q[++tail];
End[Now] += End[fail[Now]];
for (int i = 0; i < 26; i++) {
if (ch[Now][i]) {
q[++head] = ch[Now][i];
fail[ch[Now][i]] = ch[fail[Now]][i];
} else
ch[Now][i] = ch[fail[Now]][i];
}
}
}
struct mat {
long long mp[maxn][maxn];
mat() {}
mat(long long x) {
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) mp[i][j] = x;
}
mat friend operator*(mat a, mat b) {
mat res(-1);
for (int k = 0; k <= cnt; k++)
for (int i = 0; i <= cnt; i++)
for (int j = 0; j <= cnt; j++) {
if (a.mp[i][k] != -1 && b.mp[k][j] != -1)
res.mp[i][j] = max(res.mp[i][j], a.mp[i][k] + b.mp[k][j]);
}
return res;
}
mat friend operator^(mat a, long long x) {
mat res(-1);
res.mp[0][0] = 0;
while (x) {
if (x & 1) res = res * a;
a = a * a;
x >>= 1;
}
return res;
}
};
mat a;
void failmat() {
for (int i = 0; i <= cnt; i++)
for (int j = 0; j <= cnt; j++) a.mp[i][j] = -1;
for (int i = 0; i <= cnt; i++) {
for (int j = 0; j < 26; j++) a.mp[i][ch[i][j]] = End[ch[i][j]];
}
}
int main() {
int N, i, j;
long long L, Max = 0;
scanf("%d%I64d", &N, &L);
for (i = 1; i <= N; i++) scanf("%d", &num[i]);
for (i = 1; i <= N; i++) {
scanf("%s", c + 1);
insert(i);
}
failbuild();
failmat();
mat ans = a ^ L;
for (i = 0; i <= cnt; i++) Max = max(Max, ans.mp[0][i]);
printf("%I64d\n", Max);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
double m, n;
cin >> m >> n;
long double ans = 0;
for (double i = 1; i <= m; i++) {
ans += i * (pow(i / m, n) - pow((i - 1) / m, n));
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
void solve() {
int alph[26], alph1[26];
for (int i = 0; i < 26; i++) alph[i] = alph1[i] = 0;
int a, b, l, r, dif, ans1 = INF;
string s, s1;
cin >> a >> b >> l >> r;
--l;
--r;
char d;
for (char c = 'a'; c - 'a' < a; c++) {
if (a > b && c - 'a' == b) d = c;
s += c;
if (a > b) s1 += c;
if (c - 'a' == a - 1) {
for (int i = 0; i < b; i++) {
s += c;
if (a > b) s1 += d;
}
}
}
int sz = s.length(), times = 0, times1 = 0;
for (int i = sz - 1; times < a; i--) {
alph[s[i] - 'a']++;
if (a > b) alph1[s1[i] - 'a']++;
times++;
}
times = 0;
if (!(a > b)) times1 = INF;
char c = 'a';
for (int i = 0; times < a || times1 < a; i++) {
if (times1 == b) d = c;
if (alph[i] == 0) {
s += c;
times++;
if (times == a) {
for (int j = 0; j < b; j++) {
s += c;
}
}
}
if (alph1[i] == 0) {
if (a > b) s1 += c;
times1++;
if (times1 == a) {
for (int j = 0; j < b; j++) {
s1 += d;
}
}
}
c++;
}
for (int i = 0; i < 26; i++) alph[i] = alph1[i] = 0;
dif = l;
l = l % (2 * (a + b));
dif -= l;
r -= dif;
int idx = l;
for (int i = 0; i < min(2 * (a + b), r - l + 1); i++) {
alph[s[idx % (2 * (a + b))] - 'a']++;
if (a > b) alph1[s1[idx % (2 * (a + b))] - 'a']++;
idx++;
}
int answer = 0;
if (a > b) ans1 = 0;
for (int i = 0; i < 26; i++) {
if (alph[i]) answer++;
if (alph1[i]) ans1++;
}
cout << min(answer, ans1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int d[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
struct node {
long long val, last;
} dp[maxn][3];
long long h1[maxn], h2[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d", &(h1[i]));
for (int i = 1; i <= n; i++) scanf("%I64d", &(h2[i]));
dp[0][0].last = -1;
for (int i = 1; i <= n; i++) {
if (dp[i - 1][1].val >= dp[i - 1][2].val)
dp[i][0].val = dp[i - 1][1].val, dp[i][0].last = 1;
else
dp[i][0].val = dp[i - 1][2].val, dp[i][0].last = 2;
if (dp[i - 1][0].val >= dp[i][0].val)
dp[i][0].val = dp[i - 1][0].val, dp[i][0].last = dp[i - 1][0].last;
dp[i][1].val = dp[i - 1][2].val + h1[i];
if (dp[i - 1][0].last != 1 && dp[i][1].val < dp[i - 1][0].val + h1[i]) {
dp[i][1].val = dp[i - 1][0].val + h1[i];
}
dp[i][2].val = dp[i - 1][1].val + h2[i];
if (dp[i - 1][0].last != 2 && dp[i][2].val < dp[i - 1][0].val + h2[i]) {
dp[i][2].val = dp[i - 1][0].val + h2[i];
}
}
cout << max(dp[n][1].val, max(dp[n][2].val, dp[n][0].val)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using iii = tuple<int, int, int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int N;
bool f = false;
string A, B;
cin >> N >> A >> B;
int C[26] = {}, D[26] = {};
for (char c : A) C[c - 'a']++;
for (char c : B) D[c - 'a']++;
for (int i = 0; i < 26; i++)
if (f = C[i] != D[i]) break;
if (f) {
cout << "NO\n";
continue;
}
for (int i = 0; i < 26; i++)
if (f = C[i] >= 2) break;
if (f) {
cout << "YES\n";
continue;
}
int a = 0, b = 0;
for (int i = 1; i < N; i++)
for (int j = 1; j < N; j++)
if (A[j] < A[j - 1]) {
a++;
swap(A[j], A[j - 1]);
}
for (int i = 1; i < N; i++)
for (int j = 1; j < N; j++)
if (B[j] < B[j - 1]) {
b++;
swap(B[j], B[j - 1]);
}
cout << (a % 2 == b % 2 ? "YES" : "NO") << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n / 2 + 1; i++) {
for (j = 0; j < n / 2 - i; j++) {
printf("*");
}
for (j = 0; j < (i * 2 + 1); j++) {
printf("D");
}
for (j = 0; j < n / 2 - i; j++) {
printf("*");
}
printf("\n");
}
for (i = 1; i <= n / 2; i++) {
for (j = 0; j < i; j++) {
printf("*");
}
for (j = 0; j < (n - (2 * i)); j++) {
printf("D");
}
for (j = 0; j < i; j++) {
printf("*");
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
long long int INF = 1e18;
long long int po(long long int a, long long int b) {
long long int re = 1;
while (b) {
if (b % 2 == 1) {
re = (re * a);
}
a = (a * a);
b >>= 1;
}
return re;
}
vector<long long int> pri;
bool p[100001];
int main() {
int test = 1;
for (int i = (2); i < (100001); i++) {
if (p[i] == 0) {
pri.push_back(i);
for (int j = 2 * i; j < 1001; j += i) p[j] = 1;
}
}
cin >> test;
while (test--) {
long long int q, x = 1, r = 1000000000, g, g2;
int j = 0, pj = 0;
vector<long long int> oc;
int i = 0;
while (1) {
q = 1;
pj = j;
while (q < 1e15) {
q *= pri[j];
j++;
}
cout << "? " << q << '\n';
cin >> g;
i++;
if (i == 22) break;
q = 1;
for (int k = (pj); k < (j); k++) {
if (g % pri[k] == 0) {
oc.push_back(pri[k]);
if (q == 1) {
q = po(pri[k], (log(r) / log(pri[k])));
} else {
q *= po(pri[k], (log(r) / log(pri[k])));
cout << "? " << q << '\n';
cin >> g2;
i++;
if (i == 22) break;
q = 1;
x *= g2;
r /= g2;
}
}
}
if (i >= 22) break;
if (q > 1) {
cout << "? " << q << '\n';
cin >> g2;
i++;
if (i == 22) break;
q = 1;
x *= g2;
r /= g2;
}
}
long long int ans = 1, ni = 9;
for (int i = (0); i < (oc.size()); i++) {
int c = 1;
while (x % oc[i] == 0) {
c++;
x /= oc[i];
}
ans *= c;
}
cout << "! " << max(ans * 2, ans + 7) << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace FastRead {
char __buff[5000];
int __lg = 0, __p = 0;
char nc() {
if (__lg == __p) {
__lg = fread(__buff, 1, 5000, stdin);
__p = 0;
if (!__lg) return EOF;
}
return __buff[__p++];
}
template <class T>
void read(T& __x) {
T __sgn = 1;
char __c;
while (!isdigit(__c = nc()))
if (__c == '-') __sgn = -1;
__x = __c - '0';
while (isdigit(__c = nc())) __x = __x * 10 + __c - '0';
__x *= __sgn;
}
} // namespace FastRead
using namespace FastRead;
using namespace std;
const int N = 3e5 + 10;
const int M = 1e9 + 7;
const long double PI = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, q, m, x, y;
int root[N], h[N], fr[N];
vector<int> G[N], path[N];
int find(int r) { return (root[r] == r ? r : root[r] = find(root[r])); }
void unite(int x, int y) {
x = root[x];
y = root[y];
if (h[x] < h[y])
root[x] = y;
else if (h[x] > h[y])
root[y] = x;
else
root[x] = y, ++h[y];
}
bool dfs(int curr, int parent, int asked, int cnt) {
if (curr == asked) {
path[cnt].push_back(curr);
return 1;
}
for (auto i : G[curr])
if (i != parent) {
bool ok = dfs(i, curr, asked, cnt);
if (ok == 1) {
path[cnt].push_back(curr);
return 1;
}
}
return 0;
}
void Test() {
int i;
cin >> n >> m;
for (i = 1; i <= n; i++)
path[i].clear(), fr[i] = 0, G[i].clear(), root[i] = i, h[i] = 1;
for (i = 1; i <= m; i++) {
cin >> x >> y;
if (find(x) == find(y)) continue;
unite(x, y);
G[x].push_back(y);
G[y].push_back(x);
}
cin >> q;
int cnt = 0;
while (q--) {
cin >> x >> y;
++fr[x], ++fr[y];
dfs(x, 0, y, ++cnt);
}
int add = 0;
for (i = 1; i <= n; i++) add += fr[i] & 1;
if (add) return cout << "NO\n" << add / 2 << '\n', void();
cout << "YES\n";
for (i = 1; i <= cnt; i++) {
cout << path[i].size() << '\n';
reverse(path[i].begin(), path[i].end());
for (auto j : path[i]) cout << j << ' ';
cout << '\n';
}
}
signed main() {
int q = 1;
while (q--) Test();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<long long int> s;
void sieve() {
std::vector<bool> arr(1000001, true);
for (long long int i = 3; i * i < 1000001; i += 2) {
if (arr[i] == true) {
for (long long int j = i * i; j <= 1000001; j += i) arr[j] = false;
}
}
s.insert(2);
for (long long int i = 3; i * i < 1000001; i += 2) {
if (arr[i]) s.insert(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int arr[n];
set<long long int> s;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
s.insert(arr[i]);
}
if (s.find(0) != s.end())
cout << s.size() - 1 << endl;
else
cout << s.size() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[1005], x, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
x = arr[n - 1] - arr[0];
x = x + 1;
x = x - n;
cout << x << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void ri(int &a) {
a = 0;
register int x = getchar_unlocked();
bool neg = false;
while (x < '0' || x > '9') {
if (x == '-') neg = true;
x = getchar_unlocked();
}
while (x >= '0' && x <= '9') {
a = (a << 3) + (a << 1) + (x - '0');
x = getchar_unlocked();
}
if (neg) a = -a;
}
const int maxn = 100100, INF = (1 << 30) - 1, alpha = 28;
int n;
map<string, vector<int>> pref, suff;
string str[maxn];
bool used[alpha];
int par[alpha], rnk[alpha];
bool check[alpha];
void no() {
printf("NO\n");
exit(0);
}
int getpar(int a) { return a == par[a] ? a : par[a] = getpar(par[a]); }
void mrg(int a, int b) {
int A = getpar(a), B = getpar(b);
if (A == B) return;
if (rnk[A] > rnk[B]) {
par[B] = A;
} else if (rnk[B] > rnk[A]) {
par[A] = B;
} else {
par[A] = B;
rnk[A]++;
}
}
string addTo(int flag, string ans) {
string tempStr;
bool found = false;
for (char c = 'a'; !found && c <= 'z'; c++) {
if (used[c - 'a']) continue;
if (flag == 0) {
tempStr = c + ans;
string prefIt = "";
prefIt += tempStr[0];
for (int i = 1; i < tempStr.size(); i++) {
prefIt += tempStr[i];
if (suff[prefIt].size() > 0) {
found = true;
used[c - 'a'] = true;
break;
}
}
} else {
tempStr = ans + c;
string suffIt = "";
suffIt += tempStr[tempStr.size() - 1];
for (int i = tempStr.size() - 2; i >= 0; i--) {
suffIt = tempStr[i] + suffIt;
if (pref[suffIt].size() > 0) {
found = true;
used[c - 'a'] = true;
break;
}
}
}
}
if (found) {
return addTo(flag, tempStr);
}
return ans;
}
int main() {
ri(n);
for (int i = 0; i < n; i++) {
cin >> str[i];
if (str[i].size() > 26) {
no();
}
int cnt[alpha];
memset(cnt, 0, sizeof(cnt));
string prefIt = "", suffIt = "";
for (int j = 0; j < str[i].size(); j++) {
prefIt += str[i][j];
cnt[str[i][j] - 'a']++;
if (cnt[str[i][j] - 'a'] > 1) {
no();
}
pref[prefIt].push_back(i);
}
for (int j = str[i].size() - 1; j >= 0; j--) {
suffIt = str[i][j] + suffIt;
suff[suffIt].push_back(i);
}
}
for (int i = 0; i < alpha; i++) {
par[i] = i;
}
for (int i = 0; i < n; i++) {
for (char c : str[i]) {
mrg(c - 'a', str[i][0] - 'a');
}
}
vector<string> ans;
for (int i = 0; i < n; i++) {
int num = getpar(str[i][0] - 'a');
if (!check[num]) {
for (char c : str[i]) {
used[c - 'a'] = true;
}
ans.push_back(addTo(1, addTo(0, str[i])));
check[num] = true;
}
}
sort(ans.begin(), ans.end());
string prnt = "";
for (string add : ans) {
prnt += add;
}
map<string, bool> occ;
for (int i = 0; i < prnt.size(); i++) {
string ss = "";
ss += prnt[i];
occ[ss] = true;
for (int j = i + 1; j < prnt.size(); j++) {
ss += prnt[j];
occ[ss] = true;
}
}
for (int i = 0; i < n; i++) {
if (!occ[str[i]]) {
no();
}
}
cout << prnt << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "inline", "Ofast")
using namespace std;
const int N = 5e5 + 100;
int n, c0 = 0, c1 = 0, nxt[N];
char s[N], t[N];
void cal_fail() {
int k = -1;
nxt[1] = 0;
for (int i = 2; i <= n; i++) {
while (t[k + 1] != t[i] && k) k = nxt[k];
if (t[k + 1] == t[i]) ++k;
nxt[i] = k;
}
}
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == '0') c0++;
if (s[i] == '1') c1++;
}
scanf("%s", t + 1), n = strlen(t + 1);
cal_fail();
int ps = 0;
while (1) {
++ps;
if (t[ps] == '0' && !c0) break;
if (t[ps] == '1' && !c1) break;
if (t[ps] == '0') printf("0"), --c0;
if (t[ps] == '1') printf("1"), --c1;
if (ps == n) ps = nxt[ps];
}
if (c0) {
for (int i = 1; i <= c0; i++) printf("0");
}
if (c1) {
for (int i = 1; i <= c1; i++) printf("1");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _IOS() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
}
const long long mod = 1e9 + 7;
long long n, m, k, w;
long long a[100009];
bool ch(char s) {
return s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u';
}
bool palid(string s) {
int n = s.length();
for (int i = 0; i < n / 2; i++)
if (s[i] != s[n - i - 1]) return 0;
return 1;
}
int mp[200005];
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0;
bool f = 1;
while (i >= 0 && i < n) {
if (mp[i]) {
f = 0;
break;
}
mp[i] = 1;
if (s[i] == '>')
i += a[i];
else
i -= a[i];
}
if (f)
cout << "FINITE";
else
cout << "INFINITE";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k, c = 0;
cin >> n >> k;
long long int a[2 * n + 2];
for (long long int i = 1; i <= 2 * n + 1; ++i) {
cin >> a[i];
}
for (long long int i = 1; i <= 2 * n + 1; ++i) {
if (i % 2 == 0 && c < k && a[i] - 1 > a[i - 1] && a[i] - 1 > a[i + 1])
cout << a[i] - 1 << " ", c++;
else
cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 1e5 + 10;
long double a[20];
string s[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y", "y^x^z", "y^z^x",
"(y^x)^z", "(y^z)^x", "z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
int main() {
long double x, y, z;
while (cin >> x >> y >> z) {
a[0] = pow(y, z) * log(x);
a[1] = pow(z, y) * log(x);
a[2] = z * y * log(x);
a[3] = y * z * log(x);
a[4] = pow(x, z) * log(y);
a[5] = pow(z, x) * log(y);
a[6] = x * z * log(y);
a[7] = x * z * log(y);
a[8] = pow(x, y) * log(z);
a[9] = pow(y, x) * log(z);
a[10] = y * x * log(z);
a[11] = x * y * log(z);
int index = 0;
for (int i = 1; i < 12; ++i) {
if (a[i] > a[index]) {
index = i;
}
}
cout << s[index] << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100009];
int b[100009], c[100009];
int used[100009];
int main() {
cin >> n;
if (n == 1) {
cout << 0 << endl << 0 << endl << 0 << endl;
return 0;
}
if (n % 2 == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n - 2; i++) a[i] = b[i] = i - 1;
a[n] = b[n] = n - 2;
a[n - 1] = b[n - 1] = n - 1;
for (int i = 1; i <= n; i++) c[i] = (a[i] + b[i]) % n;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
for (int i = 1; i <= n; i++) cout << b[i] << " ";
cout << endl;
for (int i = 1; i <= n; i++) cout << c[i] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v, dp;
vector<int> vis, dep;
int dfs(int x) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (vis[y] == 0) {
dp[y][0] = x;
dep[y] = dep[x] + 1;
dfs(y);
}
}
return 0;
}
int lift(int x, int val) {
for (int i = 0; i <= 25; i++) {
if ((1 << i) & val) x = dp[x][i];
}
return x;
}
int lca(int x, int y) {
if (dep[x] > dep[y]) {
x = lift(x, dep[x] - dep[y]);
}
if (dep[y] > dep[x]) {
y = lift(y, dep[y] - dep[x]);
}
if (x == y) {
return x;
} else {
for (int i = 25; i >= 0; i--) {
if (dp[x][i] != dp[y][i]) {
x = dp[x][i];
y = dp[y][i];
}
}
return dp[x][0];
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
v.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dp.resize(n + 1);
for (int i = 0; i <= n; i++) dp[i].resize(26, -1);
vis.resize(n + 1, 0);
dep.resize(n + 1, 0);
dep[1] = 1;
dfs(1);
for (int j = 1; j <= 25; j++) {
for (int i = 1; i <= n; i++) {
int x = dp[i][j - 1];
if (x != -1) {
dp[i][j] = dp[x][j - 1];
}
}
}
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int lc1 = lca(a, b);
int u = dep[a] + dep[b] - 2 * dep[lc1];
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
int lc2 = lca(x, a);
int lc3 = lca(a, y);
int lc4 = lca(x, b);
int lc5 = lca(y, b);
int path1 =
1 + dep[a] + dep[x] - 2 * dep[lc2] + dep[b] + dep[y] - 2 * dep[lc5];
int path2 =
1 + dep[a] + dep[y] - 2 * dep[lc3] + dep[b] + dep[x] - 2 * dep[lc4];
u = path1;
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
u = path2;
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
cout << "NO"
<< "\n";
continue;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << "," << a.second << ")";
}
template <class A>
ostream &operator<<(ostream &out, const vector<A> &a) {
for (const A &it : a) out << it << " ";
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
return in >> a.first >> a.second;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &i : a) in >> i;
return in;
}
ifstream cinn("in.txt");
ofstream coutt("out.txt");
long long poww(const long long &a, long long b,
const long long &m = 1000000007) {
if (b == 0) return 1;
long long first = poww(a, b / 2, m);
first = first * first % m;
if (b & 1) first = first * a % m;
return first;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
long long rint(long long l, long long r) { return rand() % (r - l + 1) + l; }
const long long N = 5e5 + 5;
long long st[N];
vector<long long> ans(N + 1);
void build(long long n, long long l, long long r) {
if (l == r) {
st[n] = ans[l];
return;
}
long long mid = (l + r) / 2;
build(n * 2, l, mid);
build((n * 2) + 1, mid + 1, r);
st[n] = st[n * 2] & st[(n * 2) + 1];
}
long long query(long long n, long long l, long long r, long long a,
long long b) {
if (l > b || r < a) {
return -1;
} else if (l >= a && r <= b) {
return st[n];
}
long long mid = (l + r) / 2;
long long leftQuery = query(n * 2, l, mid, a, b);
long long rightQuery = query(n * 2 + 1, mid + 1, r, a, b);
long long q = 0;
if (rightQuery == -1) {
return leftQuery;
}
if (leftQuery == -1) {
return rightQuery;
}
return leftQuery & rightQuery;
}
vector<long long> graph[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j, first;
long long n, m;
cin >> n >> m;
long double ans = 0;
long long nodes[n + 1];
for (i = 0; i < n; i++) {
cin >> nodes[i + 1];
}
long long l, r, c;
for (i = 0; i < m; i++) {
cin >> l >> r >> c;
ans = max(ans, ((long double)nodes[l] + nodes[r]) / c);
}
cout << fixed << setprecision(10) << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &p) {
out << p.first << " " << p.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &vec) {
for (auto &el : vec) {
in >> el;
}
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &vec) {
for (auto &el : vec) {
out << el << " ";
}
return out;
}
vector<vector<int>> g;
vector<vector<int>> used;
vector<int> st;
int canDraw = 0;
void dfs(int u, int p) {
st.push_back(u);
used[u][p] = 1;
if (p == 1 && g[u].empty()) {
cout << "Win" << '\n';
for (int el : st) {
cout << el + 1 << " ";
}
cout << '\n';
exit(0);
}
for (int v : g[u]) {
if (!used[v][1 - p]) {
dfs(v, 1 - p);
} else if (used[v][1 - p] == 1) {
canDraw = 1;
}
}
used[u][p] = 2;
st.pop_back();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
used.resize(n, vector<int>(2));
g.resize(n);
for (int i = 0; i < n; i++) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
x--;
g[i].push_back(x);
}
}
int s;
cin >> s;
dfs(s - 1, 0);
if (canDraw) {
cout << "Draw";
} else {
cout << "Lose";
}
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (n < k) {
if (k % n != 0)
cout << k / n + 1;
else
cout << k / n;
} else
cout << 1;
return 0;
}
| 1 |
#include<algorithm>
#include<iostream>
#include<sstream>
#include<cstring>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<deque>
#include<cmath>
#include<map>
#include<set>
#define AC 0
#define endl '\n'
#define PI acos(-1)
#define Please return
#define int long long
using namespace std;
const int N=2e5+7;
const int mod=1e9+7;
const int INF=0x3f3f3f3f;
const double eps=1e-8;
int gcd(int a,int b){return b==0?a:gcd(b,a%b);}
int lcm(int a,int b){return a*b/gcd(a,b);}
int factorials(int a){if(a==0)return 1;return a*factorials(a-1);}
void fastio(){ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);}
int qpow(int a,int b){int ans=1;while(b){if(b&1)ans=ans*a;b>>=1;a=a*a;}return ans;}
int qpow(int a,int b,int m){int ans=1%m;while(b){if(b&1)ans=ans*a%m;b>>=1;a=a*a%m;}return ans;}
int exgcd(int a,int b,int&x,int&y){if(!b){x=1,y=0;return a;}int r=exgcd(b,a%b,x,y);int te=y;y=x-(a/b)*y;x=te;return r;}
int a[N];
int check(int a,int b,int c)
{
return !(a>=b&&b>=c||a<=b&&b<=c);
}
void solve()
{
int n;
cin>>n;
for(int i=1;i<=n;++i)
{
cin>>a[i];
}
int ans=2*n-1;
for(int i=3;i<=n;++i)
{
ans+=check(a[i],a[i-1],a[i-2]);
}
for(int i=4;i<=n;++i)
{
ans+=check(a[i],a[i-1],a[i-2])&&check(a[i],a[i-1],a[i-3])&&check(a[i],a[i-2],a[i-3])&&check(a[i-1],a[i-2],a[i-3]);
}
cout<<ans<<endl;
}
signed main()
{
fastio();
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int t;
t=1;
cin>>t;
while(t--)
{
solve();
}
Please AC;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
;
int vis[100005];
int c[100005];
vector<int> v[100005];
int dfs(int i) {
vis[i] = 1;
int p = c[i];
for (int j = 0; j < v[i].size(); j++) {
if (vis[v[i][j]] == 0) p = min(p, dfs(v[i][j]));
}
return (p);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int x, y;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long int mn = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
mn += dfs(i);
}
}
cout << mn;
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> tab;
int n, k;
bitset<60> dp[60];
bool check(long long val) {
for (int i = 0; i <= n; ++i) dp[i].reset();
dp[0][0] = 1;
for (int i = 1; i <= k; ++i) {
for (int s = 1; s <= n; ++s) {
if (!dp[s - 1][i - 1]) continue;
for (int j = s; j <= n; ++j) {
long long sum = tab[j] - tab[s - 1];
if ((sum & val) == val) dp[j][i] = 1;
}
}
}
return dp[n][k];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
tab.resize(n + 1);
for (int i = 1; i <= n; ++i) {
long long a;
cin >> a;
tab[i] = tab[i - 1] + a;
}
long long res = 0;
for (int i = 60; i >= 0; --i) {
if (check(res + (1LL << i))) res |= 1LL << i;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1234567890;
pair<int, int> g[1010][1010], h[1010][1010];
int f[1010][1010], a[1010], n;
vector<string> vv;
string toStr(int first) {
string ret = "";
while (first > 0) {
char t = (first % 10) + '0';
ret = t + ret;
first /= 10;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
memset(f, 127, sizeof f);
f[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= i; ++j)
if (f[i][j] < oo) {
if (j == 0) {
if (f[i][j] < f[i + 1][i + 1]) {
f[i + 1][i + 1] = f[i][j];
g[i + 1][i + 1] = make_pair(i, j);
h[i + 1][i + 1] = make_pair(0, 0);
}
} else {
if (f[i][j] + max(a[i + 1], a[j]) < f[i + 1][0]) {
f[i + 1][0] = f[i][j] + max(a[i + 1], a[j]);
g[i + 1][0] = make_pair(i, j);
h[i + 1][0] = make_pair(j, i + 1);
}
if (i + 2 <= n) {
if (f[i][j] + max(a[i + 1], a[i + 2]) < f[i + 2][j]) {
f[i + 2][j] = f[i][j] + max(a[i + 1], a[i + 2]);
g[i + 2][j] = make_pair(i, j);
h[i + 2][j] = make_pair(i + 1, i + 2);
}
if (f[i][j] + max(a[j], a[i + 1]) < f[i + 2][i + 2]) {
f[i + 2][i + 2] = f[i][j] + max(a[j], a[i + 1]);
g[i + 2][i + 2] = make_pair(i, j);
h[i + 2][i + 2] = make_pair(j, i + 1);
}
if (f[i][j] + max(a[j], a[i + 2]) < f[i + 2][i + 1]) {
f[i + 2][i + 1] = f[i][j] + max(a[j], a[i + 2]);
g[i + 2][i + 1] = make_pair(i, j);
h[i + 2][i + 1] = make_pair(j, i + 2);
}
}
}
}
int p = n, q, ans = oo, cnt = n;
if (n & 1) {
for (int j = 1; j <= n; ++j)
if (f[n][j] + a[j] < ans) {
ans = f[n][j] + a[j];
q = j;
}
vv.push_back(toStr(q));
cnt -= 1;
} else {
q = 0;
ans = f[n][0];
}
printf("%d\n", ans);
while (cnt > 0) {
if (h[p][q].first > 0 && h[p][q].second > 0) {
vv.push_back(toStr(h[p][q].first) + " " + toStr(h[p][q].second));
cnt -= 2;
}
int p0 = g[p][q].first, q0 = g[p][q].second;
p = p0;
q = q0;
}
for (int i = vv.size() - 1; i >= 0; --i) puts(vv[i].c_str());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isPalindrom(string s) {
if (equal(s.begin(), s.begin() + s.size() / 2, s.rbegin())) return true;
return false;
}
int main() {
string s;
cin >> s;
while (s[0] == '0') {
s.erase(0, 1);
}
while (s[s.size() - 1] == '0') {
s.erase(s.size() - 1, 1);
}
cout << (isPalindrom(s) ? "YES\n" : "NO\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int type[200005];
int tim[200005];
map<int, pair<int, int>> mapp;
void solve() {
mapp.clear();
int n;
long long t, a, b;
int e = 0, h = 0;
scanf("%d %lld %lld %lld", &n, &t, &a, &b);
for (int i = 0; i < n; i++) scanf("%d", &type[i]);
for (int i = 0; i < n; i++) scanf("%d", &tim[i]);
vector<pair<long long, long long>> v;
for (int i = 0; i < n; i++) {
if (type[i] == 0) {
v.push_back(make_pair(tim[i], 0));
e++;
} else {
v.push_back(make_pair(tim[i], 1));
h++;
}
}
for (auto i : v) {
if (mapp.find(i.first) != mapp.end()) {
if (i.second == 0)
mapp[i.first].first++;
else
mapp[i.first].second++;
} else {
if (i.second == 0)
mapp[i.first] = make_pair(1, 0);
else
mapp[i.first] = make_pair(0, 1);
}
}
int p1 = 0, p2 = 0;
int maxi = 0;
for (auto it = mapp.begin(); it != mapp.end(); it++) {
int before = it->first - 1;
if (a * p1 + b * p2 <= before) {
long long plus = min((long long)e - p1, (before - (a * p1 + b * p2)) / a);
if (p1 + p2 + plus > maxi) maxi = p1 + p2 + plus;
if (a * (p1 + plus) + b * p2 <= before) {
long long plus2 =
min((long long)h - p2, (before - (a * (p1 + plus) + b * p2)) / b);
if (p1 + p2 + plus + plus2 > maxi) maxi = p1 + p2 + plus + plus2;
}
}
p1 += it->second.first;
p2 += it->second.second;
}
if (a * e + b * h <= t) maxi = e + h;
printf("%d\n", maxi);
}
int main(void) {
int T_;
scanf("%d", &T_);
while (T_--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n][n];
int cur = n * n, ans = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j >= k - 1; j--) {
a[i][j] = cur;
cur--;
}
ans += (cur + 1);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = k - 2; j >= 0; j--) {
a[i][j] = cur;
cur--;
}
}
cout << ans << endl;
for (__typeof(n) i = (0); i != (n); i++) {
for (__typeof(n) j = (0); j != (n); j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const long long inf = 1e15;
int n;
long long a[N];
bool was[N];
long long f[N];
long long maxf;
vector<int> g[N];
void dfs(int u, int p) {
f[u] = a[u];
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u);
if (f[v] > 0) {
f[u] += f[v];
}
}
}
int ret = 0;
bool mark[N];
void redfs(int u, int p) {
f[u] = a[u];
for (int v : g[u]) {
if (v == p) continue;
redfs(v, u);
if (f[v] > 0 && not mark[v]) {
f[u] += f[v];
}
}
if (f[u] == maxf) {
mark[u] = 1;
ret++;
}
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, -1);
maxf = -inf;
for (int i = 1; i <= n; i++) {
maxf = max(maxf, f[i]);
}
redfs(1, -1);
cout << maxf * ret << " " << ret << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, nd, a[100005], sum;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
sum = a[0];
nd = 1;
for (i = 1; i < n; i++) {
if (a[i] >= sum) {
sum += a[i];
nd++;
}
}
cout << nd;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct info {
long long v1, v2, v3;
} tree[maxn << 2];
long long sum;
int n, m;
long long d[maxn], h[maxn];
info operator+(const info &a, const info &b) {
info ret;
ret.v1 = max(a.v1, b.v1);
ret.v2 = max(a.v2, b.v2);
ret.v3 = max(a.v3, b.v3);
ret.v3 = max(ret.v3, b.v2 + a.v1);
return ret;
}
void build(int cur, int l, int r) {
if (l == r) {
tree[cur].v1 = 2ll * h[l] - d[l];
tree[cur].v2 = 2ll * h[l] + d[l];
tree[cur].v3 = 0;
return;
}
build((cur << 1), l, ((l + r) >> 1));
build((cur << 1 | 1), ((l + r) >> 1) + 1, r);
tree[cur] = tree[(cur << 1)] + tree[(cur << 1 | 1)];
}
info query(int cur, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return tree[cur];
if (qr <= ((l + r) >> 1))
return query((cur << 1), l, ((l + r) >> 1), ql, qr);
else if (ql > ((l + r) >> 1))
return query((cur << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr);
else
return query((cur << 1), l, ((l + r) >> 1), ql, qr) +
query((cur << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr);
}
int main() {
scanf("%d%d", &n, &m);
d[1] = 0;
for (int i = 2; i <= n + 1; i++) {
scanf("%I64d", &d[i]);
d[i] += d[i - 1];
}
sum = d[n + 1];
for (int i = 1; i <= n; i++) scanf("%I64d", &h[i]);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int a, b;
long long ans = 0;
scanf("%d%d", &a, &b);
if (a <= b) {
info p1, p2;
if (1 <= a - 1) p1 = query(1, 1, n, 1, a - 1), ans = max(ans, p1.v3);
if (b + 1 <= n) p2 = query(1, 1, n, b + 1, n), ans = max(ans, p2.v3);
if (1 <= a - 1 && b + 1 <= n) {
ans = max(ans, p1.v2 + p2.v1 + sum);
}
printf("%I64d\n", ans);
} else {
swap(a, b);
a++, b--;
printf("%I64d\n", query(1, 1, n, a, b).v3);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
int main() {
int mas1[105];
int mas2[105][105];
int n;
scanf("%i", &n);
for (int i = 0; i < n; i++) {
scanf("%i", &mas1[i]);
for (int j = 0; j < mas1[i]; j++) {
scanf("%i", &mas2[i][j]);
}
}
for (int i = 0; i < n; i++) {
int mas3[105];
for (int j = 0; j < n; j++) {
mas3[j] = mas1[j];
}
bool wellnull = false;
for (int j = 0; j < mas1[i]; j++) {
bool hasnull = false;
int num = mas2[i][j];
for (int t = 0; t < n; t++) {
if (t != i) {
for (int r = 0; r < mas1[t]; r++) {
if (num == mas2[t][r]) {
mas3[t]--;
if (mas3[t] == 0) hasnull = true;
}
}
}
}
if (hasnull) {
wellnull = true;
printf("NO\n");
j = 100000;
}
}
if (wellnull == false) {
printf("YES\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int N, K;
scanf("%d%d", &N, &K);
int ret = N - 1;
int max = 0;
int part = 0;
for (int i = 0; i < K; i++) {
int M;
scanf("%d", &M);
int a[100001];
if (M == 1) {
scanf("%d", &a[0]);
continue;
}
part += M - 1;
for (int j = 0; j < M; j++) scanf("%d", &a[j]);
int tok = 0;
for (int j = 0; j < M; j++) {
if (a[j] == 1) {
for (int k = j + 1; k < M; k++) {
if (a[k - 1] + 1 == a[k]) {
tok++;
} else
break;
}
break;
} else {
break;
}
}
max = max < tok ? tok : max;
}
printf("%d", ret + part - max * 2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n;
long long w[N], h[N], c[N];
map<long long, map<long long, long long> > cnt;
bool flag = 0;
vector<pair<long long, long long> > vc;
long long Gcd(long long a, long long b) {
if (!a) return b;
if (!b) return a;
return Gcd(b, a % b);
}
bool Is(pair<long long, long long> a, pair<long long, long long> b) {
return a.first == b.first && a.second == b.second;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &w[i], &h[i], &c[i]);
cnt[w[i]][h[i]] += c[i];
}
long long ans = -1;
for (auto now = cnt.begin(); now != cnt.end(); now++) {
long long tmp = -1;
auto &mp = now->second;
for (auto p = mp.begin(); p != mp.end(); p++)
tmp = tmp < 0 ? p->second : Gcd(tmp, p->second);
ans = ans < 0 ? tmp : Gcd(tmp, ans);
for (auto p = mp.begin(); p != mp.end(); p++) p->second /= tmp;
if (!flag) {
vc.clear();
for (auto p = mp.begin(); p != mp.end(); p++) {
vc.push_back(*p);
}
flag = 1;
} else {
int k = 0;
if (mp.size() != vc.size()) {
cout << 0 << endl;
return 0;
}
for (auto p = mp.begin(); p != mp.end(); p++) {
if (!Is(*p, vc[k++])) {
cout << 0 << endl;
return 0;
}
}
}
}
int ct = 0;
for (int i = 1; 1ll * i * i <= ans; i++)
if (ans % i == 0) {
ct++;
if (i * i != ans) ct++;
}
cout << ct << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void taskA1() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int q = sqrt(n), x = n;
for (int i = (2); i <= (q); i++)
if (n % i == 0) {
x = i;
break;
}
n = n + x + (k - 1) * 2;
cout << n << "\n";
}
return;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
taskA1();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double p[100];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lf", p + i);
sort(p, p + n);
double best = 0.0;
for (int i = 0; i < n; ++i) {
double x = 0.0, y = 1.0;
for (int j = i; j < n; ++j)
x = x * (1.0 - p[j]) + y * p[j], y *= (1.0 - p[j]);
best = max(best, x);
}
printf("%.16lf\n", best);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, i, c = 0, x, p = 0;
cin >> n;
long long int a[n];
for (i = 0; i < n; ++i) a[i] = 0;
for (i = 0; i < n; ++i) {
cin >> x;
a[x - 1]++;
}
for (i = 0; i < n; ++i) {
c += (a[i] + p) / (i + 1);
p = (a[i] + p) % (i + 1);
}
cout << c << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, j, ans = 0, product = 1;
;
cin >> n >> k;
if (k >= n / 2) {
cout << n * (n - 1) / 2;
return 0;
}
for (i = 0; i < k; i++) {
ans = ans + n - 1 - i;
}
ans = ans + (n - 2 * k) * (k);
product = k * (k - 1) / 2;
ans = ans + product;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxN = 1e5 + 10;
long long int n, i, a[maxN], mx, cnt, nxt;
stack<pair<long long int, long long int> > st;
int main() {
cin >> n;
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = n - 1; i >= 0; i--) {
while (!st.empty()) {
if (a[i] < st.top().first) break;
cnt++;
cnt = max(cnt, st.top().second);
st.pop();
}
mx = max(mx, cnt);
st.push(make_pair(a[i], cnt));
cnt = 0;
}
cout << mx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> s1, s2, s;
int n;
string k;
cin >> n;
s1.push_back("purple");
s2.push_back("Power");
s1.push_back("green");
s2.push_back("Time");
s1.push_back("blue");
s2.push_back("Space");
s1.push_back("orange");
s2.push_back("Soul");
s1.push_back("red");
s2.push_back("Reality");
s1.push_back("yellow");
s2.push_back("Mind");
while (n--) {
cin >> k;
for (int i = 0; i < 6; i++) {
if (k == s1[i]) {
s1.erase(s1.begin() + i);
s2.erase(s2.begin() + i);
}
}
}
cout << s2.size() << endl;
for (int i = 0; i < s2.size(); i++) {
cout << s2[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500010;
int ara[MAX];
vector<pair<int, int> > V;
vector<int> P;
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &ara[i]);
}
for (int i = 1; i < n; i++) {
V.push_back({ara[i + 1] - ara[i], i});
}
sort(V.begin(), V.end(), cmp);
long long ans = 0;
P.push_back(0);
for (int i = 0; i < k - 1; i++) {
P.push_back(V[i].second);
}
sort(P.begin(), P.end());
P.push_back(n);
for (int i = 1; i < P.size(); i++) {
ans += ara[P[i]] - ara[P[i - 1] + 1];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, mod = 1000 * 1000 * 1000 + 7;
long long dp[N][N];
int main() {
int n, m, x;
cin >> n >> m >> x;
if (n > m) {
cout << 0;
return 0;
}
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = n; j >= 0; j--) {
for (int k = j; k >= 0; k--) {
if (i == x) {
dp[j][k] = 0;
}
if (j > k) {
dp[j][k] += dp[j - 1][k];
}
if (k > 0 && i != x) {
dp[j][k] += dp[j][k - 1];
}
if (k > 0) {
dp[j][k] += dp[j - 1][k - 1];
}
dp[j][k] %= mod;
}
}
}
long long ans = dp[n][n];
for (int i = 1; i <= n; i++) {
ans *= i;
ans %= mod;
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 501;
vector<int> g[maxn];
int was[maxn], st = -1, p[maxn];
vector<int> cycle;
int dfs(int v, int s, int f, int par) {
p[v] = par;
was[v] = 1;
int ans = 0;
for (int x : g[v]) {
if (v != s or x != f) {
if (was[x] == 1)
ans++, p[x] = v, st = x;
else if (was[x] == 0)
ans += dfs(x, s, f, v);
}
}
was[v] = 2;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
if (!was[i]) dfs(i, -1, -1, -1);
}
if (st == -1) {
cout << "YES" << endl;
return 0;
}
for (int i = 1; i <= n; i++) st = p[st];
cycle.push_back(st);
st = p[st];
while (st != cycle[0]) cycle.push_back(st), st = p[st];
cycle.push_back(cycle[0]);
for (int i = 1; i < cycle.size(); i++) {
fill(was, was + n + 1, 0);
int ans = 0;
for (int j = 1; j <= n; j++) {
if (!was[j]) ans += dfs(j, cycle[i], cycle[i - 1], -1);
}
if (ans == 0) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int r;
int p;
int i, j;
scanf("%d", &r);
scanf("%d", &p);
i = 1;
j = ((4 * r) / 2) + 1;
while (i <= ((4 * r) / 2) || j <= p) {
if (j <= p) {
printf("%d ", j);
j++;
}
if (i <= 2 * r) {
if (i <= p) {
printf("%d ", i);
}
i++;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t = 0, p = 0;
cin >> n;
int a[n];
for (int k = 0; k < n; k++) {
cin >> a[k];
if (a[k] > 0) {
p = p + a[k];
}
if ((a[k] == -1)) {
if (p <= 0) {
t = t + 1;
} else
p = p - 1;
}
}
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long cg = 1e9;
const int maxn = 2e5 + 100;
struct Node {
int x, f;
int op;
};
vector<Node> nodes;
map<long long, int> dp;
bool cmp(Node a, Node b) { return a.x < b.x; }
int main() {
int n, x, w, pre = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &w);
Node temp1, temp2;
temp1.x = x - w, temp1.f = -1;
temp2.x = x + w, temp2.f = 1, temp2.op = temp1.x;
nodes.push_back(temp1), nodes.push_back(temp2);
}
sort(nodes.begin(), nodes.end(), cmp);
dp[nodes[0].x + cg] = 0;
for (int i = 1; i < nodes.size(); i++) {
dp[nodes[i].x + cg] = pre;
if (nodes[i].f == 1)
dp[nodes[i].x + cg] = max(dp[nodes[i].x + cg], dp[nodes[i].op + cg] + 1);
pre = dp[nodes[i].x + cg];
}
printf("%d\n", dp[nodes[nodes.size() - 1].x + cg]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int md = (2 << 30);
const long long oo = 1e14;
const double pi = acos(-1);
int dy[] = {0, 1, 0, -1};
int dx[] = {1, 0, -1, 0};
const int N = 1e9 + 5;
bool Is_Prime(int x) {
if (!(x & 1) && x != 2) return 0;
if (!(x % 3) && x != 3) return 0;
for (int i = 5; i * 1LL * i <= x; i += 6)
if (!(x % i) || !(x % (i + 2))) return 0;
return 1;
}
int main() {
int n, m, k, t;
int a, b;
scanf("%d%d%d%d", &n, &m, &k, &t);
pair<int, int> p[k];
for (auto &i : p) scanf("%d%d", &i.first, &i.second);
sort(p, p + k);
while (t--) {
scanf("%d%d", &a, &b);
long long t = (a - 1) * 1LL * m + b;
bool first = 1;
for (int _ = 0; _ < k; ++_) {
if (a == p[_].first && b == p[_].second) first = 0;
if (p[_].first < a)
--t;
else if (p[_].second < b && p[_].first == a)
--t;
else
break;
}
if (first) {
if (t % 3LL == 1)
puts("Carrots");
else if (t % 3LL == 2)
puts("Kiwis");
else
puts("Grapes");
} else
puts("Waste");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int LIMIT = 1e2 + 7;
const int INF = 1e9 + 7;
long long n, dp[2][LIMIT][LIMIT], a[LIMIT];
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (int i = 0; i < LIMIT; i++) {
for (int j = 0; j < LIMIT; j++) {
dp[0][i][j] = INF;
dp[1][i][j] = INF;
}
}
dp[1][0][0] = 0;
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
if (!(a[i] & 1)) {
dp[0][i][j] = min(dp[0][i - 1][j - 1], dp[1][i - 1][j - 1] + 1);
}
if ((a[i] & 1) || a[i] == 0) {
dp[1][i][j] = min(dp[0][i - 1][j] + 1, dp[1][i - 1][j]);
}
}
}
printf("%lld", min(dp[0][n][n / 2], dp[1][n][n / 2]));
return EXIT_SUCCESS;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxL = 1024 + 5;
bool adj[20][20];
bool bit[maxL][20];
int n, e, k;
int cont[maxL], BIT[20];
long long dp[maxL][maxL];
inline void init() {
for (int i = 0; i < (1 << n); i++) {
int tmp = i;
for (int j = 1; j <= n; j++) {
bit[i][j] = tmp & 1;
cont[i] += bit[i][j];
tmp >>= 1;
}
}
for (int i = 0; i <= n; i++) BIT[i] = (1 << i);
}
int main() {
scanf("%d%d%d", &n, &e, &k);
for (int i = 1; i <= e; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x][y] = adj[y][x] = true;
}
init();
for (int i = 1; i < BIT[n]; i++) {
if (cont[i] < 2) continue;
if (cont[i] == 2) {
int e1 = -1;
int e2 = -1;
for (int j = 1; j <= n; j++)
if (bit[i][j]) {
if (e1 == -1)
e1 = j;
else
e2 = j;
}
dp[i][i] = adj[e1][e2];
continue;
}
for (int j = 1; j < BIT[n]; j++)
if (1 < cont[j] && (j & i) == j) {
int oth = (i ^ j);
int poi = 1;
while (!bit[j][poi]) poi++;
int end = (j ^ BIT[poi - 1]);
int ii = (i ^ BIT[poi - 1]);
for (int z = 1; z <= n; z++)
if (bit[oth][z] && adj[poi][z]) {
dp[i][j] += dp[ii][end] + dp[ii][end ^ BIT[z - 1]];
}
}
}
long long res = 0;
for (int i = 0; i < BIT[n]; i++)
if (cont[i] == k) res += dp[BIT[n] - 1][i];
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long minbranch(long long n, long long b) {
long long score = 0;
long long p = 0;
while (n > 0) {
long long a = pow(b, p);
long long k = min(n, a);
n -= k;
score += (p + 1) * k;
p++;
}
return score;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, s;
cin >> n >> s;
if (s > (n * (n + 1)) / 2 || s < 2 * n - 1)
cout << "No";
else {
cout << "Yes" << '\n';
long long b = 1;
while (minbranch(n, b) > s) b++;
long long remaining = (n * (n + 1)) / 2 - s;
vector<long long> cur(n + 1, 1);
long long cur_pow = 2;
long long pointer = n;
while (remaining >= pointer - cur_pow && remaining > 0) {
remaining -= (pointer - cur_pow);
cur[pointer]--;
cur[cur_pow]++;
pointer--;
if (cur[cur_pow] == pow(b, cur_pow - 1)) cur_pow++;
}
cur[pointer]--;
cur[pointer - remaining]++;
vector<vector<long long>> baskets(cur.size(), vector<long long>{});
long long p = 1;
long long pbasket = 1;
while (p <= n) {
for (long long i = 0; i < cur[pbasket]; ++i) {
baskets[pbasket - 1].push_back(p);
p++;
}
pbasket++;
}
vector<long long> answer(n + 1, 0);
long long si = baskets.size();
for (long long i = 0; i < si; ++i) {
vector<long long> v = baskets[i];
if (i == 0) continue;
for (long long j = 0; j < v.size(); ++j) {
long long c = v[j];
answer[c] = baskets[i - 1][j / b];
}
}
for (long long i = 2; i <= n; ++i) cout << answer[i] << " ";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int mxN = 100010;
vector<int> g[mxN];
int vis[mxN];
int h[mxN];
int mn[mxN], mnI[mxN];
int nodeInCycle[mxN];
bool f = false;
vector<int> res;
vector<int> at;
vector<int> st;
void dfs(int v) {
assert(!vis[v]);
vis[v] = 1;
mn[v] = h[v];
mnI[v] = v;
st.push_back(v);
for (auto u : g[v]) {
if (vis[u] == 1) {
if (!f) {
int cur = st.size() - 1;
while (u != st[cur]) {
nodeInCycle[st[cur]] = st[cur];
res.push_back(st[cur--]);
}
assert(u == st[cur]);
nodeInCycle[u] = u;
res.push_back(u);
at.clear();
at.resize(res.size(), 0);
reverse(res.begin(), res.end());
f = true;
} else {
int lo = 0, hi = res.size() - 1, to = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (vis[res[md]] == 1)
lo = md + 1;
else
hi = md - 1, to = md;
}
while ((int)res.size() > to) {
at.pop_back();
res.pop_back();
}
lo = 0, hi = res.size() - 1, to = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (h[res[md]] < h[u])
lo = md + 1;
else
hi = md - 1, to = md;
}
if (!at.empty()) at[0]--;
if (to < (int)at.size()) at[to]++;
}
if (h[u] <= mn[v]) {
mn[v] = h[u];
mnI[v] = u;
}
if (nodeInCycle[v] == -1) nodeInCycle[v] = nodeInCycle[u];
} else if (vis[u] == 2) {
int in = u;
if (vis[mnI[in]] == 1) {
int lo = 0, hi = res.size() - 1, toa = res.size(), tob = res.size();
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (vis[res[md]] == 1)
lo = md + 1;
else
hi = md - 1, toa = md;
}
lo = 0, hi = res.size() - 1;
while (lo <= hi) {
int md = (lo + hi) >> 1;
if (h[res[md]] < h[in])
lo = md + 1;
else
hi = md - 1, tob = md;
;
}
if (toa < (int)at.size()) at[toa]--;
if (tob < (int)at.size()) at[tob]++;
}
if (mn[u] <= mn[v]) {
mn[v] = mn[u];
mnI[v] = mnI[u];
}
if (nodeInCycle[v] == -1) nodeInCycle[v] = nodeInCycle[u];
} else {
h[u] = h[v] + 1;
dfs(u);
if (mn[u] <= mn[v]) {
mn[v] = mn[u];
mnI[v] = mnI[u];
}
if (nodeInCycle[v] == -1) nodeInCycle[v] = nodeInCycle[u];
}
}
st.pop_back();
vis[v] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, M, u, v;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
f = false;
memset(nodeInCycle, -1, sizeof nodeInCycle);
for (int i = 0; i < N; i++)
if (!vis[i]) dfs(i);
u = -2;
int cur = 0;
for (int i = 0; i < (int)res.size(); i++) {
cur += at[i];
if (cur >= 0) u = res[i];
}
cout << u + 1 << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long maxn = 70 + 10, N = 2e6 + 90, SQ = 300, base = 1999,
mod = 1e9 + 7, INF = 1e9 + 1, lg = 25;
const long double eps = 1e-4;
long long n, dp[maxn][maxn][maxn][2], sz1, sz2, sz3;
string s;
inline void pre() {
for (long long i = 0; i < n; ++i) {
if (s[i] == 'V') {
sz1++;
}
if (s[i] == 'K') {
sz2++;
}
if (s[i] != 'V' && s[i] != 'K') {
s[i] = 'X';
sz3++;
}
}
for (long long i = 0; i <= n; ++i) {
for (long long j = 0; j <= n; ++j) {
for (long long k = 0; k <= n; ++k) {
dp[i][j][k][0] = dp[i][j][k][1] = INF;
}
}
}
dp[0][0][0][0] = 0;
}
inline void find_first(long long &id1, long long &id2, long long &id3,
long long i, long long j, long long k) {
long long c1 = 0, c2 = 0, c3 = 0;
string tmp = "";
for (long long id = 0; id < n; ++id) {
if (s[id] == 'V') {
c1++;
if (c1 > i) {
tmp += s[id];
}
}
if (s[id] == 'K') {
c2++;
if (c2 > j) {
tmp += s[id];
}
}
if (s[id] == 'X') {
c3++;
if (c3 > k) {
tmp += s[id];
}
}
}
for (long long id = 0; id < (long long)tmp.size(); ++id) {
if (tmp[id] == 'V' && id1 == -1) {
id1 = id;
}
if (tmp[id] == 'K' && id2 == -1) {
id2 = id;
}
if (tmp[id] == 'X' && id3 == -1) {
id3 = id;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
pre();
for (long long i = 0; i <= sz1; ++i) {
for (long long j = 0; j <= sz2; ++j) {
for (long long k = 0; k <= sz3; ++k) {
long long id1 = -1, id2 = -1, id3 = -1;
find_first(id1, id2, id3, i, j, k);
if (id1 != -1) {
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1], dp[i][j][k][0] + id1);
dp[i + 1][j][k][1] = min(dp[i + 1][j][k][1], dp[i][j][k][1] + id1);
}
if (id2 != -1) {
dp[i][j + 1][k][0] = min(dp[i][j + 1][k][0], dp[i][j][k][0] + id2);
}
if (id3 != -1) {
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0], dp[i][j][k][0] + id3);
dp[i][j][k + 1][0] = min(dp[i][j][k + 1][0], dp[i][j][k][1] + id3);
}
}
}
}
cout << min(dp[sz1][sz2][sz3][0], dp[sz1][sz2][sz3][1]) << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, ind;
} a[400001];
int arr[300005];
bool check(node a, node b) {
if (a.l == b.l) return a.r < b.r;
return a.l < b.l;
}
priority_queue<int, vector<int>, greater<int> > pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, n, k, j = 0, m;
cin >> n >> k;
int mini = 1000000007;
int maxi = -1000000007;
int ans = -1000000007;
for (i = 0; i < n; i++) {
cin >> a[i].l >> a[i].r;
arr[i] = a[i].r;
a[i].ind = i + 1;
}
sort(a, a + n, check);
int li = 0, ri = k - 1;
for (i = 0; i < n; i++) {
if (i == k - 1) {
pq.push(a[i].r);
ans = max(0, pq.top() - a[i].l + 1);
li = a[i].l;
ri = pq.top();
} else if (i > k - 1) {
pq.push(a[i].r);
pq.pop();
if (ans < pq.top() - a[i].l + 1) {
ans = pq.top() - a[i].l + 1;
li = a[i].l;
ri = pq.top();
}
} else
pq.push(a[i].r);
}
if (ans == 0) {
cout << "0\n";
for (i = 0; i < k; i++) cout << a[i].ind << " ";
return 0;
}
int sum = 0;
cout << ans << "\n";
for (i = 0; i < n; i++) {
if (sum == k) break;
if (a[i].l <= li && a[i].r >= ri) {
sum++;
cout << a[i].ind << " ";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
long long a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
long long sumn = 0;
for (int i = 0; i < m; i++) {
cin >> b[i];
sumn += b[i];
}
long long low = sumn + m;
long long high = n;
long long ans = -1;
while (low <= high) {
long long mid = (low + high) / 2;
bool flag = true;
int cnt[m];
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < mid; i++) {
if (a[i] != -1) cnt[a[i]]++;
}
for (int i = 0; i < m; i++) {
if (cnt[i] == 0) {
flag = false;
break;
}
}
if (!flag) {
low = mid + 1;
} else {
int cnt[m];
long long opr = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = mid - 1; i >= 0; i--) {
if (a[i] == -1) {
opr = max(0LL, opr - 1);
} else {
if (cnt[a[i]] == 0) {
opr = opr + b[a[i]];
cnt[a[i]] = 1;
} else {
opr = max(0LL, opr - 1);
}
}
}
if (opr == 0) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
const int M = 300100;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
void MOD(long long &a) {
if (a >= mod) a -= mod;
}
void MOD(long long &a, long long c) {
if (a >= c) a -= c;
}
void ADD(long long &a, long long b) {
a += b;
MOD(a);
}
void ADD(long long &a, long long b, long long c) {
a += b;
MOD(a, c);
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long qpow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b /= 2;
}
return ans;
}
int n, c[N][N], dp[N][N], last[26];
char s[N];
int main() {
scanf("%d%s", &n, s + 1);
for (int i = (c[0][0] = 1); i <= n; i++)
for (int j = (c[i][0] = 1); j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= n; j++) {
if (last[s[i] - 'a'])
dp[i][j] += dp[i - 1][j - 1] - dp[last[s[i] - 'a']][j - 1];
else
dp[i][j] += dp[i - 1][j - 1];
dp[i][j] %= mod;
dp[i][j] += mod;
dp[i][j] %= mod;
}
last[s[i] - 'a'] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + 1ll * c[n - 1][i - 1] * dp[n][i]) % mod;
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, c, d = 0, j, e = 0;
cin >> n >> t >> c;
int i = 0, a[n];
while (i < n) {
cin >> a[i];
i++;
}
for (i = 0; i < n; i++) {
if (a[i] <= t) {
e++;
} else {
if (a[i - 1] <= t && e >= c) d = d + e - c + 1;
e = 0;
}
}
if (i == n && a[n - 1] <= t && e >= c) d = d + e - c + 1;
cout << d;
}
| 1 |
#include <bits/stdc++.h>
const int P = 1e9 + 7;
const int N = 2e5 + 5;
const int M = 1e6 + 5;
int cnt[M], p[M];
int n, A[N], X[M];
long long ans = 0;
int max(int a, int b) { return a > b ? a : b; }
int MAX = 0;
void Init() {
p[0] = 1;
for (int i = 1; i <= MAX; i++) p[i] = p[i - 1] * 2 % P, X[i] = i;
for (int i = 2; i <= MAX; i++)
for (int j = 2; j * i <= MAX; j++) X[i * j] -= X[i];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
cnt[A[i]]++;
MAX = max(MAX, A[i]);
}
Init();
for (int i = MAX; i >= 2; i--) {
long long now = 0;
for (int j = 1; j * i <= MAX; j++) now = now + cnt[i * j];
if (now == 0) continue;
ans = (ans + 1ll * now * p[now - 1] % P * X[i]) % P;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string ara[105];
bool vis[100][100], cycle;
string str, str2;
long long n, m;
long long dx[] = {0, 0, 1, -1};
long long dy[] = {1, -1, 0, 0};
void dfs(char ch, long long r, long long c, long long sr, long long sc) {
if (r >= n || c >= m || r < 0 || c < 0) return;
if (ara[r][c] != ch) return;
if (vis[r][c]) {
cycle = true;
return;
}
vis[r][c] = true;
for (long long i = 0; i < 4; i++) {
long long nr = r + dx[i];
long long nc = c + dy[i];
if (nr == sr && nc == sc) continue;
dfs(ch, nr, nc, r, c);
}
}
int main() {
long long int a, ans, i, j, d, temp;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> ara[i];
}
cycle = false;
memset(vis, false, sizeof vis);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (vis[i][j] == false) {
dfs(ara[i][j], i, j, -1, -1);
if (cycle) {
cout << "Yes";
return 0;
}
}
}
}
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long unsigned int days, a, b;
scanf("%llu", &days);
scanf("%llu", &a);
scanf("%llu", &b);
int w;
long long unsigned int aux;
for (int i = 0; i < days; i++) {
scanf("%i", &w);
aux = ((w * a) % b) / a;
printf("%llu ", aux);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> diff;
vector<int> idOfDiff[2005];
int main() {
ios::sync_with_stdio(0);
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
diff.push_back(x);
idOfDiff[x].push_back(i + 1);
}
sort(diff.begin(), diff.end());
diff.resize(unique(diff.begin(), diff.end()) - diff.begin());
int two = 0;
bool three = false;
for (int i = 0; i < (int)diff.size(); i++) {
int h = diff[i];
if (idOfDiff[h].size() >= 3)
three = true;
else if (idOfDiff[h].size() == 2)
two++;
}
if (!three && two < 2) {
cout << "NO\n";
return 0;
}
vector<int> res[3];
if (three) {
bool different = false;
for (int i = 0; i < (int)diff.size(); i++) {
int h = diff[i];
int j = 0;
if (idOfDiff[h].size() >= 3 && !different) {
res[0].push_back(idOfDiff[h][0]);
res[0].push_back(idOfDiff[h][1]);
res[0].push_back(idOfDiff[h][2]);
res[1].push_back(idOfDiff[h][0]);
res[1].push_back(idOfDiff[h][2]);
res[1].push_back(idOfDiff[h][1]);
res[2].push_back(idOfDiff[h][2]);
res[2].push_back(idOfDiff[h][0]);
res[2].push_back(idOfDiff[h][1]);
different = true;
j = 3;
}
for (; j < (int)idOfDiff[h].size(); j++) {
res[0].push_back(idOfDiff[h][j]);
res[1].push_back(idOfDiff[h][j]);
res[2].push_back(idOfDiff[h][j]);
}
}
} else {
int flag = 0;
for (int i = 0; i < (int)diff.size(); i++) {
int h = diff[i];
int j = 0;
if (idOfDiff[h].size() == 2 && flag < 2) {
if (flag == 0) {
res[0].push_back(idOfDiff[h][0]);
res[0].push_back(idOfDiff[h][1]);
res[1].push_back(idOfDiff[h][1]);
res[1].push_back(idOfDiff[h][0]);
res[2].push_back(idOfDiff[h][1]);
res[2].push_back(idOfDiff[h][0]);
} else if (flag == 1) {
res[0].push_back(idOfDiff[h][0]);
res[0].push_back(idOfDiff[h][1]);
res[1].push_back(idOfDiff[h][0]);
res[1].push_back(idOfDiff[h][1]);
res[2].push_back(idOfDiff[h][1]);
res[2].push_back(idOfDiff[h][0]);
}
flag++;
j = 2;
}
for (; j < (int)idOfDiff[h].size(); j++) {
res[0].push_back(idOfDiff[h][j]);
res[1].push_back(idOfDiff[h][j]);
res[2].push_back(idOfDiff[h][j]);
}
}
}
cout << "YES\n";
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
cout << res[i][j];
if (j == n - 1)
cout << "\n";
else
cout << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int prime[33000];
int cntPr = 0;
void init() {
for (int i = (2), ei = (33000); i < ei; i++) {
bool ok = 1;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
ok = 0;
break;
}
if (ok) prime[cntPr++] = i;
}
}
vector<pair<int, int> > fact(int a) {
vector<pair<int, int> > res;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= a; j++) {
int cnt = 0;
while (a % prime[j] == 0) {
a /= prime[j];
cnt++;
}
if (cnt) res.push_back(pair<int, int>(prime[j], cnt));
}
if (a != 1) res.push_back(pair<int, int>(a, 1));
return res;
}
long long strByMod(char *str, long long M) {
long long res = 0;
for (int i = 0; str[i]; i++) res = (res * 10 + str[i] - '0') % M;
return res;
}
int nod(int a, int b) {
int c = a;
while (b) {
c = b;
b = a % b;
a = c;
}
return c;
}
int toPow(long long a, int b, int mod) {
if (a == 0) return 0;
int res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
int getFi(int a) {
int res = 1;
for (int j = 0; j < cntPr && prime[j] * prime[j] <= a; j++) {
if (a % prime[j] == 0) {
int mn = 1;
while (a % prime[j] == 0) {
a /= prime[j];
mn *= prime[j];
}
res = res * mn / prime[j] * (prime[j] - 1);
}
}
if (a != 1) res *= a - 1;
return res;
}
int c;
char B[1000100], N[1000100];
bool test() {
scanf("%s %s%d", B, N, &c);
int b = strByMod(B, c);
if (strcmp(N, "1") == 0) {
printf("%d\n", (b - 1 + c) % c);
return 0;
}
long long res = 1;
int fi = getFi(c);
int n = (strByMod(N, fi) - 1 + fi) % fi;
long long bt = 1e10;
if (strlen(B) <= 9) bt = strByMod(B, 1e11);
if (bt >= fi) n += fi;
res = toPow(b, n, c);
res = (res * (b - 1 + c)) % c;
if (res == 0) res = c;
cout << res << endl;
return true;
}
int main() {
init();
test();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, flag = 0, sum = 0;
cin >> a >> b;
int A[a][b];
for (c = 0; c < a; c++) {
for (d = 0; d < b; d++) {
cin >> A[c][d];
}
}
for (c = a - 1; c >= 0; c--) {
for (d = b - 1; d >= 0; d--) {
if (A[c][d] == 0) {
A[c][d] = std::min(A[c + 1][d], A[c][d + 1]) - 1;
}
sum = sum + A[c][d];
}
}
for (c = 0; c < a - 1; c++) {
for (d = 0; d < b - 1; d++) {
if (A[c][d] >= A[c][d + 1] || A[c][d] >= A[c + 1][d]) {
flag = 1;
break;
}
}
}
if (A[a - 2][b - 1] >= A[a - 1][b - 1] || A[a - 1][b - 2] >= A[a - 1][b - 1])
flag = 1;
if (flag == 0) {
cout << sum << endl;
} else {
cout << -1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bitset<101> b;
int n;
pair<int, int> A[100];
void dfs(int i) {
if (b[i]) return;
b[i] = 1;
for (int j = 0; j < n; j++) {
if (i == j) continue;
if ((A[j].first == A[i].first || A[j].second == A[i].second) && !b[j])
dfs(j);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
A[i] = pair<int, int>(a, b);
}
int ans = -1;
for (int i = 0; i < n; i++) {
if (b[i]) continue;
dfs(i);
ans++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t MOD(int32_t x, int32_t y) { return x % y < 0 ? x % y + y : x % y; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int32_t T;
string s;
for (cin >> T >> s; T--; cin >> s) {
if (s[0] == 'R' && ('0' <= s[1] && s[1] <= '9') &&
s.find('C') != string::npos) {
string ans = "";
int32_t row = stol(s.substr(1, s.find('C') - 1)),
col = stol(s.substr(s.find('C') + 1));
for (; col != 0; col /= 26)
if (col % 26 != 0)
ans = ((char)('A' + col % 26 - 1)) + ans;
else {
ans = 'Z' + ans;
col--;
}
cout << ans << row << '\n';
} else {
int32_t row, col = 0;
for (int32_t i = 0; i < s.size(); i++)
if (s[i] > '9')
col = 26 * col + (s[i] - 'A' + 1);
else {
row = stol(s.substr(i));
break;
}
cout << 'R' << row << 'C' << col << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char *p1, *p2, buf[100000];
int read() {
int x = 0, f = 1;
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++);
while (ch<48 | ch> 57) {
if (ch == '-') f = -1;
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++);
}
while (ch >= 48 && ch <= 57) {
x = x * 10 + ch - 48;
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
const int maxn = 2105;
int n;
int dp[10005][maxn];
int a[10005];
void init() {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= maxn - 1; j++) dp[i][j] = 0x3f3f3f3f;
}
void solve() {
n = read();
init();
for (int i = 1; i <= n; i++) a[i] = read();
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int k = 0; k <= 2000; k++) {
if (dp[i - 1][k] == 0x3f3f3f3f) continue;
if (k + a[i] <= 2000)
dp[i][k + a[i]] = min(dp[i][k + a[i]], max(dp[i - 1][k], k + a[i]));
if (k - a[i] >= 0)
dp[i][k - a[i]] = min(dp[i][k - a[i]], dp[i - 1][k]);
else
dp[i][0] = min(dp[i][0], dp[i - 1][k] + a[i] - k);
}
int mn = 0x3f3f3f3f;
for (int i = 0; i <= 2000; i++) mn = min(mn, dp[n][i]);
cout << mn << "\n";
}
int main() {
ios::sync_with_stdio(0);
int t = read();
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265358979323846;
const long long modo = 998244353;
const long long inf = 1e16;
const long long ms = (1e6) + 5;
char ar[ms];
int tt[ms] = {0};
int ss[ms] = {0};
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
string s;
cin >> s;
int n = s.length();
int i;
int pr = 0;
for (i = 1; i < n; i++) {
while (pr > 0 && s[pr] != s[i]) {
pr = tt[pr - 1];
}
if (s[i] == s[pr]) {
pr++;
}
tt[i] = pr;
}
ss[0] = 1;
for (i = 1; i < (n - 1); i++) {
++ss[tt[i]];
}
pr = tt[n - 1];
while (!ss[pr]) {
pr = tt[pr - 1];
}
if (!pr) {
cout << "Just a legend";
return 0;
}
for (i = 0; i < pr; i++) cout << s[i];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, sm = 0;
cin >> n;
vector<long long> v(n);
vector<long long> s(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
sm += v[i];
s[i] = v[i];
}
sort(s.begin(), s.end());
vector<long long> res;
for (long long i = 0; i < n; i++) {
long long x = s[s.size() - 1];
if (x == v[i]) {
x = s[s.size() - 2];
}
if ((sm - v[i] - x) == x) {
res.push_back(i + 1);
}
}
cout << res.size() << endl;
for (long long i = 0; i < res.size(); i++) {
cout << res[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int num, tot, hd, top = 0;
std::vector<int> vec;
int p[35], cnt[35], st[100005];
inline int read() {
register int x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline void DivideByPrime(int n) {
num = 0;
for (register int i = 2; i * i <= n; ++i) {
if (n % i == 0) {
p[++num] = i;
cnt[num] = 0;
while (n % i == 0) {
++cnt[num];
n /= i;
}
}
}
if (n > 1) {
p[++num] = n;
cnt[num] = 1;
}
}
int main() {
int T = read();
while (T--) {
int n = read();
DivideByPrime(n);
if (num == 2 && cnt[1] == 1 && cnt[2] == 1) {
printf("%d %d %d\n", n, p[1], p[2]);
printf("1\n");
} else {
vec.clear();
for (register int i = num; i >= 1; --i) {
for (register int j = 0; j < vec.size(); ++j) {
int cur = vec[j];
for (register int k = 1, x = p[i]; k <= cnt[i]; ++k, x *= p[i]) {
st[++top] = cur * x;
}
}
int pos = (vec.size() >= 1 ? vec.size() : 0);
for (register int k = 1, x = p[i]; k <= cnt[i]; ++k, x *= p[i])
vec.push_back(x);
while (top) {
vec.push_back(st[top--]);
}
for (register int j = pos; j < vec.size(); ++j) {
if ((vec[j] % p[i] == 0 &&
(vec[j] / p[i] == p[i - 1] || vec[j] / p[i] == p[i + 1])) ||
vec[j] == n)
continue;
printf("%d ", vec[j]);
}
if (i != 1) printf("%d ", p[i] * p[i - 1]);
}
printf("%d\n0\n", n);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int k[105];
int main() {
int n, a, b, x, i;
cin >> n >> a >> b;
for (i = 1; i <= a; i++) {
cin >> x;
k[x] = 1;
}
for (i = 1; i <= b; i++) {
cin >> x;
if (k[x]) continue;
k[x] = 2;
}
for (i = 1; i <= n; i++) cout << k[i] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 62) - 1;
const long long MOD = 998244353;
const int MAX = 2e9 + 10;
const long long int N = 3e5 + 10;
using namespace std;
int bPow(int a, int b) {
int res = 1;
while (b) {
if (b & 1ll) {
res = 1ll * res * a % MOD;
}
b >>= 1;
a = 1ll * a * a % MOD;
}
return res;
}
bool checkPrefSuf(string& pre, string& s, string& suf) {
int nt = pre.length(), ns = s.length();
string ss = s;
reverse(ss.begin(), ss.end());
string testPre = s.substr(0, nt), testSuf = ss.substr(0, nt);
reverse(testSuf.begin(), testSuf.end());
return testPre == pre and testSuf == suf;
}
void solve() {
int n;
cin >> n;
int len = 2 * n - 2;
vector<vector<pair<string, int> > > preSuf(n);
for (int i = 0; i < len; ++i) {
string t;
cin >> t;
preSuf[t.length()].emplace_back(t, i);
}
string s = preSuf[n - 1][0].first + preSuf[n - 1][1].first.back(),
ans(len, '?');
bool isOk = true;
for (int i = 1; i < n; ++i) {
string s1 = preSuf[i][0].first, s2 = preSuf[i][1].first;
int idx1 = preSuf[i][0].second, idx2 = preSuf[i][1].second;
if (checkPrefSuf(s1, s, s2)) {
ans[idx1] = 'P', ans[idx2] = 'S';
} else if (checkPrefSuf(s2, s, s1)) {
ans[idx1] = 'S', ans[idx2] = 'P';
} else {
isOk = false;
break;
}
}
if (isOk) {
cout << ans << endl;
return;
}
s = preSuf[n - 1][1].first + preSuf[n - 1][0].first.back();
ans = string(len, '?');
for (int i = 1; i < n; ++i) {
string s1 = preSuf[i][0].first, s2 = preSuf[i][1].first;
int idx1 = preSuf[i][0].second, idx2 = preSuf[i][1].second;
if (checkPrefSuf(s1, s, s2)) {
ans[idx1] = 'P', ans[idx2] = 'S';
} else if (checkPrefSuf(s2, s, s1)) {
ans[idx1] = 'S', ans[idx2] = 'P';
}
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, t, res, a[1001];
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
t = 0;
for (j = i; j >= 1; j--)
if (a[j] >= a[j - 1])
t++;
else
break;
for (j = i + 1; j < n; j++)
if (a[j - 1] >= a[j])
t++;
else
break;
res = max(res, t + 1);
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("test.in");
ofstream fout("test.out");
int core[102];
int cell[102][102];
bool cellB[102];
int n, k, m;
int instr[102][102];
int main() {
int i, j, l, celula;
cin >> n >> m >> k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> instr[i][j];
}
}
for (j = 1; j <= m; j++) {
for (i = 1; i <= k; i++) {
cell[0][i] = 0;
}
for (i = 1; i <= n; i++) {
if (!core[i]) {
celula = instr[i][j];
if (cellB[celula]) {
core[i] = j;
} else {
cell[0][celula]++;
cell[cell[0][celula]][celula] = i;
}
}
}
for (i = 1; i <= k; i++) {
if (cell[0][i] > 1) {
cellB[i] = true;
for (l = 1; l <= cell[0][i]; l++) {
core[cell[l][i]] = j;
}
}
}
}
for (i = 1; i <= n; i++) cout << core[i] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
struct Node {
int l, r, minn, lazy;
int mid() { return (l + r) >> 1; }
} tree[MAXN << 2];
void PushUp(int rt) {
tree[rt].minn = min(tree[rt << 1].minn, tree[rt << 1 | 1].minn);
}
void PushDown(int rt) {
if (tree[rt].lazy) {
tree[rt << 1].lazy = max(tree[rt << 1].lazy, tree[rt].lazy);
tree[rt << 1 | 1].lazy = max(tree[rt << 1 | 1].lazy, tree[rt].lazy);
tree[rt << 1].minn = max(tree[rt << 1].minn, tree[rt].lazy);
tree[rt << 1 | 1].minn = max(tree[rt << 1 | 1].minn, tree[rt].lazy);
tree[rt].lazy = 0;
}
}
void Build(int l, int r, int rt) {
tree[rt].l = l, tree[rt].r = r, tree[rt].minn = tree[rt].lazy = 0;
if (l == r) {
cin >> tree[rt].minn;
return;
}
int mid = tree[rt].mid();
Build(l, mid, rt << 1);
Build(mid + 1, r, rt << 1 | 1);
PushUp(rt);
}
void Update(int val, int rt) {
if (tree[rt].minn >= val) return;
tree[rt].minn = val;
tree[rt].lazy = max(tree[rt].lazy, val);
}
void change(int pos, int val, int rt) {
if (tree[rt].l == tree[rt].r) {
tree[rt].minn = val;
return;
}
PushDown(rt);
int m = tree[rt].mid();
if (pos <= m)
change(pos, val, rt << 1);
else
change(pos, val, rt << 1 | 1);
PushUp(rt);
}
int Query(int pos, int rt) {
if (tree[rt].l == pos && pos == tree[rt].r) return tree[rt].minn;
PushDown(rt);
int mid = tree[rt].mid();
if (pos <= mid)
return Query(pos, rt << 1);
else
return Query(pos, rt << 1 | 1);
}
int main() {
ios::sync_with_stdio(false);
int n, m, u, v;
cin >> n;
Build(1, n, 1);
int op, x, y;
cin >> m;
while (m--) {
cin >> op >> x;
if (op == 1) {
cin >> y;
change(x, y, 1);
} else {
Update(x, 1);
}
}
for (int i = 1; i <= n; i++) {
cout << Query(i, 1) << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum = 0;
int i = 0;
int n;
scanf("%d", &n);
char s[n];
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == s[i + 1]) {
sum++;
}
}
printf("%d", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline float minOf(float x, float y) { return (x < y ? x : y); }
inline float maxOf(float x, float y) { return (x > y ? x : y); }
float mabs(float x) {
if (x < 0.0) return -x;
return x;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[4005];
string s;
int pos, cnt = 0;
int sum = 0;
for (int i = 1; i <= 2 * n; i++) {
cin >> s;
pos = 0;
while (s[pos] != '.') pos++;
pos++;
a[i] = 0;
for (int j = 0; j < 3; j++) a[i] = a[i] * 10 + s[pos++] - '0';
if (a[i] == 0) cnt++;
sum += a[i];
}
sum = 1000 * n - sum;
float mn = mabs(sum);
for (int i = 1; i <= (int)minOf(cnt, n); i++)
if (mabs(sum - i * 1000) < mn) mn = mabs(sum - i * 1000);
float ans = mn;
ans /= 1000.00;
cout << fixed;
cout << setprecision(3) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 5e3, Q = 7e4;
int n, q, a[N], ans[Q];
std::vector<std::pair<int, int>> move;
struct data {
std::vector<int> v;
std::map<std::pair<int, int>, int> map;
} node[N * 4];
void build(int l, int r, int id = 1) {
std::vector<int> &v = node[id].v;
if (l == r) {
v.push_back(a[l]);
return;
}
int m = (l + r) / 2;
build(l, m, id * 2);
build(m + 1, r, id * 2 + 1);
std::vector<int> &v1 = node[id * 2].v;
std::vector<int> &v2 = node[id * 2 + 1].v;
v.resize(r - l + 1);
std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v.begin());
}
int solve(int l, int r, int id = 1) {
std::vector<int> &v = node[id].v;
int x = std::lower_bound(v.begin(), v.end(), l) - v.begin();
int y = std::upper_bound(v.begin(), v.end(), r) - v.begin();
if (x == v.size() || x == y) return -1;
if (x + 1 == y) return v[x];
std::map<std::pair<int, int>, int> &map = node[id].map;
if (map.find({x, y}) == map.end()) {
int a = solve(l, r, id * 2);
int b = solve(l, r, id * 2 + 1);
if (a != -1 && b != -1) {
move.push_back({a, b});
map[{x, y}] = move.size() + n;
} else
map[{x, y}] = std::max(a, b);
}
return map[{x, y}];
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
int val;
scanf("%d", &val);
a[val] = i;
}
build(1, n);
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
ans[i] = solve(l, r);
}
printf("%d\n", move.size() + n);
for (std::pair<int, int> p : move) printf("%d %d\n", p.first, p.second);
for (int i = 1; i <= q; ++i) printf("%d ", ans[i]);
printf("\n");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int a[maxn][maxn], n, m;
int levo[maxn][maxn];
int desno[maxn][maxn];
int gore[maxn][maxn];
int dole[maxn][maxn];
void fix(int r, int c) {
a[r][c] = !a[r][c];
for (int i = 1; i < m; ++i) {
if (a[r][i - 1])
levo[r][i] = levo[r][i - 1] + 1;
else
levo[r][i] = 0;
}
for (int i = m - 1; i >= 0; --i) {
if (a[r][i + 1])
desno[r][i] = desno[r][i + 1] + 1;
else
desno[r][i] = 0;
}
for (int i = 1; i < n; ++i) {
if (a[i - 1][c])
gore[i][c] = gore[i - 1][c] + 1;
else
gore[i][c] = 0;
}
for (int i = n - 1; i >= 0; --i) {
if (a[i + 1][c])
dole[i][c] = dole[i + 1][c] + 1;
else
dole[i][c] = 0;
}
}
bool can(int r, int c) { return a[r][c] && r >= 0 && r < n && c >= 0 && c < m; }
int solve(int r, int c) {
int ret = 0;
for (int i = 0; i < 2; ++i) {
int x1 = 0, x2 = m;
int rn = r, cn = c, h = 1;
while (can(rn, cn)) {
x1 = max(x1, cn - levo[rn][cn]);
x2 = min(x2, cn + desno[rn][cn]);
ret = max(ret, h * (x2 - x1 + 1));
i & 1 ? ++rn : --rn;
++h;
}
}
for (int i = 0; i < 2; ++i) {
int y1 = 0, y2 = n;
int rn = r, cn = c, h = 1;
while (can(rn, cn)) {
y1 = max(y1, rn - gore[rn][cn]);
y2 = min(y2, rn + dole[rn][cn]);
ret = max(ret, h * (y2 - y1 + 1));
i & 1 ? ++cn : --cn;
++h;
}
}
return ret;
}
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 1; j < m; ++j) {
if (a[i][j - 1])
levo[i][j] = levo[i][j - 1] + 1;
else
levo[i][j] = 0;
}
for (int j = m - 1; j >= 0; --j) {
if (a[i][j + 1])
desno[i][j] = desno[i][j + 1] + 1;
else
desno[i][j] = 0;
}
}
for (int i = 0; i < m; ++i) {
for (int j = 1; j < n; ++j) {
if (a[j - 1][i])
gore[j][i] = gore[j - 1][i] + 1;
else
gore[j][i] = 0;
}
for (int j = n - 1; j >= 0; --j) {
if (a[j + 1][i])
dole[j][i] = dole[j + 1][i] + 1;
else
dole[j][i] = 0;
}
}
for (int i = 0; i < q; ++i) {
int op, r, c;
scanf("%d %d %d", &op, &r, &c);
--r, --c;
if (op == 1) {
fix(r, c);
} else {
printf("%d\n", solve(r, c));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, c[3010];
struct info {
int x, y;
};
struct as {
int a, b, c;
} ans;
struct node {
int x, id;
} a[3010];
inline bool cmp(node a, node b) { return a.x > b.x; }
inline info max(info a, info b) {
if (a.x < b.x) return b;
return a;
}
struct seg {
int lt[12010], rt[12010];
info mx[12010];
inline void build(int i, int l, int r) {
lt[i] = l;
rt[i] = r;
if (l == r) {
mx[i] = (info){a[l].x - a[l + 1].x, l};
return;
}
int mid = l + r >> 1;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
mx[i] = max(mx[i * 2], mx[i * 2 + 1]);
}
inline info query(int i, int l, int r) {
if (l <= lt[i] && r >= rt[i]) return mx[i];
int mid = lt[i] + rt[i] >> 1;
info ans = {-1, 0};
if (l <= mid) ans = query(i * 2, l, r);
if (r > mid) ans = max(ans, query(i * 2 + 1, l, r));
return ans;
}
} A;
inline as max(as t1, as t2) {
if (t1.a == 0) return t2;
if (a[t1.a].x - a[t1.a + 1].x != a[t2.a].x - a[t2.a + 1].x)
return a[t1.a].x - a[t1.a + 1].x > a[t2.a].x - a[t2.a + 1].x ? t1 : t2;
if (a[t1.b].x - a[t1.b + 1].x != a[t2.b].x - a[t2.b + 1].x)
return a[t1.b].x - a[t1.b + 1].x > a[t2.b].x - a[t2.b + 1].x ? t1 : t2;
if (a[t1.c].x - a[t1.c + 1].x != a[t2.c].x - a[t2.c + 1].x)
return a[t1.c].x - a[t1.c + 1].x > a[t2.c].x - a[t2.c + 1].x ? t1 : t2;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i].x), a[i].id = i;
sort(a + 1, a + n + 1, cmp);
A.build(1, 1, n);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j < n; j++)
if (2 * (j - i) >= i && i * 2 >= j - i) {
int lk = max(j + (max(i, j - i) + 1) / 2, j + 1),
rk = min(j + 2 * min(i, j - i), n);
if (lk <= rk) ans = max(ans, (as){i, j, A.query(1, lk, rk).y});
}
for (int i = 1; i <= ans.a; i++) c[a[i].id] = 1;
for (int i = ans.a + 1; i <= ans.b; i++) c[a[i].id] = 2;
for (int i = ans.b + 1; i <= ans.c; i++) c[a[i].id] = 3;
for (int i = ans.c + 1; i <= n; i++) c[a[i].id] = -1;
for (int i = 1; i <= n; i++) printf("%d ", c[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mulMod(long long a, long long b, long long mod) {
long long res = 0;
while (b > 0) {
if (b % 2 == 1) res = (res + a) % mod;
a = (a + a) % mod;
b /= 2;
}
return res;
}
long long powMod(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = mulMod(res, base, mod);
base = mulMod(base, base, mod);
exp /= 2;
}
return res;
}
char s[1000010];
long long pref[1000010], post[1000010];
int main() {
ios_base::sync_with_stdio(false);
scanf("%s", s);
long long a, b;
scanf("%lld %lld", &a, &b);
long long l = strlen(s);
pref[0] = (s[0] - '0') % a;
post[l - 1] = (s[l - 1] - '0') % b;
long long i;
for (i = 1; i < l; i++) {
pref[i] = (pref[i - 1] * 10 + (s[i] - '0')) % a;
}
long long p = 10;
for (i = l - 2; i >= 0; i--) {
post[i] = (post[i + 1] + p * (s[i] - '0')) % b;
p = (p * 10) % b;
}
long long flag = 0;
for (i = 1; i <= l - 1; i++) {
if (s[i] != '0' && pref[i - 1] == 0 && post[i] == 0) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("YES\n");
for (long long j = 0; j < i; j++) printf("%c", s[j]);
printf("\n");
for (long long j = i; j < l; j++) printf("%c", s[j]);
} else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a;
cin >> b;
vector<long long int> a1;
vector<long long int> b1;
for (int i = 1; i <= b; i++) {
a1.push_back(i * a);
}
for (int i = 1; i <= a; i++) {
b1.push_back(i * b);
}
long long int actr = 0;
long long int bctr = 0;
auto ita = a1.begin();
auto itb = b1.begin();
while (ita != a1.end() && itb != b1.end()) {
if ((*ita) < (*itb)) {
actr++;
ita++;
} else if ((*ita) == (*itb)) {
ita++;
itb++;
if (a < b) {
bctr++;
} else if (b < a) {
actr++;
}
} else {
bctr++;
itb++;
}
}
for (auto it = ita; it != a1.end(); it++) {
actr++;
}
for (auto it = itb; it != b1.end(); it++) {
bctr++;
}
if (actr < bctr) {
cout << "Masha";
} else if (actr > bctr) {
cout << "Dasha";
} else {
cout << "Equal";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int test, n, i, l, r, m, cnt[3];
string s;
bool check(int x) {
cnt[0] = cnt[1] = cnt[2] = 0;
for (i = 0; i < x; i++) cnt[s[i] - '1']++;
if (cnt[0] && cnt[1] && cnt[2]) return 1;
while (i < n) {
cnt[s[i] - '1']++;
cnt[s[i - x] - '1']--;
if (cnt[0] && cnt[1] && cnt[2]) return 1;
i++;
}
return 0;
}
int main() {
cin >> test;
while (test--) {
cin >> s;
n = s.size();
l = 3, r = n;
while (l < r) {
m = (l + r) >> 1;
if (check(m))
r = m;
else
l = m + 1;
}
if (s.size() < 3 || !check(l))
puts("0");
else
printf("%d\n", l);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int len, n, m, i, j, id[100010], xlh, cnt[100010], f[100010], a[100010], ans;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
id[i] = 1;
cnt[a[i]]++;
}
len = min(n * n, n * m);
for (i = n + 1; i <= len; i++) a[i] = a[i - n], id[i] = id[i - n] + 1;
for (i = 1; i <= len; i++) id[i] = min(n, m) - id[i] + 1;
for (i = len; i; i--) {
f[i] = 1;
for (j = i + 1; j <= len; j++)
if (a[j] >= a[i]) f[i] = max(f[i], f[j] + 1);
ans = max(ans, f[i]);
}
xlh = 0;
if (m <= n) return printf("%d", ans), 0;
for (i = 1; i <= 300; i++) xlh = max(xlh, cnt[i]);
printf("%d", ans + xlh * (m - n));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
cout << "------------------------------------------------------\n";
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
cout << "----------------------------------------------------------\n";
}
void print(double d) {
cout << fixed << setprecision(10) << d << endl;
cout << "--------------------------------------------------------\n";
}
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
cout << "-----------------------------------------------------------\n";
}
template <typename T>
void readToVector(vector<T> &v, long long n) {
T x;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
}
long long n, m;
const int N = 305;
long long a[305][305];
long long dx[] = {0, 0, 1, -1};
long long dy[] = {1, -1, 0, 0};
bool isValid(int x, int y) { return x >= 0 and x < n and y >= 0 and y < m; }
long long getCount(int x, int y) {
long long cnt = 0;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (isValid(xx, yy)) cnt++;
}
return cnt;
}
int main() {
long long q, i, j = 0, temp, t, k, ans = 0, sum = 0, x, y, z, cnt = 0, fg = 0,
mx = 0, mx1 = 0, mn = 8000000000000000000,
mn1 = 8000000000000000000;
cin >> t;
while (t--) {
cin >> n >> m;
fg = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
y = getCount(i, j);
if (x > y) fg = 1;
a[i][j] = y;
}
}
if (fg) {
cout << "NO\n";
continue;
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pi;
ll mod=1000000007;
ll bpow(ll a, ll b)
{
ll res=1;
while(b>0)
{
if(b&1)
{
res=res*a;
res%=mod;
}
a*=a;
a%=mod;
b>>=1;
}
return res;
}
void solve()
{
ll n; cin>>n;
if(n<8)
{
ll k=(n<=4 ? 2 : 3);
cout<<k+n-3<<endl;
for(ll i=n-1; i>=3; i--)
{cout<<i<<" "<<n<<endl;}
while(k--)
{
cout<<n<<" "<<2<<endl;
}
}
else
{
ll k=8, c=1;
while(k<n)
{
k*=8;
c++;
}
cout<<(n-1)+c<<endl;
for(ll i=n-1; i>=3; i--)
{
if(i!=8)
{cout<<i<<" "<<n<<endl;}
}
if(c!=1)
{
while(c--)
{
cout<<n<<" "<<8<<endl;
}
}
for(ll i=0; i<3; i++)
{cout<<8<<" "<<2<<endl;}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
ll t; cin>>t;
while(t--)
{
solve();
}
// your code goes here
return 0;
} | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.