solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <stdio.h>
int main (){
char date[12];
scanf ("%s",date );
date[3] ='8';
printf("%s", date);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-8;
char TEMPORARY_CHAR;
const long long INF = 1e17;
const int N = 1 << 17;
inline void input(int& a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
vector<vector<pair<int, int> > > g;
vector<int> dp1, dp2;
int cnt = 0;
int dfs(int v, int p) {
int mi1 = dp2[v] - dp1[v], mi2 = 1e9;
for (int i = 0; i < (int)(g[v].size()); i++) {
int to = g[v][i].first;
if (to != p) {
dp1[to] = dp1[v] + g[v][i].second;
dp2[to] = dp2[v] + 1 - g[v][i].second;
cnt += g[v][i].second;
int rr = dfs(to, v);
if (rr < mi1) {
mi2 = mi1;
mi1 = rr;
} else if (rr < mi2)
mi2 = rr;
}
}
int ret = mi1;
if (p == -1) ret += mi2;
return ret;
}
int main() {
int(n);
input((n));
;
if (n == 1) {
puts("0");
return 0;
}
g.resize(n);
dp1.resize(n);
dp2.resize(n);
for (int i = 0; i < (int)(n - 1); i++) {
int(a);
input((a));
;
int(b);
input((b));
;
g[a - 1].push_back(make_pair(b - 1, 0));
g[b - 1].push_back(make_pair(a - 1, 1));
}
dfs(0, -1);
int val[n];
int ans = 1e9;
for (int i = 0; i < (int)(n); i++) {
val[i] = cnt - dp1[i] + dp2[i];
ans = min(ans, val[i]);
}
for (int i = 0; i < (int)(n); i++) {
dp1.assign(n, 0);
dp2.assign(n, 0);
ans = min(val[i] + dfs(i, -1), ans);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int N;
cin >> N;
bool A[N];
memset(A, 0, sizeof A);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
int B;
cin >> B;
if (i == j) {
assert(B == -1);
continue;
}
if (B == 1 || B == 3) A[i] = true;
if (B == 2 || B == 3) A[j] = true;
}
int ans = 0;
for (int i = 0; i < N; i++)
if (!A[i]) ans++;
cout << ans << endl;
for (int i = 0; i < N; i++)
if (!A[i]) cout << i + 1 << " ";
}
| 1 |
#include <iostream>
using namespace std;
const int N = 500020 , mod = 998244353;
inline int qpow(int x , int y = mod - 2) {
int res = 1;
for(; y ; y >>= 1 , x = 1ll * x * x % mod)
if(y & 1) res = 1ll * res * x % mod;
return res;
}
int fac[N] , inv[N];
int C(int x , int y) {
if(y < 0 || y > x) return 0;
return 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;
}
typedef long long int64;
void C_init(int n) {
fac[0] = 1;
for(int i = 1 ; i <= n ; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = qpow(fac[n]);
for(int i = n-1 ; ~i ; i--) inv[i] = inv[i + 1] * (i + 1ll) % mod;
}
int n , k , ans;
int main() {
cin >> n >> k;
C_init(k);
for(int i = n ; i <= k ; ++i)
ans = (ans + C(k , i)) % mod,
ans = (ans - C(k, 2*i - n + 1) + mod) % mod;
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int dp[2][maxn][maxn];
int a[maxn];
inline void solve(void) {
int n, m, b;
long long M;
cin >> n >> m >> b >> M;
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= b; k++) {
for (int j = 0; j <= m; j++) {
if (i == 1) {
if (j * a[i - 1] <= k) dp[1][j][j * a[i - 1]] = 1;
} else {
if (k >= a[i - 1]) {
dp[1][j][k] = (dp[1][j][k] + dp[1][j - 1][k - a[i - 1]]);
while (dp[1][j][k] >= M) dp[1][j][k] -= M;
}
dp[1][j][k] = (dp[1][j][k] + dp[0][j][k]);
while (dp[1][j][k] >= M) dp[1][j][k] -= M;
}
}
}
for (int k = 0; k <= b; k++) {
for (int j = 0; j <= m; j++) {
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = 0;
}
}
}
long long ans = 0;
for (int i = (0); i < (b + 1); i++) ans = (ans + dp[0][m][i]) % M;
cout << ans;
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char* argv[]) {
init();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
if (a == 0) {
cout << -b * b << endl;
for (int i = 0; i < b; i++) cout << 'x';
cout << endl;
return 0;
}
if (b <= 1) {
cout << a * a - b * b << endl;
for (int i = 0; i < a; i++) cout << 'o';
for (int i = 0; i < b; i++) cout << 'x';
cout << endl;
return 0;
}
long long ans = 0, ians = -1;
for (int i = 1; i <= a && i <= b - 1; i++) {
long long now = (i - 1) + (a - i + 1) * (a - i + 1) -
(b / (i + 1)) * (b / (i + 1)) * (i + 1) -
(b % (i + 1)) * (2 * (b / (i + 1)) + 1);
if (ians == -1 || now > ans) {
ans = now;
ians = i;
}
}
cout << ans << endl;
long long mod = b % (ians + 1);
for (int i = 0; i < ians + 1; i++) {
for (int j = 0; j < b / (ians + 1); j++) cout << 'x';
if (mod > 0) cout << 'x', mod--;
if (i < ians - 1)
cout << 'o';
else if (i == ians - 1) {
for (int j = 0; j < a - ians + 1; j++) cout << 'o';
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int sp = 0, dp = 0, s = 1;
int l = 0, r = n - 1;
while (l <= r) {
if (a[l] > a[r]) {
if (s == 1) {
sp += a[l];
s = 2;
} else {
dp += a[l];
s = 1;
}
l++;
} else {
if (s == 1) {
sp += a[r];
s = 2;
} else {
dp += a[r];
s = 1;
}
r--;
}
}
cout << sp << " " << dp << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
int n = a + b;
set<int> ans;
{
int x = (n + 1) / 2;
int y = n / 2;
int init = 0;
if (x > a) {
int diff = x - a;
init += diff;
x -= diff;
y += diff;
} else if (a > x) {
int diff = a - x;
init += diff;
x += diff;
y -= diff;
}
ans.insert(init);
for (int i = 1; i <= min(x, y); ++i) {
ans.insert(init + 2 * i);
}
}
{
int y = (n + 1) / 2;
int x = n / 2;
int init = 0;
if (x > a) {
int diff = x - a;
init += diff;
x -= diff;
y += diff;
} else if (a > x) {
int diff = a - x;
init += diff;
x += diff;
y -= diff;
}
ans.insert(init);
for (int i = 1; i <= min(x, y); ++i) {
ans.insert(init + 2 * i);
}
}
cout << ans.size() << "\n";
for (auto x : ans) cout << x << " ";
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
struct node {
node *ch[26], *fa, *nxt;
int go[26];
long long val, cnt;
long long dp;
void clean() { memset(this, 0, sizeof(node)); }
} pool[MAXN * 2], *first[MAXN];
node *root, *last, *cur;
inline void init() {
cur = pool;
root = last = cur++;
}
node *p, *q, *nq;
inline void extend(int c) {
p = last, last = cur++;
last->val = p->val + 1;
last->cnt = 1;
while (p && !p->ch[c]) p->ch[c] = last, p = p->fa;
if (!p) {
last->fa = root;
return;
}
q = p->ch[c];
if (q->val == p->val + 1)
last->fa = q;
else {
nq = cur++;
memcpy(nq->ch, q->ch, sizeof(q->ch));
nq->val = p->val + 1, nq->fa = q->fa;
q->fa = last->fa = nq;
while (p && p->ch[c] == q) p->ch[c] = nq, p = p->fa;
}
}
char str[MAXN];
int main() {
init();
scanf("%s", str);
long long L = strlen(str);
for (int i = 0; str[i]; i++) extend(str[i] - 'a');
for (node *i = pool; i != cur; i++) i->nxt = first[i->val], first[i->val] = i;
for (int it = L; it >= 0; it--)
for (node *i = first[it]; i; i = i->nxt)
if (i->fa) i->fa->cnt += i->cnt;
for (int it = L; it >= 0; it--)
for (node *i = first[it]; i; i = i->nxt) {
i->dp = i->cnt;
for (int j = 0, top = 0; j < 26; j++)
if (i->ch[j]) {
i->dp += i->ch[j]->dp;
i->go[top++] = j;
}
}
int n;
int t;
n = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
node *now = root;
if (t > L * (L + 1) / 2) {
puts("No such line.");
continue;
}
while (t > 0) {
for (int i = 0;; i++) {
int u = now->go[i];
if (now->ch[u]->dp >= t) {
putchar(u + 'a');
now = now->ch[u];
t -= now->cnt;
break;
} else
t -= now->ch[u]->dp;
}
}
puts("");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-6;
const int MOD = (int)1e9 + 7;
const int maxn = (int)2e5 + 5;
const int logn = 20;
int dr[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dc[] = {0, 1, 1, 1, 0, -1, -1, -1};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
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)); }
inline bool check_bit(long long int n, int i) { return n & (1LL << i); }
inline long long int set_bit(long long int n, int i) { return n | (1LL << i); }
inline long long int reset_bit(long long int n, int i) {
return n & (~(1LL << i));
}
inline bool is_squre_root(long long int x) {
long long int s = sqrt(x);
return (s * s == x);
}
inline bool is_power_of_two(long long int x) {
return ((1LL << (long long int)log2(x)) == x);
}
inline bool is_leap_year(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<int, int> > arr;
for (int i = 1; i <= (n); i++) {
int x;
cin >> x;
arr.push_back({-x, i});
}
sort(arr.begin(), arr.end());
int sum = 0;
int counter = 0;
for (int i = 0; i < (int)arr.size(); i++) {
sum += ((-1) * arr[i].first) * counter + 1;
counter++;
}
cout << sum << '\n';
for (int i = 0; i < (int)arr.size(); i++) {
cout << arr[i].second << " ";
}
cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > gr;
int cnt[400010], root, rt, n;
bool ans[400010];
vector<pair<int, int> > subtr;
void dfscnt(int v, int p) {
cnt[v] = 1;
int tmp = 0;
for (auto i : gr[v]) {
if (i == p) {
continue;
}
dfscnt(i, v);
tmp = max(tmp, cnt[i]);
cnt[v] += cnt[i];
}
tmp = max(n - cnt[v], tmp);
if (tmp <= n / 2) {
root = v;
}
return;
}
void dfs(int v, int p, int subpar) {
if (cnt[subpar] == n - n / 2) {
ans[v] = 1;
}
for (int i = 0; i < subtr.size(); ++i) {
if (subtr[i].second == subpar) {
continue;
}
if (n - subtr[i].first - cnt[v] <= n / 2) {
ans[v] = 1;
} else {
break;
}
}
for (auto i : gr[v]) {
if (i == p) {
continue;
}
dfs(i, v, subpar);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
vector<int> vi;
gr.resize(n, vi);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, v--;
gr[u].push_back(v);
gr[v].push_back(u);
}
dfscnt(0, -1);
ans[root] = 1;
rt = root;
dfscnt(rt, -1);
root = rt;
for (int i = 0; i < gr[root].size(); ++i) {
subtr.push_back({cnt[gr[root][i]], gr[root][i]});
}
sort(subtr.begin(), subtr.end());
reverse(subtr.begin(), subtr.end());
for (int i = 0; i < subtr.size(); ++i) {
dfs(subtr[i].second, root, subtr[i].second);
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v1;
pair<int, int> p1;
long long a[1234567], tr[1234567];
string s;
int dp[1001];
long long pow1(long long x, long long y) {
if (y == 0) return 1;
long long temp = pow1(x, y / 2) % 1000000007;
if (y % 2 == 0)
return (temp * temp) % 1000000007;
else
return (((temp * temp) % 1000000007) * x) % 1000000007;
}
long long trie[10000001][2];
int sz = 1;
void insert(long long n) {
long long idx = 0;
for (long long i = 51; i >= 0; i--) {
long long p = ((1ll << i) & n);
if (p != 0) p = 1;
if (trie[idx][p] == -1) trie[idx][p] = sz++;
idx = trie[idx][p];
}
}
long long query(long long n) {
long long idx = 0, ans = 0;
for (long long i = 51; i >= 0; i--) {
long long p;
if ((1ll << i) & n)
p = 1;
else
p = 0;
if (trie[idx][1 - p] != -1) {
idx = trie[idx][1 - p];
ans = ans * 2 + 1;
} else if (trie[idx][p] != -1) {
ans *= 2;
idx = trie[idx][p];
}
}
return ans;
}
int main() {
int t;
int n, i, j, k, m, l;
scanf("%d", &n);
for (i = 0; i < n; i++) cin >> a[i];
tr[0] = a[0];
for (i = 1; i < n; i++) tr[i] = tr[i - 1] ^ a[i];
long long ans = *max_element(tr, tr + n);
memset(trie, -1, sizeof(trie));
insert(0);
long long val = 0;
for (i = n - 1; i >= 1; i--) {
val = val ^ a[i];
ans = max(ans, val);
insert(val);
ans = max(ans, query(tr[i - 1]));
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, s;
int main() {
cin >> n;
while (n--) {
cin >> y;
if (y == 0 or y == x) {
s++;
x = 0;
} else {
if (y == 3) {
if (x == 2) {
x = 1;
} else if (x == 1) {
x = 2;
}
} else {
x = y;
}
}
}
cout << s << endl;
}
| 1 |
#include<iostream>
#include<queue>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
int e;
long long p, q;
long long number[4000];
bool t[4000];
queue<int>v;
for (int i = 0;i < 4000;i++) {
number[i] = 0;
t[i] = false;
}
for (int i = 0;i < n;i++) {
cin >> e >> p >> q;
number[e - 1] += p*q;
if (t[e - 1] == false) {
if (number[e - 1] >= 1000000) {
v.push(e);
t[e - 1] = true;
}
}
}
int a = v.size();
if (v.empty()) { cout << "NA" << endl; }
else {
for (int i = 0;i < a;i++) {
cout << v.front() << endl;
v.pop();
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = (num << 1) + (num << 3) + (ch ^ 48);
ch = getchar();
}
return num * f;
}
int n;
const int mod(998244353);
const int maxn(2e5 + 5);
inline long long pw(long long x, long long y) {
long long ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
}
return ret % mod;
}
int main() {
n = read();
long long ans = 1, sum1 = 1, inv = pw(100, mod - 2);
for (int i = 1; i <= n; ++i) {
long long x = (read() * inv) % mod;
sum1 = (sum1 * x) % mod;
if (i != n) ans = (ans + sum1) % mod;
}
printf("%lld\n", (ans * pw(sum1, mod - 2)) % mod);
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin>> N;
cout << (N + 1)/2 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int64_t M = 1e9 + 7, N = 300;
int d[N][N];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
if (i != j) d[i][j] = M;
string s1, s2;
cin >> s1 >> s2;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
char a, b;
int w;
cin >> a >> b >> w;
d[a][b] = min(d[a][b], w);
}
for (int k = 'a'; k <= 'z'; ++k) {
for (int i = 'a'; i <= 'z'; ++i) {
for (int j = 'a'; j <= 'z'; ++j) {
if (d[i][k] < M * M && d[k][j] < M * M)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
int n1 = s1.size(), n2 = s2.size();
if (n1 != n2) cout << -1, exit(0);
string ans = "";
int sm = 0;
for (int i = 0; i < n1; i++) {
int64_t tmp = M;
ans += ' ';
int a = s1[i], b = s2[i];
for (int j = 'a'; j <= 'z'; j++) {
if (d[a][j] + d[b][j] < tmp) tmp = d[a][j] + d[b][j], ans[i] = (char)j;
}
if (tmp == M) cout << -1, exit(0);
sm += tmp;
}
cout << sm << '\n' << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
const long long int inf = 1e18;
vector<vector<long long int> > a(20, vector<long long int>(110));
vector<vector<long long int> > b(20, vector<long long int>(110));
vector<vector<long long int> > c(20, vector<long long int>(110));
long long int n, m, k;
long long int get(long long int ind1, long long int ind2) {
vector<long long int> profit;
for (long long int i = 0; i < m; i++) {
for (long long int j = 0; j < c[ind1][i]; j++)
profit.push_back(b[ind2][i] - a[ind1][i]);
}
sort(profit.rbegin(), profit.rend());
long long int ans = 0;
for (long long int i = 0; i < min(k, (long long int)profit.size()); i++) {
if (profit[i] <= 0)
break;
else
ans += profit[i];
}
return ans;
}
void solve() {
cin >> n >> m >> k;
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
for (long long int j = 0; j < m; j++) cin >> a[i][j] >> b[i][j] >> c[i][j];
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (i != j) ans = max(ans, get(i, j));
}
}
cout << ans;
}
void debug(long long int tt) {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, a, b, w[100000], x, z;
cin >> n >> a >> b;
for (i = 0; i < n; i++) cin >> w[i];
for (i = 0; i < n; i++) {
x = (a * w[i]) / b;
z = (b * x) / a;
if ((b * x) % a == 0)
cout << w[i] - z << " ";
else
cout << w[i] - z - 1 << " ";
}
}
| 2 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstring>
#include <sstream>
using namespace std;
static const double EPS = 1e-5;
typedef long long ll;
typedef pair<int,int> pi;
#define rep(i,n) for(int i=0;i<n;i++)
#define mp make_pair
int n;
int main(){
int n;
string num[]={"1111110",
"0110000",
"1101101",
"1111001",
"0110011",
"1011011",
"1011111",
"1110010",
"1111111",
"1111011",
"0000000",
};
while(cin>>n){
if(n==-1)break;
int zen=10;
rep(i,n){
int t;
cin>>t;
rep(j,7){
cout<<!(num[t][6-j]==num[zen][6-j]);
}
cout<<endl;
zen=t;
}
}
} | 0 |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;
const int Maxn = 100010;
int a[Maxn], n;
bool cmp(int x, int y) { return x > y; }
int main() {
int i, j, k;
scanf("%d", &n);
for(i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a+n, cmp);
for(i = 0; i <= n; i++){
if(i+1 >= a[i+1]){
int u = (a[i]-i+1)&1;
int v = 1;
while(i < a[i+v-1]) v++;
u |= v&1;
if(u == 1) printf("First\n");
else printf("Second\n");
break;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
cout<<x2+y1-y2<<" "<<y2-x1+x2<<" "<<x1+y1-y2<<" "<<y1-x1+x2<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
static const int MAXN = 302;
static const int MODULUS = 1e9 + 7;
long long fact[MAXN], fact_inv[MAXN];
long long part[MAXN][MAXN] = {{0}};
inline long long qpow(long long base, int exp) {
long long ans = 1;
for (; exp; exp >>= 1, (base *= base) %= MODULUS)
if (exp & 1) (ans *= base) %= MODULUS;
return ans;
}
void prepare_magic() {
fact[0] = 1;
for (int i = 1; i < MAXN; ++i) fact[i] = fact[i - 1] * i % MODULUS;
fact_inv[MAXN - 1] = qpow(fact[MAXN - 1], MODULUS - 2);
for (int i = MAXN - 2; i >= 0; --i)
fact_inv[i] = fact_inv[i + 1] * (i + 1) % MODULUS;
part[1][1] = 1;
for (int i = 2; i < MAXN; ++i)
for (int j = 1; j <= i; ++j)
part[i][j] =
(part[i - 1][j - 1] + part[i - 1][j] * (i - 1 + j)) % MODULUS;
}
inline long long binom(int n, int m) {
if (n < m || m < 0) return 0;
return fact[n] * fact_inv[m] % MODULUS * fact_inv[n - m] % MODULUS;
}
int n, a[MAXN];
std::vector<int> b[MAXN];
std::map<std::vector<int>, int> ct;
std::vector<int> c;
long long f[MAXN] = {0};
long long g[MAXN];
int main() {
prepare_magic();
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
for (int j = 2; j * j <= a[i]; ++j)
if (a[i] % j == 0) {
bool parity = false;
do {
a[i] /= j;
parity ^= 1;
} while (a[i] % j == 0);
if (parity) b[i].push_back(j);
}
if (a[i] > 1) b[i].push_back(a[i]);
++ct[b[i]];
}
for (auto p : ct) c.push_back(p.second);
int accum = c.front();
c.erase(c.begin());
f[accum - 1] = fact[accum];
for (int u : c) {
memset(g, 0, sizeof g);
for (int i = 0; i < accum; ++i)
for (int j = 1; j <= u; ++j)
for (int k = 0; k <= i && k <= j; ++k)
(g[i - k + (u - j)] += f[i] * part[u][j] % MODULUS * binom(j, k) %
MODULUS * binom(i, k) % MODULUS * fact[k] %
MODULUS * binom(accum - i + 1, j - k) %
MODULUS * fact[j - k] % MODULUS) %= MODULUS;
memcpy(f, g, sizeof g);
accum += u;
}
printf("%I64d\n", f[0]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
long long base = (1LL << 7) - 1;
long long res = 0, cur;
printf("?");
for (long long i = (1); i <= (100); i += (1)) printf(" %lld", i);
putchar('\n');
fflush(stdout);
cur = read();
res += (cur >> 7) << 7;
printf("?");
for (long long i = (1); i <= (100); i += (1)) printf(" %lld", i << 7);
putchar('\n');
fflush(stdout);
cur = read();
res += cur & base;
printf("! %lld\n", res);
fflush(stdout);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
vector<long long> calc(vector<long long> vec, int pos) {
long long x = vec[pos];
vec[pos] = 0ll;
long long p = x / 14ll;
long long cnt = 0;
for (int i = pos + 1;; i++) {
int now = i % 14;
vec[now] += p;
cnt++;
if (cnt == 14) break;
}
long long q = x % 14ll;
cnt = 0;
if (!q) return vec;
for (int i = pos + 1;; i++) {
int now = i % 14;
vec[now]++;
cnt++;
if (cnt == q) break;
}
return vec;
}
int main() {
vector<long long> vec;
for (int i = 0; i < 14; i++) {
long long x;
scanf("%lld", &x);
vec.push_back(x);
}
long long mx = -1;
for (int i = 0; i < 14; i++) {
if (!vec[i]) continue;
vector<long long> vv = calc(vec, i);
long long now = 0;
for (int i = 0; i < 14; i++) {
if (vv[i] % 2ll == 0ll) now += vv[i];
}
mx = max(mx, now);
}
printf("%lld\n", mx);
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int N,n = 1;
cin >> N;
while(n<=N) n *= 2;
cout << n/2;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int ans = INT_MAX;
void floyd(vector<vector<long long int>> graph, int n,
vector<vector<long long int>> &dist) {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, t, m;
t = 1;
while (t--) {
cin >> n;
vector<vector<long long int>> graph(n, vector<long long int>(n)),
dist(n, vector<long long int>(n, INT_MAX));
string x;
for (int i = 0; i < n; i++) {
dist[i][i] = 0;
cin >> x;
for (int j = 0; j < n; j++) {
if (x[j] == '1') dist[i][j] = 1;
graph[i][j] = (x[j] == '1');
}
}
floyd(graph, n, dist);
cin >> m;
vector<long long int> nums(m), ans;
for (int i = 0; i < m; i++) cin >> (nums[i]);
ans.push_back(nums[0]);
for (int i = 1; i < m - 1; i++) {
int x = nums[i], y = ans.back(), z = nums[i + 1];
--x, --y, --z;
if (dist[x][z] + dist[y][x] > dist[y][z]) ans.push_back(nums[i]);
}
ans.push_back(nums[m - 1]);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 300010;
long long n, a, b, val[N], pos[N];
string f;
int main() {
cin >> n >> f;
for (int i = 0; i < n; i++) pos[i] = i;
for (int i = 0; i < n; i++) {
long long j = i;
a = 0, b = 0;
while (j > 0 && f[j] < f[j - 1]) {
if (val[pos[j - 1]] == 1)
a++;
else if (val[pos[j - 1]] == 2)
b++;
swap(f[j], f[j - 1]);
swap(pos[j], pos[j - 1]);
if (a && b) {
printf("NO\n");
return 0;
}
j--;
}
if (a)
val[pos[j]] = 2;
else
val[pos[j]] = 1;
j++;
while (j <= i) {
if (a) {
val[pos[j]] = 1;
} else {
val[pos[j]] = 2;
}
j++;
}
}
printf("YES\n");
for (int i = 0; i < n; i++) {
if (val[i] <= 1)
printf("0");
else
printf("1");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 100;
int N;
int a[MN];
bool e[MN];
int f;
int c[3], C;
bool test(int v) {
for (int i = 0; i < C; i++)
if (!(c[i] % v)) return 0;
return 1;
}
void solve(void) {
f = 0;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", a + i);
sort(a, a + N, greater<int>());
N = unique(a, a + N) - a;
for (int i = 0; i < N; i++) e[a[i]] = 1;
C = 0;
for (int i = 0; i < N && C < 3; i++)
if (test(a[i])) c[C++] = a[i], f += a[i];
for (int i = 0; i < N; i++)
if (!(a[i] & 1) && a[i] % 3 == 0 && a[i] % 5 == 0)
if (e[a[i] >> 1] && e[a[i] / 3] && e[a[i] / 5])
f = max(f, (a[i] >> 1) + a[i] / 3 + a[i] / 5);
for (int i = 0; i < N; i++) e[a[i]] = 0;
printf("%d\n", f);
}
int Q;
int main(void) {
scanf("%d", &Q);
for (int i = 0; i < Q; i++) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, s[10005][4];
int mtx[105][105];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = (1); i <= (q); i++) {
scanf("%d", &s[i][0]);
if (s[i][0] == 3)
scanf("%d %d %d", &s[i][1], &s[i][2], &s[i][3]);
else
scanf("%d", &s[i][1]);
}
for (int i = (q); i >= (1); i--) {
if (s[i][0] == 3)
mtx[s[i][1]][s[i][2]] = s[i][3];
else if (s[i][0] == 1) {
for (int j = (m); j >= (2); j--)
swap(mtx[s[i][1]][j], mtx[s[i][1]][j - 1]);
} else {
for (int j = (n); j >= (2); j--)
swap(mtx[j][s[i][1]], mtx[j - 1][s[i][1]]);
}
}
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
printf("%d%c", mtx[i][j], j == m ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100000];
long long c[100000];
long long w[100000];
int uu[100000], vv[100000];
int col[100000];
int st[100000], sz = 0;
vector<int> cyc;
int cycv = 0;
bool flag = true;
bool dfs(int v, int co) {
st[sz++] = v;
col[v] = co;
for (int e : g[v]) {
int to = (uu[e] == v ? vv[e] : uu[e]);
if (col[to] == -1) {
if (dfs(to, co ^ 1)) {
if (flag) {
cyc.push_back(e);
if (v == cycv) {
flag = false;
}
}
return true;
}
} else if (col[to] == col[v] && cyc.empty()) {
cyc.push_back(e);
cycv = to;
flag = true;
return true;
}
}
--sz;
return false;
}
bool used[100000] = {};
void solve(int v) {
used[v] = true;
for (int e : g[v]) {
int to = (uu[e] == v ? vv[e] : uu[e]);
if (used[to]) {
continue;
}
solve(to);
w[e] = -c[to];
c[to] += w[e];
c[v] += w[e];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(n); ++i) scanf("%I64d", c + i), c[i] *= -1;
for (int i = 0; i < (int)(m); ++i) {
scanf("%d%d", uu + i, vv + i), --uu[i], --vv[i];
g[uu[i]].push_back(i);
g[vv[i]].push_back(i);
}
memset(col, -1, sizeof col);
dfs(0, 0);
solve(cycv);
if (c[cycv] != 0) {
if (cyc.empty()) {
cout << "NO" << endl;
return 0;
}
long long need = -c[cycv] / 2;
for (int x : cyc) {
w[x] += need;
need *= -1;
}
}
cout << "YES" << endl;
for (int i = 0; i < (int)(m); ++i) printf("%I64d\n", w[i]);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int h, n;
scanf("%d%d", &h, &n);
for(int i=0;i<n;i++) {
int x;
scanf("%d", &x);
if(h>0) h-=x;
}
puts(h>0?"No":"Yes");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, d, t, time = 0;
scanf("%d %d", &n, &d);
if ((n - 1) * 10 >= d)
printf("-1");
else {
for (i = 0; i < n; ++i) {
scanf("%d", &t);
time += t;
}
time += (n - 1) * 10;
if (time == d)
printf("%d", (n - 1) * 2);
else if (time > d)
printf("-1");
else
printf("%d", (n - 1) * 2 + (d - time) / 5);
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <functional>
using namespace std;
int main()
{
long n, u, k, r, v1, c1;
const long INF = 0xFFFFFFFF;
cin >> n >> k >> r;
vector<vector<long> > v(n), c(n);
vector<long> w(n, INF);
typedef pair<long, long> wt;
priority_queue<wt, vector<wt>, greater<wt> > que;
for (long i = 0; i < k; i++) {
cin >> u >> v1 >> c1;
v[u].push_back(v1);
c[u].push_back(c1);
}
w[r] = 0;
que.push(wt(0, r));
while (!que.empty()) {
wt g = que.top();
que.pop();
int k = g.second;
if (w[k] < g.first)
continue;
for (long i = 0; i < (long)v[k].size(); i++) {
if (w[v[k][i]] > w[k] + c[k][i]) {
w[v[k][i]] = w[k] + c[k][i];
que.push(wt(w[v[k][i]], v[k][i]));
}
}
}
for (long i = 0; i < n; i++) {
if (w[i] < INF)
cout << w[i] << endl;
else
cout << "INF" << endl;
}
return 0;
}
| 0 |
#include <algorithm>
#include <iostream>
#include <vector>
#include <cstdio>
using namespace std;
long long gcd(long long x, long long y){
if(x < y) swap(x,y);
while(y){
x %= y;
swap(x,y);
}
return x;
}
int main(){
long long n, m;
cin >> n >> m;
vector<long long> A(n);
vector<double> P(n);
for(int i = 0; i < n; ++i) cin >> A[i];
for(int i = 0; i < n; ++i){
cin >> P[i];
P[i] /= 100.0;
}
double ans = 0;
// vector<long long> LCM;
// vector<double> P_;
// vector<int> C;
// LCM.push_back(1);
// P_.push_back(1.0);
// C.push_back(0);
vector<long long> LCM((1<<n)+1);
vector<double> P_((1<<n)+1);
vector<int> C((1<<n)+1);
LCM[0] = 1;
P_[0] = 1;
C[0] = 0;
long long s = 1;
for(int i = 0; i < n; ++i){
long long s_ = s;
for(long long j = 0; j < s; ++j){
if(LCM[j]/gcd(LCM[j],A[i]) > m/A[i]) continue;
long long t = LCM[j]/gcd(LCM[j],A[i])*A[i];
if(t > m) continue;
double p = P_[j]*P[i];
int c = C[j] + 1;
if(c%2) ans += m/t*p;
else ans -= m/t*p;
// LCM.push_back(t);
// P_.push_back(p);
// C.push_back(c);
LCM[s_] = t;
P_[s_] = p;
C[s_] = c;
++s_;
//cout << t << " " << p << " " << c << endl;
}
s = s_;
}
printf("%.12f\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, y = 0, k = 0, t = 0;
int indeex[101];
int arr[102];
cin >> x;
for (int i = 1; i <= 7; i++) {
cin >> arr[i];
}
for (int i = 1; i <= 7; i++) {
t += arr[i];
if (t >= x) {
cout << i;
return 0;
} else if (i == 7) {
if (t < x) {
i = 0;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> vec;
int cnt = 0;
for (int i = max(0, n - 90); i <= n; i++) {
int tmp = i;
int ans = i;
while (tmp) {
ans += tmp % 10;
tmp /= 10;
}
if (ans == n) {
vec.push_back(i);
cnt++;
}
}
if (cnt == 0)
cout << 0 << endl;
else {
cout << cnt << endl;
for (auto it : vec) cout << it << endl;
}
cin >> n;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define ALL(a) (a).begin(),(a).end()
#define DEBUG(a) "(" << #a << ": " << (a) << ")"
template<typename T>
void chmin(T &x, T y) { x = min(x, y); }
template<typename T>
void chmax(T &x, T y) { x = max(x, y); }
typedef long long int lli;
typedef long double ld;
typedef tuple<int,int> P;
const int INF = INT_MAX/2 - 1;
const ld EPS = 1e-14;
const int dx[4] = {0, 1, 0, -1}; // {-1, 0, 1, -1, 1, -1, 0, 1};
const int dy[4] = {1, 0, -1, 0}; // {-1, -1, -1, 0, 0, 1, 1, 1};
const int M = 256;
ld entropy(const vector<int> &v) {
ld H = 0;
for (int x : v) {
if (x) { H -= x * log((ld)x); }
}
return H;
}
ld calc(int S, int A, int C, const vector<int> &I) {
vector<int> table(M);
for (int i = 0, len = I.size(), R = S; i < len; ++i) {
R = (A * R + C) % M;
table[(I[i] + R) % M]++;
}
return entropy(table);
}
int main() {
cout << fixed << setprecision(10);
int N;
while (cin >> N and N) {
vector<int> I(N);
REP(i, N) cin >> I[i];
ld ans = INF;
int S = -1, A = -1, C = -1;
REP(s, 16) REP(a, 16) REP(c, 16) {
ld H = calc(s, a, c, I);
if (ans > H + EPS) {
ans = H;
S = s, A = a, C = c;
}
}
cout << S << " " << A << " " << C << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int inf = 0x7f7f7f7f;
struct node {
int a, b;
bool operator<(const node& x) const {
if (x.b == b) return a < x.a;
return b < x.b;
}
} nod[maxn];
int main() {
long long n, r, avg;
while (~scanf("%I64d%I64d%I64d", &n, &r, &avg)) {
avg *= n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &nod[i].a, &nod[i].b);
avg -= nod[i].a;
}
sort(nod, nod + n);
int cnt = 0;
long long ans = 0, num;
while (avg > 0) {
num = max(0ll, min(avg, r - nod[cnt].a));
ans += num * nod[cnt].b;
avg -= num;
cnt++;
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long int mark[3000005];
int main() {
string t;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i, j;
while (cin >> t) {
set<long long int> s, b;
for (i = 0; i < t.size(); i++) s.insert(i);
for (i = 0; i + 1 < t.size(); i++) {
if (t[i] != t[i + 1]) {
b.insert(i);
}
}
long long int cn = 0;
set<long long int>::iterator it;
s.insert(-1);
s.insert(t.size());
while (b.size() > 0) {
vector<long long int> v;
cn++;
while (b.size() > 0) {
long long int r = *b.begin();
b.erase(b.find(r));
if (mark[r] == 1) continue;
s.erase(s.find(r));
mark[r] = 1;
while (1) {
long long int r1 = *s.upper_bound(r);
if (r1 == t.size()) break;
if (t[r] == t[r1]) {
v.push_back(r1);
break;
}
mark[r1] = 1;
s.erase(s.find(r1));
r = r1;
}
}
for (i = 0; i < v.size(); i++) {
if (mark[v[i]] == 1) continue;
it = s.lower_bound(v[i]);
if (*it >= v[i]) it--;
long long int x = *it;
if (x == -1 || mark[x] == 1) continue;
if (t[x] != t[v[i]]) b.insert(x);
}
}
cout << cn << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma loop_opt(on)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using ld = long double;
mt19937 mtrd(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1000000007;
const int mod2 = 998244353;
const ld PI = acos(-1);
long long qpow(long long x, long long powcnt, long long tomod) {
long long res = 1;
for (; powcnt; powcnt >>= 1, x = (x * x) % tomod)
if (1 & powcnt) res = (res * x) % tomod;
return (res % tomod);
}
long long inv(long long x) { return qpow(x, mod - 2, mod); }
const long long N = 5e5 + 10;
struct Disjoint_Set {
long long p[N];
long long sz[N];
void init() {
memset((p), (-1), sizeof((p)));
for (long long i = 0; i < N; i++) sz[i] = 1;
}
long long fp(long long x) { return p[x] == -1 ? x : p[x] = fp(p[x]); }
bool U(long long x, long long y) {
x = fp(x);
y = fp(y);
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y);
p[x] = y;
sz[y] += sz[x];
return true;
}
} dsu;
long long n;
long long L[N];
void solve() {
cin >> n;
dsu.init();
vector<long long> a(2 * n);
for (long long i = 1; i <= n; i++) {
long long l, r;
cin >> l >> r;
l--;
r--;
a[l] = a[r] = i;
L[i] = l;
}
set<pll> s;
long long cnt = 0;
for (auto i : a) {
if (cnt >= n) break;
if (s.count(make_pair(L[i], i))) {
s.erase(make_pair(L[i], i));
auto it = s.lower_bound(make_pair(L[i], i));
for (; it != s.end(); it++) {
cnt++;
if (!dsu.U(it->second, i)) {
cout << "NO\n";
return;
}
if (cnt >= n) break;
}
} else
s.insert(make_pair(L[i], i));
}
cout << (cnt == n - 1 ? "YES\n" : "NO\n");
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
const int N = 2350;
const int INF = 0x3f3f3f3f;
using namespace std;
const int M = 450;
int mp1[M][M], mp2[M][M];
int main() {
int n, m, a, b;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
mp1[i][j] = mp2[i][j] = 0;
else
mp1[i][j] = mp2[i][j] = INF;
}
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
mp1[a][b] = mp1[b][a] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (mp1[i][j] == 1) {
mp2[i][j] = INF;
} else {
mp2[i][j] = 1;
}
}
}
if (mp1[1][n] == 1) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (mp2[i][j] > mp2[i][k] + mp2[k][j])
mp2[i][j] = mp2[i][k] + mp2[k][j];
}
}
}
if (mp2[1][n] == INF)
printf("-1\n");
else
printf("%d\n", mp2[1][n]);
} else {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (mp1[i][j] > mp1[i][k] + mp1[k][j])
mp1[i][j] = mp1[i][k] + mp1[k][j];
}
}
}
if (mp1[1][n] == INF)
printf("-1\n");
else
printf("%d\n", mp1[1][n]);
}
}
}
| 1 |
#include <iostream>
using namespace std;
int a[6];
string s;
void C(int i,int j,int k,int l){
int t;t=a[i];a[i]=a[j];a[j]=a[k];a[k]=a[l];a[l]=t;
}
int main(){
for(int i=0;i<6;i++){
cin>>a[i];
}
cin>>s;
for(int i=0;i<s.size();i++){
if(s[i]=='E')for(int j=0;j<3;j++)C(0,2,5,3);
if(s[i]=='W')C(0,2,5,3);
if(s[i]=='S')for(int j=0;j<3;j++)C(0,1,5,4);
if(s[i]=='N')C(0,1,5,4);
}
cout<<a[0]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
long long a[N + 100], pre[N + 100];
long long A, B, Q;
int n;
const int MAXL = 20;
const int INF = 0x3f3f3f3f;
struct abc {
long long pre2[MAXL + 5], need[N + 10];
long long fmax[N + 10][MAXL + 5];
void init(int n) {
pre2[0] = 1;
for (int i = 1; i <= MAXL; i++) {
pre2[i] = pre2[i - 1] << 1;
}
need[1] = 0;
need[2] = 1;
int temp = 2;
for (int i = 3; i <= n; i++)
if (pre2[temp] == i)
need[i] = need[i - 1] + 1, temp++;
else
need[i] = need[i - 1];
}
void getst(long long *a, int n) {
for (int i = 1; i <= n; i++) fmax[i][0] = a[i];
for (int l = 1; pre2[l] <= n; l++)
for (int i = 1; i <= n; i++) {
if (i + pre2[l] - 1 <= n)
fmax[i][l] = max(fmax[i][l - 1], fmax[i + pre2[l - 1]][l - 1]);
}
}
int getmax(int l, int r) {
int len = need[r - l + 1];
return max(fmax[l][len], fmax[r - pre2[len] + 1][len]);
}
} ST;
bool ok(int l, int r, long long t, long long m) {
if (r > n) return false;
int ma = ST.getmax(l, r);
if (ma > t) return false;
long long ju = t * m;
long long sum = pre[r] - pre[l - 1];
if (sum <= ju) {
return true;
}
return false;
}
int main() {
scanf("%lld%lld%lld", &A, &B, &Q);
for (int i = 1;; i++) {
a[i] = A + (i - 1) * B;
if (a[i] > (int)1e6) {
n = i - 1;
break;
}
}
ST.init(n);
ST.getst(a, n);
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
while (Q--) {
int l;
long long t, m;
scanf("%d%lld%lld", &l, &t, &m);
if (l > n) {
puts("-1");
continue;
}
int L = l, R = N + 10, temp = -1;
while (L <= R) {
int mid = (L + R) >> 1;
if (ok(l, mid, t, m)) {
temp = mid;
L = mid + 1;
} else {
R = mid - 1;
}
}
printf("%d\n", temp);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, m;
std::vector<int> v[1111111];
int x[1111111], y[1111111], l[1111111];
int fa[1111111];
int rt(int x) { return (fa[x]) ? fa[x] = rt(fa[x]) : x; }
int f[1111111][22], dep[1111111];
int lca(int x, int y) {
if (dep[x] < dep[y]) x ^= y ^= x ^= y;
register int i;
for (i = 20; ~i; i--)
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
for (i = 20; ~i; i--)
if (f[x][i] ^ f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
bool vis[1111111];
int sum[1111111];
void dfs(int p, int fff = 0) {
f[p][0] = fff, vis[p] = 1, dep[p] = dep[fff] + 1;
register int i;
for (i = 1; f[p][i - 1]; i++) f[p][i] = f[f[p][i - 1]][i - 1];
for (auto tp : v[p])
if (tp ^ fff) dfs(tp, p);
}
void prefix(int p, int fff = 0) {
vis[p] = 1;
for (auto tp : v[p])
if (tp ^ fff) prefix(tp, p), sum[p] += sum[tp];
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
bool inc(int x, int y, int z) { return dis(x, z) + dis(y, z) == dis(x, y); }
int s1[1111111], t1, s2[1111111], t2;
int inv[1111111];
int tmp[1111111], ts;
void record(int pid, int* stk, int& top) {
ts = top = 0;
int xx = x[pid], yy = y[pid], pl = lca(xx, yy);
while (xx ^ pl) stk[++top] = xx, xx = f[xx][0];
while (yy ^ f[pl][0]) tmp[++ts] = yy, yy = f[yy][0];
while (ts) stk[++top] = tmp[ts--];
}
void intersect(int x, int y) {
record(x, s1, t1), record(y, s2, t2);
register int i;
for (i = 1; i <= t1; i++) inv[s1[i]]++;
for (i = 1; i <= t2; i++) inv[s2[i]] += 2;
int p1 = 0, p2 = 0;
int r1 = 0, r2, r3;
for (i = 1; i <= t1; i++)
if (inv[s1[i]] == 3) r1++;
r2 = t1 - r1 + 2, r3 = t2 - r1 + 2;
printf("%d ", r1);
for (i = 1; i <= t1; i++)
if (inv[s1[i]] == 3) printf("%d ", s1[i]), p1 = i;
puts("");
for (i = 1; i <= t2; i++)
if (inv[s2[i]] == 3) p2 = i;
if (s1[p1] ^ s2[p2]) {
for (i = 1; i <= t2 - i + 1; i++) {
int t = s2[i];
s2[i] = s2[t2 - i + 1], s2[t2 - i + 1] = t;
}
p2 = 0;
for (i = 1; i <= t2; i++)
if (inv[s2[i]] == 3) p2 = i;
}
printf("%d ", r2);
for (i = p1 - 1; i; i--)
if (inv[s1[i - 1]] ^ 3) printf("%d ", s1[i]);
for (i = t1; i >= p1; i--)
if (inv[s1[i + 1]] ^ 3) printf("%d ", s1[i]);
puts("");
printf("%d ", r3);
for (i = p2 - 1; i; i--)
if (inv[s2[i - 1]] ^ 3) printf("%d ", s2[i]);
for (i = t2; i >= p2; i--)
if (inv[s2[i + 1]] ^ 3) printf("%d ", s2[i]);
puts("");
}
void solve(int ex) {
puts("YES");
register int i;
int a = 0, b = 0;
for (i = 1; i <= m; i++)
if (!l[i])
if (inc(x[i], y[i], ex))
if (inc(x[i], y[i], f[ex][0])) (a ? b : a) = i;
intersect(a, b);
}
int main() {
scanf("%d%d", &n, &m);
register int i;
for (i = 1; i <= m; i++) scanf("%d%d", x + i, y + i);
for (i = 1; i <= m; i++) {
int xx = rt(x[i]), yy = rt(y[i]);
if (xx == yy) continue;
v[x[i]].push_back(y[i]), v[y[i]].push_back(x[i]), fa[xx] = yy, l[i] = 1;
}
for (i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (i = 1; i <= m; i++)
if (!l[i]) {
int p = x[i], q = y[i], r = lca(p, q);
sum[p]++, sum[q]++, sum[r] -= 2;
}
memset(vis, 0, sizeof vis);
for (i = 1; i <= n; i++)
if (!vis[i]) prefix(i);
for (i = 1; i <= n; i++)
if (sum[i] >= 2) return solve(i), 0;
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2005, MOD = 1e9 + 7;
int n, d, C[MAX];
vector<int> G[MAX];
long long dfs(int nod, int p, int val, int ni) {
if (C[nod] < val || C[nod] > val + d || (C[nod] == val && nod < ni)) return 1;
long long ans = 1;
for (int i = 0; i < G[nod].size(); i++) {
int newn = G[nod][i];
if (newn == p) continue;
ans = (ans * (dfs(newn, nod, val, ni))) % MOD;
}
return ans + 1;
}
int main() {
scanf("%d%d", &d, &n);
for (int i = 1; i <= n; i++) scanf("%d", &C[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
long long sol = 0;
for (int i = 1; i <= n; i++) {
sol = (sol + dfs(i, -1, C[i], i)) % MOD;
sol = (sol - 1 + MOD) % MOD;
}
printf("%I64d\n", sol);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 200005;
const int MAX_VERTEX = N * 5 * 2;
const int MOD = 1e9 + 7;
int vertexCount;
vector<pair<int, int>> adj[MAX_VERTEX];
int start[N];
int dist[MAX_VERTEX];
int n, m;
pair<int, int> elist[M];
void addEdge(int from, int to, int w) { adj[from].push_back({to, w}); }
void read() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &elist[i].first, &elist[i].second);
}
}
void createExtendedGraph() {
for (int i = 1; i <= n; i++) {
start[i] = vertexCount++;
}
for (int i = 1; i <= m; i++) {
vector<int> digits;
int j = i;
while (j > 0) {
digits.push_back(j % 10);
j /= 10;
}
reverse(digits.begin(), digits.end());
for (int it = 0; it < 2; it++) {
int cur = start[elist[i].first];
for (int j = 0; j + 1 < digits.size(); j++) {
int nex = vertexCount++;
addEdge(cur, nex, digits[j]);
cur = nex;
}
addEdge(cur, start[elist[i].second], digits.back());
swap(elist[i].first, elist[i].second);
}
}
}
void prepare() {
createExtendedGraph();
memset(dist, -1, sizeof dist);
dist[start[1]] = 0;
}
vector<vector<int>> processEquivalentVertices(vector<int> vertices) {
int val = dist[vertices[0]];
val = 10ll * val % MOD;
vector<int> orders[10];
for (int v : vertices) {
for (pair<int, int> edge : adj[v]) {
orders[edge.second].push_back(edge.first);
}
}
vector<vector<int>> ret;
for (int i = 0; i < 10; i++) {
vector<int> equivalentVerts;
for (int x : orders[i]) {
if (dist[x] == -1) {
dist[x] = (val + i) % MOD;
equivalentVerts.push_back(x);
}
}
if (!equivalentVerts.empty()) {
ret.push_back(equivalentVerts);
}
}
return ret;
}
void work() {
queue<vector<int>> q;
q.push({start[1]});
while (!q.empty()) {
vector<int> cur = q.front();
q.pop();
vector<vector<int>> equivalentVerts = processEquivalentVertices(cur);
for (vector<int> x : equivalentVerts) {
q.push(x);
}
}
for (int i = 2; i <= n; i++) {
printf("%d\n", dist[start[i]]);
}
}
int main() {
read();
prepare();
work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m, x;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
set<int> towers;
for (int i = 0; i < m; i++) {
cin >> x;
towers.insert(x);
}
int ans = 0;
for (int cur : a) {
int dist = 2 * 1e9 + 1;
auto it = towers.lower_bound(cur);
if (it != towers.end()) dist = *it - cur;
if (it != towers.begin()) dist = min(dist, cur - *(--it));
ans = max(ans, dist);
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 65536 * 2;
const long long INF = 1e10;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
vector<long long> t;
set<long long> a;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (a.count(x) != 0) {
a.erase(x);
a.insert(i + 1);
} else {
a.erase(x);
a.insert(i + 1);
}
}
cout << a.size() << '\n';
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 100010;
const double EPS = 1e-6;
using namespace std;
int v[26];
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
for (int i = 0; i < (s.size()); ++i) v[s[i] - 'a']++;
int flag = 1;
for (int i = 0; i < (26); ++i) {
if (v[i] > m) flag = 0;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
const int MOD = 1000000007;
long long getPhi(long long n) {
long long ret = 1;
for (long long i = 2; i * i <= n; ++i) {
if (n % i) continue;
ret *= i - 1;
n /= i;
for (; n % i == 0; n /= i) ret *= i;
}
if (n > 1) ret *= n - 1;
return ret;
}
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
k = k + 1 >> 1;
for (; k && n > 1; --k) n = getPhi(n);
printf("%lld\n", n % MOD);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e9;
void take(string &f, long long int &ab, long long int &ae, long long int &ina) {
ab = ae = ina = 0;
if (f[0] == 'C')
ab = 2;
else if (f[0] == 'A')
ab = 1;
if (f[(long long int)(f).size() - 1] == 'C')
ae = 2;
else if (f[(long long int)(f).size() - 1] == 'A')
ae = 1;
for (long long int i = 0; i < ((long long int)(f).size()); i++) {
if (i && f[i - 1] == 'A' && f[i] == 'C') ina++;
}
}
long long int cnt(string &f, string &s, long long int k) {
long long int ab = 0, bb = 0, ae = 0, be = 0, ina = 0, inb = 0;
take(f, ab, ae, ina);
take(s, bb, be, inb);
for (long long int i = 0; i < (k - 2); i++) {
long long int nb = 0, ne = 0, inn = 0;
inn = ina + inb;
if (ae == 1 && bb == 2) inn++;
nb = ab;
ne = be;
ab = bb;
ae = be;
ina = inb;
bb = nb;
be = ne;
inb = inn;
}
return inb;
}
void apply(string &f, long long int t) {
long long int en = (long long int)(f).size() - 1;
long long int a = t % 3;
t /= 3;
if (a == 0)
f[en] = 'D';
else if (a == 1)
f[en] = 'A';
else
f[en] = 'C';
a = t;
if (a == 0)
f[0] = 'D';
else if (a == 1)
f[0] = 'A';
else
f[0] = 'C';
}
bool gen_nx(string &f) {
if ((long long int)(f).size() < 3) return true;
if (f[1] == 'D') {
f[1] = 'A';
return false;
}
for (long long int i = 1; i < (long long int)(f).size() - 1; i++) {
if (f[i] == 'D') {
f[i] = (f[i - 1] == 'A' ? 'C' : 'A');
if (f[i + 1] == 'D') f[i + 1] = (f[i] == 'A' ? 'C' : 'A');
return false;
}
}
if (f[1] == 'C') return true;
f[1] = 'C';
for (long long int i = 2; i < (long long int)(f).size() - 1; i++) f[i] = 'D';
return false;
}
bool gensolve(long long int n, long long int m, long long int t1,
long long int t2, long long int need, long long int k) {
string f, s;
f.resize(n);
s.resize(m);
for (long long int i = 0; i < ((long long int)(f).size()); i++) f[i] = 'D';
for (long long int i = 0; i < ((long long int)(s).size()); i++) s[i] = 'D';
apply(f, t1);
apply(s, t2);
string ns = s;
do {
do {
if (cnt(f, ns, k) == need) {
cout << f << endl << ns;
return true;
}
} while (!gen_nx(ns));
ns = s;
} while (!gen_nx(f));
return false;
}
int main() {
long long int k, need, n, m;
cin >> k >> need >> n >> m;
for (long long int i = 0; i < (9); i++)
for (long long int j = 0; j < (9); j++) {
if (gensolve(n, m, i, j, need, k)) {
return 0;
}
}
cout << "Happy new year!";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Max = 100000000;
void Floyd_Warshall(int n, vector<vector<int>>& MinCost) {
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
MinCost[i][j] = min(MinCost[i][j], MinCost[i][k] + MinCost[k][j]);
}
void Count_Min_Edge(int n, vector<vector<int>>& E, vector<vector<int>>& MinDist,
vector<vector<int>>& Count) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < E.size(); j++) {
int x = E[j][0];
int y = E[j][1];
int d = E[j][2];
if (MinDist[i][x] != Max) {
if (MinDist[i][x] + d == MinDist[i][y]) {
Count[i][y]++;
} else if (MinDist[i][y] + d == MinDist[i][x]) {
Count[i][x]++;
}
}
}
}
}
void Shortest_path_Edge_Count(int n, vector<vector<int>>& MinDist,
vector<vector<int>>& Count) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int c = 0;
if (MinDist[i][j] != Max) {
for (int k = 0; k < n; k++) {
if (MinDist[i][k] + MinDist[k][j] == MinDist[i][j]) c += Count[i][k];
}
}
cout << c << endl;
}
}
}
int main(int argc, const char** argv) {
int n, m;
cin >> n >> m;
vector<vector<int>> Mindist(n);
vector<vector<int>> Count(n);
vector<vector<int>> E(m);
for (int i = 0; i < n; i++) {
Mindist[i] = vector<int>(n);
Count[i] = vector<int>(n);
}
for (int i = 0; i < m; i++) {
int x, y, d;
cin >> x >> y >> d;
vector<int> e = {x - 1, y - 1, d};
E[i] = e;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j)
Mindist[i][j] = Max;
else
Mindist[i][j] = 0;
}
}
for (int i = 0; i < m; i++) {
int x = E[i][0];
int y = E[i][1];
int d = E[i][2];
Mindist[x][y] = d;
Mindist[y][x] = d;
}
Floyd_Warshall(n, Mindist);
Count_Min_Edge(n, E, Mindist, Count);
Shortest_path_Edge_Count(n, Mindist, Count);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n,m,k;
int main()
{
scanf("%d%d%d",&n,&m,&k);
n=max(n,m);
printf("%d\n",k/n+(k%n!=0));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int a[500001];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
map<int, int> already;
map<int, int> last_seen;
int left = 1;
int right = 1;
int counter = 1;
already[a[right]]++;
int ans_right = -1, ans_left = 0;
while (left <= n) {
right++;
while (right <= n) {
already[a[right]]++;
if (already[a[right]] == 1) counter++;
if (counter > k) break;
right++;
}
if (counter > k) {
already[a[right]]--;
right--;
counter--;
if (right - left + 1 > ans_right - ans_left + 1) {
ans_right = right;
ans_left = left;
}
for (left = left; left <= right; left++) {
already[a[left]]--;
if (already[a[left]] == 0) {
counter--;
break;
}
}
} else if (right > n) {
if (right - left > ans_right - ans_left + 1) {
ans_right = right - 1;
ans_left = left;
}
}
left++;
}
printf("%d %d", ans_left, ans_right);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, row = 0, col = 0;
int main() {
long long t;
a = 0;
b = 0;
c = 0;
d = 0;
e = 0;
f = 0;
g = 0;
h = 0;
row = 0;
col = 0;
cin >> a;
string s;
if (a == 24) {
cin >> s;
b = s.size();
if (s[0] > '2') {
s[0] = '1';
} else if (s[0] == '2') {
if (s[1] >= '4') {
s[0] = '0';
}
}
if (s[3] >= '6') {
s[3] = '0';
}
cout << s << endl;
} else {
cin >> s;
b = s.size();
if (s[0] > '1' || s[0] == '0') {
if (s[1] != '0') {
s[0] = '0';
} else {
s[0] = '1';
}
} else if (s[0] == '1') {
if (s[1] > '2') {
s[0] = '0';
}
}
if (s[3] >= '6') {
s[3] = '0';
}
cout << s;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = 0;
long long arr[n], arr1[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr1[i] = arr[i];
}
sort(arr, arr + n);
sort(arr1, arr1 + n);
reverse(arr, arr + n);
for (int i = 0; i < n; i++) {
sum += arr[i] * arr1[i];
}
cout << sum % 10007;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long mod = 998244353ll;
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = 0; i < (2 * n); i++) cin >> a[i];
sort((a).begin(), (a).end());
long long LIM = 150005;
long long* inv = new long long[LIM] - 1;
inv[1] = 1;
for (long long i = (2); i <= (LIM - 1); i++)
inv[i] = mod - (mod / i) * inv[mod % i] % mod;
long long binCoef = 1;
for (long long i = 2 * n; i >= (n + 1); i--) {
binCoef *= i;
binCoef %= mod;
}
for (long long i = n; i >= (1); i--) {
binCoef *= inv[i];
binCoef %= mod;
}
long long s1 = 0;
long long s2 = 0;
for (long long i = 0; i < (n); i++) s1 += a[i];
for (long long i = (n); i <= (2 * n - 1); i++) s2 += a[i];
long long res = binCoef * ((s2 - s1) % mod);
res %= mod;
cout << res << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxd = 1000000007, N = 100000;
const double pi = acos(-1.0);
int n, pre[30], suf[30], len;
long long dp[100100][30];
char s[100100];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
void init(int now) {
scanf("%s", s + 1);
len = strlen(s + 1);
int i, j;
memset(pre, 0, sizeof(pre));
memset(suf, 0, sizeof(suf));
for (j = 0; j < 26; j++) {
int cnt = 0, maxlen = 0;
for (i = 1; i <= len; i++)
if (s[i] - 'a' == j) {
cnt++;
maxlen = max(maxlen, cnt);
} else
cnt = 0;
dp[now][j] = maxlen;
for (i = 1; i <= len; i++)
if (s[i] - 'a' == j)
pre[j]++;
else
break;
for (i = len; i >= 1; i--)
if (s[i] - 'a' == j)
suf[j]++;
else
break;
}
}
int main() {
n = read();
init(1);
int i, j;
for (i = 2; i <= n; i++) {
init(i);
for (j = 0; j < 26; j++) {
if (dp[i - 1][j]) {
if (pre[j] == len)
dp[i][j] =
max(dp[i][j], 1ll * len * (dp[i - 1][j] + 1) + dp[i - 1][j]);
else
dp[i][j] = max(dp[i][j], 1ll * (pre[j] + suf[j] + 1));
}
}
}
long long ans = 0;
for (i = 0; i < 26; i++) ans = max(ans, dp[n][i]);
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename G1, typename G2 = G1, typename G3 = G1>
struct triple {
G1 first;
G2 second;
G3 T, Fo;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<long long> mx(n, 1e9);
vector<long long> s(n);
vector<triple<long long> > queries;
for (int i = 0; i < m; i++) {
long long t, l, r, x;
cin >> t >> l >> r >> x;
--l;
--r;
queries.push_back({t, l, r, x});
if (t == 1) {
for (int j = l; j <= r; j++) s[j] += x;
} else {
for (int j = l; j <= r; j++) mx[j] = min(mx[j], x - s[j]);
}
}
vector<long long> ans = mx;
bool ok = true;
for (int i = 0; i < m; i++) {
long long t = queries[i].first;
long long l = queries[i].second;
long long r = queries[i].T;
long long x = queries[i].Fo;
if (t == 1) {
for (int j = l; j <= r; j++) mx[j] += x;
} else {
long long temp = -1e9;
for (int j = l; j <= r; j++) temp = max(mx[j], temp);
ok &= temp == x;
}
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " \n"[i == n - 1];
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main() {
string s;
cin>>s;
int n = s.length();
int i = 0;
int ac = 0;
long long ans = 0;
while(i+1 < n) {
if(s[i] == 'A') {
ac++;
i++;
}
else if(s[i] == 'B' && s[i+1] == 'C') {
ans+=ac;
i+=2;
}
else if(s[i]!= 'A') {
ac = 0;
i++;
}
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, t, k, d, f[110], sol, i, x;
set<int> s;
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cin >> n >> q;
for (; q; q--) {
cin >> t >> k >> d;
for (i = 1; i <= n; i++)
if (f[i] < t) s.insert(i);
if (s.size() < k) {
cout << -1 << '\n';
continue;
}
x = k;
sol = 0;
for (auto it : s) {
x--;
sol += it;
if (x == 0) break;
}
cout << sol << '\n';
x = k;
for (i = 0; i < x; i++) {
f[*s.begin()] = t + d - 1;
s.erase(s.begin());
}
}
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2767>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
ll solve(){
ll res = 0;
ll N; cin >> N;
string S; cin >> S;
vector<int> alpha;
for(int i = 0; i < 26;i++){
int x = (int)count(S.begin(),S.end(),'a'+i);
if(x == 0) continue;
alpha.push_back(x);
}
sort(alpha.begin(),alpha.end());
ll len0 = INF, len1 = 0;
// for(auto v:alpha){
// if(v == 1) len0 += 1;
// else len0 += 3;
// }
// len0 += alpha.size()-1;
//
for(int x = 1; x <= 9; x++){
int y = (int)count(alpha.begin(),alpha.end(),x);
if(y == 0) continue;
if(x == 1){
len1 += (2*y-1);
}else{
if(y == 1){
len1 += 3*y;
}else{
len1 += (4+2*y-1);
}
}
}
alpha.erase(unique(alpha.begin(),alpha.end()),alpha.end());
len1 += alpha.size()-1;
res = min(len0,len1);
return res;
}
int main(void) {
cin.tie(0); ios_base::sync_with_stdio(false);
cout << solve() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
char a[N], b[N];
int n, m, K, fail[N], pre[N], aft[N];
void cul(char *A, char *B, int *res) {
int i, j;
for (i = 2, j = 0; i <= m; i++) {
while (j && B[j + 1] != B[i]) j = fail[j];
if (B[j + 1] == B[i]) j++;
fail[i] = j;
}
res[0] = K;
for (i = 1; i <= m; i++) res[i] = n + 1;
for (i = 1, j = 0; i <= n; i++) {
while (j && B[j + 1] != A[i]) j = fail[j];
if (B[j + 1] == A[i]) j++;
if (i >= K) res[j] = min(res[j], i);
if (j == m) {
puts("Yes");
int r = i, l = i - m + 1;
while (r - l + 1 < 2 * K)
if (l > 1)
l--;
else if (r < n)
r++;
cout << l << ' ' << r - K + 1, exit(0);
}
}
for (i = 1; i <= m; i++) res[fail[i]] = min(res[fail[i]], res[i]);
}
int main() {
cin >> n >> m >> K >> a + 1 >> b + 1;
cul(a, b, pre);
reverse(a + 1, a + n + 1), reverse(b + 1, b + m + 1);
cul(a, b, aft);
for (int i = 0; i <= m; i++) aft[i] = n - aft[i] + 1;
for (int i = max(0, m - K); i <= min(K, m); i++)
if (pre[i] < aft[m - i])
return cout << "Yes" << endl << pre[i] - K + 1 << ' ' << aft[m - i], 0;
puts("No");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int n;
long long a[MAXN][MAXN];
long long ans[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%lld", &a[i][j]);
long long temp = a[1][2] * a[1][3] / a[2][3];
int k = 0;
temp = sqrt(temp);
ans[++k] = temp;
for (int i = 2; i <= n; i++) ans[++k] = a[1][i] / temp;
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int n, x;
cin >> n;
int s = 0;
for (int i = 0; i < n; ++i) {
cin >> x;
++mp[x];
s = max(s, mp[x]);
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, MOD = 10567, MAXN = 1e12 + 10, LG = 20, M = 1e7,
P = 727, Sq = 100;
const long long inf = 2e18 + 10;
vector<int> v1[N], v2[N], ans1, ans2;
vector<pair<int, int> > ret1, ret2;
int main() {
int n, m, mx1 = 0, mx2 = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
v1[x].push_back(y);
v1[y].push_back(x);
ret1.push_back(make_pair(x, y));
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v2[x].push_back(y);
v2[y].push_back(x);
ret2.push_back(make_pair(x, y));
}
for (int i = 1; i <= 9; i++) {
sort(v1[i].begin(), v1[i].end());
sort(v2[i].begin(), v2[i].end());
}
for (int i = 0; i < (int)ret1.size(); i++) {
bool sw1 = false, sw2 = false;
sort(ans1.begin(), ans1.end());
ans1.resize(unique(ans1.begin(), ans1.end()) - ans1.begin());
int x = ret1[i].first, y = ret1[i].second, sz = (int)ans1.size();
if (v2[x].size() > 0) {
for (int j = 0; j < (int)v2[x].size(); j++) {
if (v2[x][j] != y) {
ans1.push_back(x);
sw1 = true;
break;
}
}
}
if (v2[y].size() > 0) {
for (int j = 0; j < (int)v2[y].size(); j++) {
if (v2[y][j] != x) {
ans1.push_back(y);
sw2 = true;
break;
}
}
}
sort(ans1.begin(), ans1.end());
ans1.resize(unique(ans1.begin(), ans1.end()) - ans1.begin());
if (sw1 && sw2) return cout << -1, 0;
mx1 = max(mx1, (int)ans1.size() - sz);
}
for (int i = 0; i < (int)ret2.size(); i++) {
bool sw1 = false, sw2 = false;
sort(ans2.begin(), ans2.end());
ans2.resize(unique(ans2.begin(), ans2.end()) - ans2.begin());
int x = ret2[i].first, y = ret2[i].second, sz = (int)ans2.size();
if (v1[x].size() > 0) {
for (int j = 0; j < (int)v1[x].size(); j++) {
if (v1[x][j] != y) {
ans2.push_back(x);
sw1 = true;
break;
}
}
}
if (v1[y].size() > 0) {
for (int j = 0; j < (int)v1[y].size(); j++) {
if (v1[y][j] != x) {
ans2.push_back(y);
sw2 = true;
break;
}
}
}
sort(ans2.begin(), ans2.end());
ans2.resize(unique(ans2.begin(), ans2.end()) - ans2.begin());
if (sw1 && sw2) return cout << -1, 0;
mx2 = max(mx2, (int)ans2.size() - sz);
}
sort(ans1.begin(), ans1.end());
sort(ans2.begin(), ans2.end());
ans1.resize(unique(ans1.begin(), ans1.end()) - ans1.begin());
ans2.resize(unique(ans2.begin(), ans2.end()) - ans2.begin());
int sz1 = ans1.size(), sz2 = ans2.size();
if (sz1 == 1 && sz2 == 1) return cout << ans1[0], 0;
if (mx1 == 1 && mx2 == 1) return cout << 0, 0;
return cout << -1, 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, int> > a(n);
for (int i = 0; i < n; i++) {
int k, x;
cin >> k;
for (int j = 1; j <= k; j++) {
cin >> x;
a[i].first = (a[i].first > x ? a[i].first : x);
}
a[i].second = k;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
long long ans = 0;
for (int i = 1; i < n; i++) {
ans += (a[i - 1].first - a[i].first) * a[i].second;
a[i].first = a[i - 1].first;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, p;
string s;
long long arr[1005], temp[1005];
bool possible(long long pos) {
for (long long i = 0; i <= n; i++) temp[i] = arr[i];
for (long long i = pos; i <= n; i++) {
long long start = (i == pos ? temp[i] + 1 : 0);
temp[i] = -1;
for (long long j = start; j < p; j++) {
if (j == temp[i - 1] || j == temp[i - 2]) continue;
temp[i] = j;
break;
}
if (temp[i] == -1) return false;
}
return true;
}
signed main() {
cin >> n >> p;
cin >> s;
arr[0] = 50;
for (long long i = 1; i <= n; i++) arr[i] = s[i - 1] - 'a';
for (long long i = n; i >= 1; i--) {
if (possible(i)) {
for (long long j = 1; j <= n; j++) cout << char('a' + temp[j]);
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include<cstdio>
#include<queue>
#define mk make_pair
using namespace std;
typedef pair<int,int> pr;
const int N=200005;
int n,cnt;
int a[N],b[N];
long long ans;
priority_queue<pr>Q;
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
for(int i=1;i<=n;i++) {
scanf("%d",&b[i]);
if(b[i]!=a[i])
Q.push(mk(b[i],i));
}
b[0]=b[n]; b[n+1]=b[1];
while(!Q.empty()) {
pr now=Q.top(); Q.pop();
int p=now.second;
int dir=(b[p]-a[p])/(b[p-1]+b[p+1]);
if(dir<=0) {
printf("-1\n");
return 0;
}
b[p]=b[p]-dir*(b[p-1]+b[p+1]);
if(p==1) b[n+1]=b[p];
if(p==n) b[0]=b[p];
ans+=dir;
if(b[p]!=a[p])
Q.push(mk(b[p],p));
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N];
int n;
long long solve(long long x) {
long long ans = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
sum = (sum + a[i]) % x;
ans += min(sum, x - sum);
}
return ans;
}
int main() {
long long sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
sum += a[i];
}
if (sum == 0) {
printf("0\n");
return 0;
} else if (sum == 1) {
printf("-1\n");
return 0;
}
long long ans = 0x7f7f7f7f7f7f7f7f;
for (long long i = 2; i * i <= sum; i++) {
if (sum % i == 0) {
ans = min(ans, solve(i));
while (sum % i == 0) sum /= i;
}
}
if (sum > 1) ans = min(ans, solve(sum));
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f[200500][10][10], n, a[200500], ans;
char s[200500];
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = s[i] - '0';
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 2; k++) f[i][j][k] = -2000000000;
f[0][0][0] = f[0][1][0] = 0;
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 2; k++)
if (f[i][j][k] != -2000000000) {
f[i + 1][j][k] = max(f[i + 1][j][k], f[i][j][k]);
int j2 = a[i + 1], k2 = 0;
if (j2 != j)
k2 = k;
else
k2 = k + 1;
if (k2 <= 2) f[i + 1][j2][k2] = max(f[i + 1][j2][k2], f[i][j][k] + 1);
}
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 2; k++) ans = max(ans, f[n][j][k]);
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a, b, c, x, y, z;
int main() {
scanf("%d %d %d", &a, &b, &c);
y = (a - b + c) / 2;
x = a - y;
z = c - y;
if (x + y != a || y + z != c || z + x != b || y < 0 || x < 0 || z < 0)
printf("Impossible\n");
else
printf("%d %d %d\n", x, z, y);
scanf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
vector<int> to[MAXN], from[MAXN];
int par[MAXN];
bool visited[MAXN];
void dfs(int u)
{
visited[u] = 1;
for (auto v : to[u])
{
if (visited[v])
continue;
bool ok = 1;
for (auto w : from[v])
{
if (!visited[w])
{
ok = 0;
break;
}
}
if (ok)
{
par[v] = u;
dfs(v);
}
}
}
int main()
{
int N, M, a, b, root;
cin >> N >> M;
for (int i = 0; i < N + M - 1; i++)
{
cin >> a >> b;
a, b;
to[a].push_back(b);
from[b].push_back(a);
}
for (int i = 1; i <= N; i++)
{
if (from[i].size() == 0)
root = i;
}
par[root] = 0;
dfs(root);
for (int i = 1; i <= N; i++)
{
cout << par[i] << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, f[1000100], r[1000100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> h;
for (int i = 0; i < m; i++) {
cin >> f[i];
}
for (int i = 0; i < n; i++) {
cin >> r[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int t;
cin >> t;
if (t)
cout << min(f[j], r[i]);
else
cout << 0;
cout << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int he[1000050 >> 1], ne[1000050 << 1], to[1000050 << 1], tot;
int n, m, ds;
const int inf = 1e9;
inline void addedge(int x, int y) {
to[++tot] = y;
ne[tot] = he[x];
he[x] = tot;
}
vector<int> v[1000050], ve[1000050];
int dfn[1000050 >> 1], low[1000050 >> 1], cnt, st[1000050 >> 1], tp;
inline void tarjan(int g) {
dfn[g] = low[g] = ++cnt;
st[++tp] = g;
for (int i = he[g]; i; i = ne[i]) {
if (dfn[to[i]])
low[g] = min(low[g], dfn[to[i]]);
else {
tarjan(to[i]);
low[g] = min(low[g], low[to[i]]);
if (low[to[i]] == dfn[g]) {
++ds;
v[g].push_back(ds);
while (1) {
int t = st[tp--];
v[ds].push_back(t);
if (t == to[i]) break;
}
}
}
}
}
int len[1000050], a[1000050];
inline void dfs(int g) {
len[g] = g <= n ? 1 : 0;
for (int i = 0, to; i < v[g].size(); ++i) {
to = v[g][i], dfs(to);
if (g <= n) len[g] = max(len[g], len[to] + 1);
}
int sz = v[g].size();
if (!sz) return;
if (g > n) {
a[sz] = 0;
for (int i = sz - 1; ~i; --i)
a[i] = max(len[v[g][i]] + sz - 1 - i, a[i + 1]);
len[g] = a[0];
for (int i = 0, ma = 0; i < sz; ++i) {
ma = max(ma, len[v[g][i]] + i);
len[g] = min(len[g], max(ma, a[i + 1]));
}
}
}
int ans[1000050 << 1];
int ma1[1000050 << 3], ma2[1000050 << 3];
inline void build(int g, int l, int r) {
if (l == r) {
ma1[g] = a[l] - l;
ma2[g] = a[l] + l;
return;
}
const int m = l + r >> 1;
build(g << 1, l, m);
build(g << 1 | 1, m + 1, r);
ma1[g] = max(ma1[g << 1], ma1[g << 1 | 1]);
ma2[g] = max(ma2[g << 1], ma2[g << 1 | 1]);
}
inline int ask1(int g, int l, int r, int x, int y) {
if (l > y || r < x) return -inf;
if (l >= x && r <= y) return ma1[g];
const int m = l + r >> 1;
int r1 = ask1(g << 1, l, m, x, y), r2 = ask1(g << 1 | 1, m + 1, r, x, y);
return max(r1, r2);
}
inline int ask2(int g, int l, int r, int x, int y) {
if (l > y || r < x) return -inf;
if (l >= x && r <= y) return ma2[g];
const int m = l + r >> 1;
int r1 = ask2(g << 1, l, m, x, y), r2 = ask2(g << 1 | 1, m + 1, r, x, y);
return max(r1, r2);
}
inline int getans(int id, int L, int R, int ma) {
int l = L, r = R;
while (l + 1 < r) {
int mid = l + r >> 1;
if (ask2(1, 1, ma, L, mid) - L <= ask1(1, 1, ma, mid + 1, R) + R)
l = mid;
else
r = mid;
}
int l1 = ask2(1, 1, ma, L, l) - L, l2 = ask1(1, 1, ma, l + 1, R) + R;
l1 = max(l1, l2);
int r1 = ask2(1, 1, ma, L, r) - L, r2 = ask1(1, 1, ma, r + 1, R) + R;
r1 = max(r1, r2);
return min(l1, r1);
}
int sz, ma;
inline void dfs2(int g, int fa) {
ans[g] = len[g] - 1;
sz = v[g].size();
if (!sz) return;
ve[g].resize(sz);
if (g <= n) {
a[sz] = 0;
for (int i = sz - 1; ~i; --i) a[i] = max(len[v[g][i]] + 1, a[i + 1]);
for (int i = 0, ma = 0; i < sz; ++i) {
len[g] = len[fa] + 1;
len[g] = max(len[g], ma);
len[g] = max(len[g], a[i + 1]);
ma = max(ma, len[v[g][i]] + 1);
ve[g][i] = len[g];
}
for (int i = 0; i < v[g].size(); ++i) len[g] = ve[g][i], dfs2(v[g][i], g);
return;
}
ma = sz + sz;
a[sz] = len[fa];
for (int i = 0; i < sz; ++i) a[i] = a[i + sz + 1] = len[v[g][i]];
build(1, 1, ma);
for (int i = 0; i < sz; ++i) ve[g][i] = getans(i, i + 1, i + sz, ma);
for (int i = 0; i < v[g].size(); ++i) {
len[g] = ve[g][i];
len[v[g][i]] = max(len[v[g][i]], ve[g][i] + 1);
dfs2(v[g][i], g);
}
}
int b[30];
inline void dfs3(int g, int fa) {
ans[g] = len[g] - 1;
sz = v[g].size();
if (!sz) return;
ve[g].resize(sz);
if (g <= n) {
a[sz] = 0;
for (int i = sz - 1; ~i; --i) a[i] = max(len[v[g][i]] + 1, a[i + 1]);
for (int i = 0, ma = 0; i < sz; ++i) {
len[g] = len[fa] + 1;
len[g] = max(len[g], ma);
len[g] = max(len[g], a[i + 1]);
ma = max(ma, len[v[g][i]] + 1);
ve[g][i] = len[g];
}
for (int i = 0; i < v[g].size(); ++i) len[g] = ve[g][i], dfs3(v[g][i], g);
return;
}
ma = sz + sz;
a[sz] = len[fa];
for (int i = 0; i < sz; ++i) a[i] = a[i + sz + 1] = len[v[g][i]];
for (int i = 0; i < sz; ++i) {
b[i + sz + 1] = 0;
for (int j = i + sz; j > i; --j) b[j] = max(a[j] + i + sz - j, b[j + 1]);
len[g] = b[i + 1];
for (int j = i + 1, ma = 0; j <= i + sz; ++j) {
ma = max(ma, a[j] + j - i - 1);
len[g] = min(len[g], max(ma, b[j + 1]));
}
ve[g][i] = len[g];
}
for (int i = 0; i < v[g].size(); ++i) {
len[g] = ve[g][i];
len[v[g][i]] = max(len[v[g][i]], ve[g][i] + 1);
dfs3(v[g][i], g);
}
}
inline void work2(int rt) {
dfs3(rt, 0);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
ds = n;
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
addedge(x, y), addedge(y, x);
}
int rt = 1;
tarjan(rt);
int masize = 0;
for (int i = 1; i <= ds; ++i)
if (v[i].size() > masize) masize = v[i].size();
dfs(rt);
if (masize < 10) return work2(rt), 0;
dfs2(rt, 0);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int t, i, j, n, x, k, last[300005], dif[300005], d, sol[300005];
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i <= n; i++) {
last[i] = -1;
dif[i] = -1;
sol[i] = -1;
}
for (i = 1; i <= n; i++) {
cin >> x;
d = i - ((last[x] == -1) ? 0 : last[x]);
dif[x] = max(dif[x], d);
last[x] = i;
}
for (i = 1; i <= n; i++) {
if (last[i] == -1) {
continue;
}
dif[i] = max(dif[i], n + 1 - last[i]);
}
for (i = n; i > 0; i--) {
if (dif[i] != -1) {
sol[dif[i]] = i;
}
}
long long int s = -1;
for (i = 1; i <= n; i++) {
if ((s == -1 && sol[i] > 0) || (sol[i] < s && sol[i] != -1)) {
s = sol[i];
}
cout << s;
if (i < n) {
cout << " ";
}
}
cout << endl;
}
return 0;
};
| 1 |
#include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n, n != 0) {
int k = n / 4;
int sum = 0;
for (int i = 0; i < k; i++) {
int hit; cin >> hit;
sum += hit;
}
cout << sum << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << i + 2 << " ";
}
cout << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(6), b(3);
for (int i = 0; i < 6; i++) {
cin >> a[i];
}
int min1, min2, ans;
if (a[4] > a[5]) {
min1 = a[0] > a[3] ? a[3] : a[0];
a[3] -= min1;
ans = min1 * a[4];
min2 = a[1] > a[2] ? a[2] : a[1];
min2 = min2 > a[3] ? a[3] : min2;
ans += min2 * a[5];
} else {
min1 = a[1] > a[2] ? a[2] : a[1];
min1 = min1 > a[3] ? a[3] : min1;
a[3] -= min1;
ans = min1 * a[5];
min2 = a[0] > a[3] ? a[3] : a[0];
ans += min2 * a[4];
}
cout << ans;
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
long long int l = count(ar, ar + n, ar[0]);
long long int b = count(ar, ar + n, ar[n - 1]);
long long int d = ar[n - 1] - ar[0];
long long int ans = l * b;
if (ar[0] == ar[n - 1]) {
ans = ((n) * (n - 1)) / 2;
}
cout << d << " " << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y;
pt(int x, int y) { this->x = x, this->y = y; }
};
bool cmp(pt a, pt b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
bool cw(pt a, pt b, pt c) {
return 1LL * a.x * (b.y - c.y) + 1LL * b.x * (c.y - a.y) +
1LL * c.x * (a.y - b.y) <
0;
}
bool ccw(pt a, pt b, pt c) {
return 1LL * a.x * (b.y - c.y) + 1LL * b.x * (c.y - a.y) +
1LL * c.x * (a.y - b.y) >
0;
}
void convex_hull(vector<pt>& a) {
if (a.size() == 1) return;
sort(a.begin(), a.end(), &cmp);
pt p1 = a[0], p2 = a.back();
vector<pt> up, down;
up.push_back(p1);
down.push_back(p1);
for (size_t i = 1; i < a.size(); ++i) {
if (i == a.size() - 1 || cw(p1, a[i], p2)) {
while (up.size() >= 2 && !cw(up[up.size() - 2], up[up.size() - 1], a[i]))
up.pop_back();
up.push_back(a[i]);
}
if (i == a.size() - 1 || ccw(p1, a[i], p2)) {
while (down.size() >= 2 &&
!ccw(down[down.size() - 2], down[down.size() - 1], a[i]))
down.pop_back();
down.push_back(a[i]);
}
}
a.clear();
for (size_t i = 0; i < up.size(); ++i) a.push_back(up[i]);
for (size_t i = down.size() - 2; i > 0; --i) a.push_back(down[i]);
}
int main() {
int n, x, y, ans = 0, dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
scanf("%d", &n);
vector<pt> a;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
for (int k = 0; k < 4; ++k) a.push_back(pt(x + dx[k], y + dy[k]));
}
convex_hull(a);
for (int i = 0; i < a.size(); ++i)
ans += max(((a[i].x - a[(i + 1) % a.size()].x) < 0
? -1 * (a[i].x - a[(i + 1) % a.size()].x)
: (a[i].x - a[(i + 1) % a.size()].x)),
((a[i].y - a[(i + 1) % a.size()].y) < 0
? -1 * (a[i].y - a[(i + 1) % a.size()].y)
: (a[i].y - a[(i + 1) % a.size()].y)));
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int MOD_ONE = 1e9 + 7;
const int INF = 2e5 + 5;
using ll = long long;
using db = double;
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
int n, m;
string s1, s2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m >> s1 >> s2;
string ans = "";
ans += s1[0];
ans += s1[n - 1];
ans += s2[0];
ans += s2[m - 1];
if (ans == "<>v^" || ans == "><^v") {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a;
vector<int> b;
int n = 0, aux = 0, flag = 1, pos = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> aux;
if (aux) {
a.push_back(aux);
}
}
for (int i = 0; i < n; i++) {
cin >> aux;
if (aux) {
b.push_back(aux);
}
}
for (pos = 0; pos < b.size(); pos++) {
if (b[pos] == a[0]) {
break;
}
}
for (int j = 0; j < b.size() - pos; j++) {
if (a[j] != b[pos + j]) {
flag = 0;
}
}
for (int j = 0; j < pos; j++) {
if (b[j] != a[j + b.size() - pos]) {
flag = 0;
}
}
if (flag == 1) {
cout << "YES" << endl;
} else if (flag == 0) {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c, d;
scanf("%lld %lld %lld %lld", &a, &b, &c, &d);
printf("%lld %lld %lld\n", b, c, c);
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000009, mm = 100010;
int t, n, m, k, L, R, top, stk[mm], l[mm], r[mm];
pair<int, int> p[mm], f[mm], rg[mm];
pair<int, int> ask(int t, int L, int R) {
if ((!t) || (L > rg[t].second) || (R < rg[t].first)) return make_pair(-1, 0);
if ((L <= rg[t].first) && (R >= rg[t].second)) return f[t];
pair<int, int> le, ri;
le = ask(l[t], L, R);
ri = ask(r[t], L, R);
if ((p[t].first <= R) && (p[t].first >= L))
return make_pair(le.second + ri.second,
max(le.first + ri.second, le.second + ri.first) + 1);
else
return le.first < 0 ? ri : le;
}
void make(int t, int L, int R) {
if (!t) return;
make(l[t], L, t - 1);
make(r[t], t + 1, R);
rg[t].first = p[L].first;
rg[t].second = p[R].first;
pair<int, int> le, ri;
le = l[t] ? f[l[t]] : make_pair(-1, 0);
ri = r[t] ? f[r[t]] : make_pair(-1, 0);
f[t].first = le.second + ri.second;
f[t].second = max(le.first + ri.second, le.second + ri.first) + 1;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) scanf("%d%d", &p[i].first, &p[i].second);
int x1, x2, x3, x4;
scanf("%d%d%d%d", &x1, &x2, &x3, &x4);
for (int i = k + 1; i <= n; i++) {
p[i].first = (1LL * p[i - 1].first * x1 % mo + x2) % mo;
p[i].second = (1LL * p[i - 1].second * x3 % mo + x4) % mo;
}
sort(p + 1, p + n + 1);
stk[top = 1] = t = 1;
for (int i = 2; i <= n; i++) {
while ((top > 0) && (p[stk[top]].second < p[i].second)) top--;
if (top > 0) {
l[i] = r[stk[top]];
r[stk[top]] = i;
} else {
t = i;
l[i] = stk[1];
}
stk[++top] = i;
}
make(t, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d", &L, &R);
printf("%d\n", ask(t, L, R).second);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int mxN=5e5, M=1e9+7;
int n, m;
ll iv[mxN+1], f1[mxN+1], f2[mxN+1];
ll nck(int n, int k) {
return f1[n]*f2[k]%M*f2[n-k]%M;
}
int main() {
iv[1]=1;
for(int i=2; i<=mxN; ++i)
iv[i]=M-M/i*iv[M%i]%M;
f1[0]=f2[0]=1;
for(int i=1; i<=mxN; ++i) {
f1[i]=f1[i-1]*i%M;
f2[i]=f2[i-1]*iv[i]%M;
}
cin >> n >> m;
ll ans=0;
for(int i=0; i<=n; ++i) {
ll c=i&1?M-1:1;
c=c*nck(n, i)%M*nck(m, i)%M*f1[i]%M*nck(m-i, n-i)%M*nck(m-i, n-i)%M*f1[n-i]%M*f1[n-i]%M;
ans=(ans+c)%M;
}
cout << ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f, g, h, m, n, cnt, pos, ans, bb[11111];
int main() {
cin >> a >> b >> c;
for (int i = 1; i <= a; ++i) {
cin >> bb[i];
}
sort(bb + 1, bb + 1 + a);
if (c >= b) {
cout << 0;
return 0;
}
for (int i = a; i > 0; --i) {
c += bb[i] - 1;
d++;
if (c >= b) {
cout << a - i + 1;
return 0;
}
}
cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, item, sum = 0, a, b, c, d;
cin >> a >> b >> c >> d;
if (a == d) {
if (a == 0 && c != 0) {
cout << "0" << endl;
return 0;
}
cout << "1" << endl;
} else {
cout << "0" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 3;
int n, m, mark[MAXN];
vector<int> g[MAXN];
pair<int, int> e[MAXN];
void dfs(int, int = 1);
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
e[i] = {u, v};
}
for (int i = 0; i < m; i++)
if (e[i].first > e[i].second) swap(e[i].first, e[i].second);
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++)
if (e[i].first < e[j].first && e[j].first < e[i].second &&
e[j].first < e[i].second && e[i].second < e[j].second)
g[i].push_back(j), g[j].push_back(i);
for (int i = 0; i < m; i++)
if (mark[i] == 0) dfs(i);
for (int i = 0; i < m; i++) cout << (mark[i] == 1 ? 'i' : 'o');
return 0;
}
void dfs(int v, int q) {
mark[v] = q;
q = 3 - q;
for (auto u : g[v])
if (mark[u] != 0 && mark[u] != q)
cout << "Impossible", exit(0);
else if (mark[u] == 0)
dfs(u, q);
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
long long rll() {
long long x;
scanf("%lld", &x);
return x;
}
vector<int> rUP[10];
vector<int> rDOWN[10];
long long UP[10][200500];
int cntUP[10];
long long DOWN[10][200500];
int cntDOWN[10];
void solve() {
long long n, k;
cin >> n >> k;
string s = "0";
vector<int> lUP, lDOWN;
long long temp = 0;
for (int i = (int)(1); i <= (int)(9999999); i++) {
int pos = s.length() - 1;
while (pos >= 0 && s[pos] == '9') pos--;
if (pos == -1)
s = "1" + string(s.length(), '0');
else {
s[pos]++;
for (int j = (int)(pos + 1); j <= (int)(s.length() - 1); j++) s[j] = '0';
}
bool check = true;
for (int j = 1; j < s.length() - 1; j++) {
if (s[j] > s[j - 1] && s[j] > s[j + 1] ||
s[j] < s[j - 1] && s[j] < s[j + 1])
;
else
check = false;
}
if (s.length() == 2 && s[0] == s[1]) check = false;
if (check) {
if ((long long)i % n == 0) {
k--;
if (k == 0) {
cout << i << endl;
return;
}
}
if (s.length() == 1)
lUP.push_back(i), lDOWN.push_back(i);
else {
if (s.length() == 7) {
if (s[0] > s[1])
rDOWN[s[0] - '0'].push_back(i);
else
rUP[s[0] - '0'].push_back(i);
}
if (s.length() == 6 && s[0] > s[1]) rUP[0].push_back(i);
if (s.back() < s[s.length() - 2])
lDOWN.push_back(i);
else
lUP.push_back(i);
}
}
}
for (int i = 0; i < 10; i++) {
UP[i][cntUP[i]++] = -1;
UP[i][cntUP[i]++] = n + 1;
DOWN[i][cntDOWN[i]++] = -1;
DOWN[i][cntDOWN[i]++] = n + 1;
for (int j = 0; j < rUP[i].size(); j++)
UP[i][cntUP[i]++] = (long long)rUP[i][j] % n;
for (int j = 0; j < rDOWN[i].size(); j++)
DOWN[i][cntDOWN[i]++] = (long long)rDOWN[i][j] % n;
sort(UP[i], UP[i] + cntUP[i]);
sort(DOWN[i], DOWN[i] + cntDOWN[i]);
}
for (int l = 0, r = 0; l != lUP.size() || lDOWN.size() != r;) {
int vl = 1e9, vr = 1e9;
if (l != lUP.size()) vl = lUP[l];
if (r != lDOWN.size()) vr = lDOWN[r];
if (vl <= vr) {
l++;
long long v = vl;
int lastDigit = (long long)v % 10;
long long ost = (n - 10000000LL * (long long)v) % n;
v *= 10000000LL;
if (ost < 0) ost += n;
for (int digit = 0; digit <= lastDigit - 1; digit++) {
int rpos = (int)(upper_bound(UP[digit], UP[digit] + cntUP[digit], ost) -
UP[digit]);
int lpos = (int)(lower_bound(UP[digit], UP[digit] + cntUP[digit], ost) -
UP[digit]);
if (rpos > lpos) {
long long cnt = rpos - lpos;
if (k > cnt)
k -= cnt;
else {
for (int i = 0; i < rUP[digit].size(); i++)
if ((v + (long long)rUP[digit][i]) % n == 0) {
k--;
if (k == 0) {
cout << v / 10000000LL;
if (digit == 0) cout << 0;
cout << rUP[digit][i];
return;
}
}
}
}
}
} else {
r++;
long long v = vr;
int lastDigit = (long long)v % 10;
long long ost = (n - 10000000LL * (long long)v) % n;
v *= 10000000LL;
if (ost < 0) ost += n;
for (int digit = lastDigit + 1; digit <= 9; digit++) {
int rpos =
(int)(upper_bound(DOWN[digit], DOWN[digit] + cntDOWN[digit], ost) -
DOWN[digit]);
int lpos =
(int)(lower_bound(DOWN[digit], DOWN[digit] + cntDOWN[digit], ost) -
DOWN[digit]);
if (rpos > lpos) {
long long cnt = rpos - lpos;
if (k > cnt)
k -= cnt;
else {
for (int i = 0; i < rDOWN[digit].size(); i++)
if ((v + (long long)rDOWN[digit][i]) % n == 0) {
k--;
if (k == 0) {
cout << v / 10000000LL << rDOWN[digit][i];
return;
}
}
}
}
}
}
}
cout << -1 << endl;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100010];
bool vis[100010];
long long n, m, total = 0;
long long cc[100010];
void dfs(long long s, long long sum) {
if (vis[s]) return;
vis[s] = 1;
if (cc[s])
sum++;
else
sum = 0;
if (sum > m) return;
if (s != 1 && adj[s].size() == 1) {
total++;
}
for (int i = 0; i < adj[s].size(); i++) {
dfs(adj[s][i], sum);
}
}
int main() {
long long i, j, k;
long long u, v;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> cc[i];
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
cout << total;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
bool sign = false;
for (int i = 0; i < n; i++) {
if (s[i] == 'a' && !sign) continue;
if (s[i] == 'a' && sign) break;
s[i]--;
sign = true;
}
if (!sign) s[n - 1] = 'z';
cout << s << '\n';
}
| 1 |
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
int n;
while (1){
list<int> lst_taro, lst_hana;
char flag[201] = {0};
cin >> n;
if (n == 0){
break;
}
for (int i = 0; i < n; i++){
int c;
cin >> c;
lst_taro.push_back(c);
flag[c] = 1;
}
lst_taro.sort();
for (int i = 1; i <= 2 * n; i++){
if (flag[i] == 0){
lst_hana.push_back(i);
}
}
int field = 0;
int count = 0;
while (lst_taro.size() > 0 && lst_hana.size() > 0){
list<int>::iterator it = count % 2 == 0 ? lst_taro.begin() : lst_hana.begin();
list<int>::iterator end = count % 2 == 0 ? lst_taro.end() : lst_hana.end();
while (it != end){
if (*it > field){
break;
}
it++;
}
if (it == end){
field = 0;
}
else {
field = *it;
(count % 2 == 0 ? lst_taro : lst_hana).erase(it);
}
count++;
}
cout << lst_hana.size() << endl << lst_taro.size() << endl;
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const signed int inf = (signed)(~0u >> 1), Val = 1e9;
typedef class SegTreeNode {
public:
int val;
SegTreeNode *l, *r;
SegTreeNode() {}
void pushUp() {
if (l) val = l->val;
if (r) val = max(val, r->val);
}
} SegTreeNode;
SegTreeNode pool[2000000];
SegTreeNode* top = pool;
SegTreeNode* newnode() {
top->l = top->r = NULL;
return top++;
}
typedef class SegTree {
public:
SegTreeNode* rt;
SegTree() : rt(NULL) {}
void update(SegTreeNode*& p, int l, int r, int ql, int qr, int val) {
if (!p) p = newnode(), p->val = inf;
if (l == ql && r == qr) {
p->val = min(p->val, val);
return;
}
int mid = (l + r) >> 1;
if (qr <= mid)
update(p->l, l, mid, ql, qr, val);
else if (ql > mid)
update(p->r, mid + 1, r, ql, qr, val);
else {
update(p->l, l, mid, ql, mid, val);
update(p->r, mid + 1, r, mid + 1, qr, val);
}
}
int query(SegTreeNode* p, int l, int r, int idx) {
if (!p) return inf;
if (l == r) return p->val;
int mid = (l + r) >> 1, a = p->val, b = 0;
if (idx <= mid)
b = query(p->l, l, mid, idx);
else
b = query(p->r, mid + 1, r, idx);
return min(a, b);
}
void update(SegTreeNode*& p, int l, int r, int idx, int val) {
if (!p) p = newnode(), p->val = -1;
if (l == r) {
p->val = val;
return;
}
int mid = (l + r) >> 1;
if (idx <= mid)
update(p->l, l, mid, idx, val);
else
update(p->r, mid + 1, r, idx, val);
p->pushUp();
}
int query(SegTreeNode* p, int l, int r, int ql, int qr) {
if (!p) return -1;
if (l == ql && r == qr) return p->val;
int mid = (l + r) >> 1;
if (qr <= mid) return query(p->l, l, mid, ql, qr);
if (ql > mid) return query(p->r, mid + 1, r, ql, qr);
int a = query(p->l, l, mid, ql, mid);
int b = query(p->r, mid + 1, r, mid + 1, qr);
return max(a, b);
}
} SegTree;
typedef class Query {
public:
int l, r, id, res;
bool operator<(Query b) const { return r < b.r; }
} Query;
int n, m;
int* ar;
SegTree st, stv;
Query* qs;
inline void init() {
scanf("%d", &n);
ar = new int[(n + 1)];
for (int i = 1; i <= n; i++) scanf("%d", ar + i);
scanf("%d", &m);
qs = new Query[(m + 1)];
for (int i = 1; i <= m; i++) {
scanf("%d%d", &qs[i].l, &qs[i].r);
qs[i].id = i, qs[i].res = inf;
}
}
inline void solve() {
sort(qs + 1, qs + m + 1);
for (int s = 0, c = 0; s < 2; s++) {
st.rt = stv.rt = NULL, top = pool, c = 1;
for (int i = 1; i <= n; i++) {
int rlim = Val, idx;
while (ar[i] <= rlim &&
(idx = stv.query(stv.rt, 0, Val, ar[i], rlim)) != -1) {
st.update(st.rt, 1, n, 1, idx, ar[idx] - ar[i]);
rlim = ((ar[idx] + ar[i] - 1) >> 1);
}
stv.update(stv.rt, 0, Val, ar[i], i);
for (; c <= m && qs[c].r == i; c++)
qs[c].res = min(qs[c].res, st.query(st.rt, 1, n, qs[c].l));
}
for (int i = 1; i <= n; i++) ar[i] = Val - ar[i];
}
for (int i = 1; i <= m; i++)
while (qs[i].id != i) swap(qs[i], qs[qs[i].id]);
for (int i = 1; i <= m; i++) printf("%d ", qs[i].res);
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 0, b = 0, c, n, t;
cin >> n >> t;
vector<long long> p;
for (long long i = 0; i < n; i++) {
cin >> c;
p.push_back(c);
}
a = 0;
for (long long i = 1; i < n; i++) {
if (p[i] == p[i - 1]) {
a++;
p[i] = p[i - 1] + t;
} else if (p[i - 1] > p[i]) {
b = p[i - 1] - p[i];
a = a + (b / t) + 1;
p[i] = p[i] + (t * ((b / t) + 1));
}
}
cout << a << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long sum[1000006], mod = 1e9 + 7;
int main() {
int n;
while (scanf("%d", &n) == 1) {
memset(sum, 0, sizeof(sum));
sum[0] = 1;
int t;
for (int i = 0; i < n; ++i) {
scanf("%d", &t);
vector<int> d;
for (int j = 1; j * j <= t; ++j) {
if (t % j) continue;
d.push_back(j);
if (j * j != t) d.push_back(t / j);
}
sort(d.begin(), d.end(),
[&](const int &x, const int &y) { return y < x; });
int len = d.size();
for (int j = 0; j < len; ++j) {
sum[d[j]] += sum[d[j] - 1];
sum[d[j]] %= mod;
}
}
long long ans = 0;
for (int i = 1; i < 1000006; ++i) {
ans += sum[i];
}
ans %= mod;
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int n, x, c, ans, now, dlt;
int main()
{
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
{
dlt = 0;
scanf("%d", &x);
c = (int)log2(x);
if(x != (1 << c)) dlt = 1;
if(now < c) ans += c - now, now = c;
if(now > c) now = c, dlt = 0;
if(dlt) ++ans, ++now;
}
printf("%d\n", ans);
return 0;
} | 0 |
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
#include <random>
#include <cstdio>
#include <cstring>
#include <cmath>
// for i in f..<t { as swift
#define forin(i, f, t) for(auto i = f; i < t; i++)
using namespace std;
using ll = long long;
using XY = pair<int, int>;
vector<vector<int>> nodes;
vector<bool> visited;
void mark(int t, int c, int id, vector<int> &map) {
if (c == t || visited[c]) return;
visited[c] = true;
map[c] = id;
cerr << c << endl;
forin(i, 0, nodes[c].size()) {
mark(t, nodes[c][i], id, map);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<XY> e(m);
nodes.resize(n + 1);
forin(i, 0, m) {
cin >> e[i].first >> e[i].second;
nodes[e[i].first].push_back(e[i].second);
}
vector<vector<int>> fMap(n + 1, vector<int>(n + 1, 0)), dMap(n + 1, vector<int>(n + 1, 0));
forin(i, 1, n + 1) {
visited.assign(n + 1, false);
int id = 1;
forin(j, 0, nodes[i].size()) {
mark(i, nodes[i][j], id++, fMap[i]);
}
visited.assign(n + 1, false);
id = (int)nodes[i].size();
for (auto j = nodes[i].size(); j > 0; --j) {
mark(i, nodes[i][j - 1], id--, dMap[i]);
}
}
forin(i, 0, m) {
auto edge = e[i];
if ((fMap[edge.first][edge.second] != dMap[edge.first][edge.second]) == (fMap[edge.second][edge.first] > 0)) {
cout << "same" << endl;
} else {
cout << "diff" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int p[N], l[N], e[N];
int x[N], y[N];
vector<int> qry[N];
stack<int> st;
int f[N];
int ans[N];
int s[N];
int find(int x) {
if (f[x] != x) f[x] = find(f[x]);
return f[x];
}
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &l[i]);
e[i] = p[i] + l[i];
f[i] = i;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x[i], &y[i]);
qry[x[i]].push_back(i);
}
for (int i = n; i >= 1; i--) {
while (!st.empty() && p[st.top()] <= e[i]) {
f[st.top()] = i;
e[i] = max(e[i], e[st.top()]);
st.pop();
}
if (st.empty())
s[i] = 0;
else {
s[i] = s[st.top()] + p[st.top()] - e[i];
}
st.push(i);
for (auto j : qry[i]) {
ans[j] = s[i] - s[find(y[j])];
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.