solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 9;
int main() {
long long i, n;
string s;
cin >> s;
long long len = s.size();
long long j = 0;
long long ans = 0;
;
for (i = 0; i < len; i++) {
long long flag = 0, k = 1;
while (j < len) {
if (j - 2 * k < i) {
j++;
k = 1;
continue;
}
if (s[j] == s[j - k] && s[j] == s[j - 2 * k]) {
flag = 1;
break;
}
k++;
}
if (flag)
ans += len - j;
else
break;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
if (b >= a)
cout << b << endl;
else if (c - d > 0) {
int x = (a - b) / (c - d);
if (x * (c - d) == (a - b))
cout << b + (x * c) << endl;
else
cout << b + ((x + 1) * c) << endl;
} else
cout << "-1" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k, a, b, v, s = 0;
int main() {
cin >> k >> a >> b >> v;
while (b >= k - 1) {
s++;
b -= k - 1;
a -= v * k;
if (a <= 0) {
cout << s << endl;
return 0;
}
}
s++;
a -= (b + 1) * v;
if (a <= 0) {
cout << s << endl;
return 0;
}
if (a % v == 0) {
cout << s + a / v << endl;
return 0;
}
cout << s + a / v + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (abs(a - b) == 1 || abs(a - b) == 0 && (a != 0 && b != 0))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c;
cin >> n >> m >> c;
int sheet[n + 1], rm = n;
for (int i = 1; i <= n; i++) sheet[i] = -1;
while (rm) {
int p, k;
cin >> p;
if (p <= c / 2) {
k = 1;
while (true) {
if ((sheet[k] == -1) or (p < sheet[k])) {
if (sheet[k] == -1) rm--;
sheet[k] = p;
break;
}
k++;
}
} else {
k = n;
while (true) {
if ((sheet[k] == -1) or (p > sheet[k])) {
if (sheet[k] == -1) rm--;
sheet[k] = p;
break;
}
k--;
}
}
cout << k << endl;
cout << flush;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, p[105];
char s[105][105];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i];
getchar();
for (int i = 0; i < n; i++) gets(s[i]);
bool ans = true;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < strlen(s[i]); j++) {
if (s[i][j] == 'a' || s[i][j] == 'e' || s[i][j] == 'i' ||
s[i][j] == 'o' || s[i][j] == 'u' || s[i][j] == 'y')
sum++;
}
if (sum != p[i]) ans = false;
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int num[200005];
int cmp(int x, int y) { return x < y; }
int min(int x, int y) { return x < y ? x : y; }
int main() {
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
}
sort(num, num + n, cmp);
int maxn = 1999999999;
for (int i = 0; i + n / 2 < n; i++) {
maxn = min(maxn, num[n / 2 + i] - num[i]);
}
printf("%d\n", maxn);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100][2][2][2][2];
const long long inf = 1e18;
long long a, b;
long long call(int i, long long x, long long y) {
if (i == 0) return (max(x, y) <= b && min(x, y) >= a ? 0 : -inf);
long long mask = ((1LL << i) - 1);
long long bit = (1LL << (i - 1));
long long hex = x & ~mask;
long long hey = y & ~mask;
long long low = a & ~mask;
long long hi = b & ~mask;
if (max(hex, hey) > hi || min(hex, hey) < low) return -inf;
long long &ret = dp[i][hex == low][hex == hi][hey == low][hey == hi];
if (~ret) return ret;
ret = -2;
ret = max(ret, call(i - 1, x | bit, y | bit));
ret = max(ret, bit | call(i - 1, x | bit, y));
ret = max(ret, bit | call(i - 1, x, y | bit));
ret = max(ret, call(i - 1, x, y));
return ret;
}
int main(int argc, char const *argv[]) {
cin >> a >> b;
memset(dp, -1, sizeof dp);
cout << call(62, 0, 0) << endl;
return 0;
}
| 4 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long LL;
int n;
int main() {
scanf("%d",&n);
int ans=2e9;
LL sum=0;
for (int i=1;i<=n;i++) {
int x,y;
scanf("%d%d",&x,&y);
if (x>y) ans=min(ans,y);
sum+=x+y;
}
if (ans==2e9) {
printf("0\n");
return 0;
}
sum=sum/2-ans;
printf("%lld\n",sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int main() {
int n, k, x;
cin >> n >> k >> x;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int sum = 0;
for (int i = 0; i < n - k; i++) {
sum += arr[i];
}
int m = (n - (n - k)) * x;
int p = m + sum;
cout << p << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n >= 6) {
if (n == 6) {
printf("1 2\n1 3\n1 4\n2 5\n2 6\n");
} else if (n == 7) {
printf("1 2\n1 3\n1 4\n2 5\n2 6\n2 7\n");
} else {
for (int i = 2; i <= n / 2; i++) {
printf("1 %d\n", i);
}
for (int i = n / 2 + 1; i <= n; i++) {
printf("2 %d\n", i);
}
}
printf("1 2\n1 3\n");
for (int i = 2; i <= n - 3; i += 2) {
printf("%d %d\n", i, i + 2);
printf("%d %d\n", i, i + 3);
}
if (n % 2 == 0) printf("%d %d\n", n - 2, n);
} else {
printf("-1\n");
if (n == 2) printf("1 2");
if (n == 3) printf("1 2\n1 3");
if (n == 4) printf("1 2\n1 3\n1 4");
if (n == 5) printf("1 2\n1 3\n1 4\n1 5");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int ar[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &ar[i][j]);
}
}
int max = 0;
for (int i = 0; i < n; ++i) {
int min = INT_MAX;
for (int j = 0; j < m; ++j) {
if (min > ar[i][j]) {
min = ar[i][j];
}
}
if (max < min) {
max = min;
}
}
printf("%d", max);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
int m;
cin >> m;
int sum = 0;
while (m) {
if (arr.size()) {
sum += arr[0];
arr.erase(arr.begin());
} else
sum -= d;
m--;
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct node {
int sz, Max[11], Min[11];
friend bool operator<(const node &x, const node &y) {
for (int i = 1; i <= k; i++)
if (x.Max[i] > y.Min[i]) return 0;
return 1;
}
void operator+=(const node &x) {
for (int i = 1; i <= k; i++)
Min[i] = min(Min[i], x.Min[i]), Max[i] = max(Max[i], x.Max[i]);
sz += x.sz;
}
} x, y;
set<node> s;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) scanf("%d", &x.Min[j]), x.Max[j] = x.Min[j];
x.sz = 1;
while (!s.empty() && s.find(x) != s.end())
y = *s.find(x), s.erase(s.find(x)), x += y;
s.insert(x);
printf("%d\n", (*(--s.end())).sz);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long pre[5];
};
node tree[4 * 1000005];
int in[1000005], arr[1000005];
int n, k, i;
long long cnt[5];
void query(int nod, int s, int e, int i, int j) {
if (s > j || e < i) return;
if (s >= i && e <= j) {
for (int i = 1; i <= 3; i++) cnt[i] = cnt[i] + tree[nod].pre[i];
return;
}
int mid = (s + e) / 2, l = 2 * nod, r = l + 1;
query(l, s, mid, i, j);
query(r, mid + 1, e, i, j);
}
void update(int nod, int s, int e, int i) {
if (s > i || e < i) return;
if (s == e) {
tree[nod].pre[1] += 1;
for (int i = 1; i < 3; i++) tree[nod].pre[i + 1] += cnt[i];
return;
}
int mid = (s + e) / 2, l = 2 * nod, r = l + 1;
update(l, s, mid, i);
update(r, mid + 1, e, i);
for (int i = 1; i <= 3; i++)
tree[nod].pre[i] = tree[l].pre[i] + tree[r].pre[i];
}
int main() {
scanf("%d", &n);
int tt = k;
for (i = 1; i <= n; i++) {
scanf("%d", &in[i]);
arr[i] = in[i];
}
map<int, int> mp;
int k = 1;
sort(arr + 1, arr + n + 1);
for (i = 1; i <= n; i++) {
mp[arr[i]] = i;
}
for (i = n; i >= 1; i--) {
memset(cnt, 0, sizeof cnt);
query(1, 1, n, 1, mp[in[i]] - 1);
update(1, 1, n, mp[in[i]]);
}
printf("%I64d\n", tree[1].pre[3]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int fx[] = {1, -1, 0, 0};
int fy[] = {0, 0, 1, -1};
int arr[n + 1][n + 1];
for (int i = 1; i <= n; i += 1) {
for (int j = 1; j <= n; j += 1) {
arr[i][j] = 1;
}
}
int c = 0;
for (int i = 1; i <= n; i += 1) {
for (int j = 1; j <= n; j += 1) {
if (arr[i][j] == 1) {
c += 1;
for (int k = 0; k < 4; k += 1) {
int x = i + fx[k];
int y = j + fy[k];
if (x >= 1 && x <= n && y >= 1 && y <= n) {
arr[x][y] = 0;
}
}
}
}
}
cout << c << endl;
for (int i = 1; i <= n; i += 1) {
for (int j = 1; j <= n; j += 1) {
if (arr[i][j] == 1) {
cout << "C";
} else {
cout << ".";
}
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int x, y, z, K;
cin >> x >> y >> z >> K;
vector<ll> a(x), b(y), c(z);
rep(i, x) cin >> a[i]; sort(a.begin(), a.end(), greater<ll>());
rep(i, y) cin >> b[i]; sort(b.begin(), b.end(), greater<ll>());
rep(i, z) cin >> c[i]; sort(c.begin(), c.end(), greater<ll>());
vector<ll> abc;
rep(i, x)rep(j, y)rep(k, z) {
if ((i+1)*(j+1)*(k+1) <= K) abc.push_back(a[i]+b[j]+c[k]);
else break;
}
sort(abc.begin(), abc.end(), greater<ll>());
rep(i, K) cout << abc[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int noCases = 0;
cin >> noCases;
for (int i = 0; i < noCases; i++) {
long long x, y, a, b = 0;
long long usedA = 0;
long long usedB = 0;
cin >> x >> y >> a >> b;
long long maxNumber = max(x, y);
long long minNumber = min(x, y);
long long op1 = ((maxNumber - minNumber) * a) + (minNumber * b);
long long op3 = (x * a) + (y * a);
if (x == y) {
long long op4 = x * b;
long long temp = min(op1, op3);
long long total = min(temp, op4);
cout << total << endl;
} else {
long long total = min(op1, op3);
cout << total << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005], pos[100005];
bool win[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, ai;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ai;
arr[i] = ai;
pos[ai] = i;
}
for (int i = n - 1; i >= 1; --i) {
for (int j = pos[i] + i; j <= n; j += i) {
if (!win[arr[j]] && arr[j] > i) win[i] = 1;
}
for (int j = pos[i] - i; j >= 1; j -= i) {
if (!win[arr[j]] && arr[j] > i) win[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (win[arr[i]])
cout << "A";
else
cout << "B";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 7;
const long long MOD = 1E9 + 7;
long long res = 0, fact[N], rev[N], dp[N][N];
vector<int> G[N];
int timer = 0, cnt[N], tin[N], depth[N], sum[N];
void add(int pos, int val) {
if (tin[pos] != timer) {
tin[pos] = timer;
cnt[pos] = 0;
}
cnt[pos] += val;
}
int get(int pos) {
if (tin[pos] != timer) {
tin[pos] = timer;
cnt[pos] = 0;
}
return cnt[pos];
}
void dfs(int v, int par) {
depth[v] = depth[par] + 1;
add(depth[v], 1);
for (int to : G[v]) {
if (to == par) continue;
dfs(to, v);
}
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
res = 0;
for (int root = 1; root <= n; ++root) {
if (G[root].size() < k) continue;
for (int i = 0; i <= n; ++i) {
for (int j = 1; j <= k; ++j) dp[i][j] = 0;
dp[i][0] = 1;
sum[i] = 0;
}
depth[root] = 0;
for (int v : G[root]) {
++timer;
dfs(v, root);
for (int dep = 1; dep <= n; ++dep) {
if (get(dep) == 0) continue;
for (int ct = min(k - 1, sum[dep]); ct >= 0; --ct) {
dp[dep][ct + 1] = (dp[dep][ct + 1] + dp[dep][ct] * get(dep)) % MOD;
}
sum[dep] = min(sum[dep] + 1, k);
}
}
for (int dep = 1; dep <= n; ++dep) res = (res + dp[dep][k]) % MOD;
}
if (k == 2) {
res = long long(n) * (n - 1) / 2 % MOD;
}
if (k == 1) {
res = n;
}
cout << res << endl;
for (int i = 1; i <= n; ++i) G[i].clear();
}
long long binpow(long long x, int power) {
long long mult = x % MOD;
x = 1;
while (power) {
if (power & 1) x = x * mult % MOD;
mult = mult * mult % MOD;
power = power >> 1;
}
return x;
}
int main() {
fact[0] = rev[0] = 1;
for (int i = 1; i < N; ++i) {
fact[i] = fact[i - 1] * i % MOD;
rev[i] = binpow(fact[i], MOD - 2);
}
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 19 * 100000 + 1000, L = 100001;
int n, m, ncnt;
struct Node {
int lc, rc, mv;
void init() {
lc = rc = -1;
mv = 0;
}
} nod[MAXN];
int new_node() {
nod[++ncnt].init();
return ncnt;
}
void init() {
for (int i = 1; i <= n; i++) new_node();
}
int query(int id, int l, int r, int y) {
if (id == -1 || l > y || r < 1) return 0;
if (1 <= l && r <= y) return nod[id].mv;
int mi = (l + r) >> 1;
return max(query(nod[id].lc, l, mi, y), query(nod[id].rc, mi + 1, r, y));
}
void update(int id, int l, int r, int y, int v) {
Node &no = nod[id];
no.mv = max(no.mv, v);
if (l == r) return;
int mi = (l + r) >> 1;
if (y <= mi) {
if (no.lc == -1) no.lc = new_node();
update(no.lc, l, mi, y, v);
} else {
if (no.rc == -1) no.rc = new_node();
update(no.rc, mi + 1, r, y, v);
}
}
int main() {
scanf("%d%d", &n, &m);
int ans = 0, a, b, w;
init();
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &w);
++w;
int cv = (w > 1) ? query(a, 1, L, w - 1) : 0;
++cv;
ans = max(ans, cv);
update(b, 1, L, w, cv);
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void print(int n) {
if (n == 0) {
putchar('0');
putchar('\n');
} else if (n == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
char buf[11];
buf[10] = '\n';
int i = 9;
while (n) {
buf[i--] = n % 10 + '0';
n /= 10;
}
while (buf[i] != '\n') putchar(buf[++i]);
}
}
int read() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';) cc = getc(stdin);
int ret = 0;
for (; cc >= '0' && cc <= '9';) {
ret = ret * 10 + cc - '0';
cc = getc(stdin);
}
return ret;
}
string read1() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';) cc = getc(stdin);
string r = "";
for (; cc >= '0' && cc <= '9';) {
r += cc;
cc = getc(stdin);
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
int m;
string s, t;
cin >> n >> m >> s >> t;
if (n - 1 > m) {
cout << "NO\n";
return 0;
}
if (m != n) {
bool is = false;
for (int i = 0; i < n; i++) {
if (s[i] == '*') is = true;
}
if (!is) {
cout << "NO\n";
return 0;
}
}
int i = 0, j = 0;
bool is = false;
while (i < n) {
if (s[i] == t[j])
i++, j++;
else if (s[i] == '*')
break;
else {
cout << "NO\n";
return 0;
}
}
i = n - 1, j = m - 1;
while (i >= 0) {
if (s[i] == t[j])
i--, j--;
else if (s[i] == '*') {
cout << "YES\n";
return 0;
} else {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool mat[3001][3001];
vector<int> v[3010];
int main() {
int n, m, a, b, result = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) mat[i][j] = false;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
mat[a][b] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
int r = 0;
for (int k = 0; k < v[i].size(); k++) {
if (mat[v[i][k]][j] == true) r++;
}
result += (r * (r - 1)) / 2;
}
}
}
cout << result;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define R(i,n) for(int i=0;i<n;++i)
int n,a,b,y[]={1000,100,10,1};
map<char,int> x;
string s,t="mcxi";
int main(){
x['m']=1000,x['c']=100,x['x']=10,x['i']=1;
cin>>n;
R(i,n){
a=0;
R(j,2){
cin>>s;
R(k,s.size())
t.find(s[k])!=string::npos?a+=x[s[k]]:a+=(s[k]-'0')*x[s[++k]];
}
R(j,4){
b=1;
while(a/y[j])a-=y[j],++b;
--b>1&&cout<<b<<t[j];
--b||cout<<t[j];
}cout<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long iMatrixMultiply(long long multiplicant1, long long multiplicant2,
long long ivalue = (long long)1023123123 *
(long long)1023123123) {
return (multiplicant1 * multiplicant2) % ivalue;
}
long long iMatrixAdd(long long operand1, long long operand2,
long long ivalue = (long long)1023123123 *
(long long)1023123123) {
return (operand1 + operand2) % ivalue;
}
vector<vector<long long> > MatrixIdentity(int row_and_col) {
vector<vector<long long> > ret = vector<vector<long long> >(
row_and_col, vector<long long>(row_and_col, 0));
for (int(i) = 0; (i) < (row_and_col); ++(i)) ret[i][i] = 1LL;
return ret;
}
vector<vector<long long> > MatrixMultiply(
vector<vector<long long> > first_matrix,
vector<vector<long long> > second_matrix,
long long ivalue = (long long)1023123123 * (long long)1023123123) {
vector<vector<long long> > ret;
if (first_matrix[0].size() != second_matrix.size())
printf("ukuran salah untuk perkalian. %d %d x %d %d\n", first_matrix.size(),
first_matrix[0].size(), second_matrix.size(),
second_matrix[0].size());
for (int(i) = 0; (i) < (((int)first_matrix.size())); ++(i)) {
vector<long long> ret_row_i;
for (int(j) = 0; (j) < (((int)second_matrix[0].size())); ++(j)) {
long long value = 0LL;
for (int(k) = 0; (k) < (((int)second_matrix.size())); ++(k)) {
value = iMatrixAdd(
value,
iMatrixMultiply(first_matrix[i][k], second_matrix[k][j], ivalue),
ivalue);
}
ret_row_i.push_back(value);
}
ret.push_back(ret_row_i);
}
return ret;
}
vector<vector<long long> > MatrixPower(
vector<vector<long long> > matrix, long long pangkat,
long long ivalue = (long long)1023123123 * (long long)1023123123) {
vector<vector<long long> > ret = MatrixIdentity(((int)matrix.size()));
while (pangkat > 0LL) {
if (pangkat % 2LL) {
ret = MatrixMultiply(ret, matrix, ivalue);
}
pangkat /= 2LL;
matrix = MatrixMultiply(matrix, matrix, ivalue);
}
return ret;
}
vector<long long> MatrixPowerSolver(vector<vector<long long> > matrix,
long long pangkat,
vector<long long> operand_vector,
long long ivalue = (long long)1023123123 *
(long long)1023123123) {
vector<vector<long long> > parsed_operand_vector(((int)operand_vector.size()),
vector<long long>(1, 0));
for (int(i) = 0; (i) < (((int)operand_vector.size())); ++(i))
parsed_operand_vector[i][0] = operand_vector[i];
vector<vector<long long> > unparsed_ret = MatrixMultiply(
MatrixPower(matrix, pangkat, ivalue), parsed_operand_vector, ivalue);
vector<long long> ret(((int)unparsed_ret.size()), 0);
for (int(i) = 0; (i) < (((int)unparsed_ret.size())); ++(i))
ret[i] = unparsed_ret[i][0];
return ret;
}
long long fibo(long long x, long long ivalue = (long long)1023123123 *
(long long)1023123123) {
if (x == 0) return 0 % ivalue;
if (x == 1) return 1 % ivalue;
if (x == 2) return 1 % ivalue;
vector<vector<long long> > matrix(2, vector<long long>(2));
matrix[0][0] = 0LL;
matrix[0][1] = 1LL;
matrix[1][0] = 1LL;
matrix[1][1] = 1LL;
vector<long long> init(2);
init[0] = 0;
init[1] = 1;
vector<long long> hasil = MatrixPowerSolver(matrix, x - 1, init, ivalue);
return hasil[1];
}
long long power(long long a, long long b, long long c) {
long long ret = 1;
long long kali = a;
while (b > 0LL) {
if (b % 2LL) {
ret *= kali;
ret %= c;
}
b /= 2LL;
kali *= kali;
kali %= c;
}
return ret;
}
int main() {
int n;
cin >> n;
long long x, y;
cin >> x >> y;
long long p;
cin >> p;
vector<long long> m;
for (int(i) = 0; (i) < (n); ++(i)) {
int buf;
scanf("%d", &buf);
m.push_back(buf);
}
if (n == 1) {
cout << m[0] % p << endl;
return 0;
}
long long xnormal = power(3LL, x, p) % p;
long long xspecial = ((power(3LL, x, 2LL * p) + 1LL) / 2LL) % p;
long long ynormal = power(3LL, y, p) % p;
long long yspecial = ((power(3LL, y, 2LL * p) + 1LL) / 2LL) % p;
long long sum = 0LL;
for (int(i) = 0; (i) < (n); ++(i)) {
if (i == 0 || i == n - 1) {
sum = (sum + ((m[i] * xspecial) % p)) % p;
continue;
}
sum = (sum + ((m[i] * xnormal) % p)) % p;
}
long long smallest = (m[0]) % p;
long long biggest =
((fibo(x, p) * m[n - 2]) % p) + ((fibo(x + 1LL, p) * m[n - 1]) % p);
biggest %= p;
sum -= smallest;
sum -= biggest;
while (sum < 0LL) sum += p;
sum = (sum * ynormal) % p;
sum = (sum + ((smallest * yspecial) % p)) % p;
sum = (sum + ((biggest * yspecial) % p)) % p;
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
template <typename A, typename B>
inline ostream& operator<<(ostream& out, const pair<A, B>& p) {
return out << p.X << " " << p.Y << " ";
}
template <typename T>
inline ostream& operator<<(ostream& out, const vector<T>& a) {
for (int i = 0; i < (int)((int)(a.size())); ++i) {
if (i) out << ' ';
out << a[i];
}
return out << " ";
}
template <typename T>
inline ostream& operator<<(ostream& out, const set<T>& a) {
return out << vector<T>(a.begin(), a.end());
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(5e5) + 9;
const int M = int(2e2) + 9;
const int LOGN = 22;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = 1e9 + 100;
const long long INF64 = 2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
struct edge {
int to, f, c, rev;
};
const int V = 1000 * 1000 + 3;
vector<edge> g[V];
int lev[V];
int head, tail, q[V];
inline bool bfs(int s, int t) {
memset(lev, 63, sizeof(lev));
head = tail = 0;
lev[s] = 0;
q[head++] = s;
while (head != tail) {
int v = q[tail++];
for (int i = 0; i < (int)((int)(g[v].size())); ++i)
if (g[v][i].f < g[v][i].c && lev[g[v][i].to] > lev[v] + 1) {
lev[g[v][i].to] = lev[v] + 1;
q[head++] = g[v][i].to;
}
}
return lev[t] < INF / 2;
}
inline void add(int from, int to, int c) {
edge f = {to, 0, c, (int)(g[to].size())};
edge b = {from, 0, 0, (int)(g[from].size())};
g[from].push_back(f);
g[to].push_back(b);
}
int ptr[V];
int dfs(int v, int t, int f) {
if (v == t) return f;
for (; ptr[v] < (int)(g[v].size()); ++ptr[v]) {
edge& e = g[v][ptr[v]];
if (e.f == e.c || lev[e.to] != lev[v] + 1) continue;
int df = dfs(e.to, t, min(f, e.c - e.f));
if (df > 0) {
e.f += df;
g[e.to][e.rev].f -= df;
return df;
}
}
return 0;
}
inline int dinic(int s, int t) {
int ans = 0;
while (bfs(s, t)) {
memset(ptr, 0, sizeof(ptr));
for (int f; (f = dfs(s, t, INF)) != 0; ans += f)
;
}
return ans;
}
int n, b, m;
pair<int, int> a[N];
void solve() {
cin >> n >> b >> m;
for (int i = 0; i < (int)(m); ++i) cin >> a[i].first >> a[i].second;
sort(a, a + m);
m = unique(a, a + m) - a;
for (int i = 1; i < (int)(m); ++i) {
if (a[i - 1].second > a[i].second) {
cout << "unfair";
return;
}
if (a[i - 1].second != a[i].second && a[i - 1].first == a[i].first) {
cout << "unfair";
return;
}
}
for (int i = 0; i < (int)(5); ++i) add(0, 100 * 1000 + (i % 5), n / 5);
for (int i = 1; i <= b; ++i) add(100 * 1000 + (i % 5), i, 1);
int pos = 0;
for (int i = 1; i <= b; ++i) {
while (pos < m && a[pos].first < i) ++pos;
add(i, pos + 1 + b, 1);
}
pos = 0;
for (int i = b + 1; i <= b + m + 1; ++i, ++pos) {
int r = (pos == m ? n : a[pos].second);
int l = (pos == 0 ? 0 : a[pos - 1].second);
add(i, N - 1, r - l);
}
if (dinic(0, N - 1) == n)
cout << "fair";
else
cout << "unfair";
}
int main() {
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7fffffffffffffff;
int c[1001][1001];
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
long long s = 0, sij = 0, si = 0, sj = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int p = (i - 1) * 4 + 2, q = (j - 1) * 4 + 2;
scanf("%d", &c[i][j]);
s += c[i][j];
sij += (long long)c[i][j] * (p * p + q * q);
si += c[i][j] * p;
sj += c[i][j] * q;
}
}
int x, y;
long long ans = inf;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int p = i * 4, q = j * 4;
long long temp = s * (p * p + q * q) - 2 * si * p - 2 * sj * q + sij;
if (temp < ans) {
ans = temp;
x = i;
y = j;
}
}
}
printf("%I64d\n%d %d\n", ans, x, y);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int cnt[30];
vector<int> prm;
vector<pair<int, int> > tmp;
bool isprime(int n) {
int s = sqrt(n), i;
for (i = 2; i <= s; i++)
if (n % i == 0) return false;
return true;
}
int main() {
int i, j, k, flag;
for (i = 2; i <= 1000; i++)
if (isprime(i)) prm.push_back(i);
while (cin >> a) {
memset(cnt, 0, sizeof(cnt));
b = a;
tmp.clear();
for (i = 0; i < a.size(); i++) {
cnt[a[i] - 'a']++;
b[i] = '#';
}
for (i = 0; i < 26; i++) {
if (cnt[i]) tmp.push_back(pair<int, int>(cnt[i], i));
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
k = 0;
flag = 0;
for (i = 0; i < prm.size() && prm[i] <= a.size(); i++) {
for (j = prm[i] - 1; j < a.size(); j += prm[i]) {
if (b[j] == '#') {
if (tmp[k].first) {
b[j] = tmp[k].second + 'a';
tmp[k].first--;
} else {
flag = 1;
break;
}
} else if (b[j] - 'a' != tmp[k].second) {
flag = 1;
break;
}
}
if (flag) break;
while (tmp[k].first == 0) k++;
}
if (!flag) {
b[0] = tmp[k].second + 'a';
cout << "YES" << endl << b << endl;
} else
cout << "NO" << endl;
;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool ok(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
int main() {
int n, q;
cin >> n >> q;
int free = n;
int t[q], kol[q], time[q];
for (int i = 0; i < q; i++) {
cin >> t[i] >> kol[i] >> time[i];
}
int last = 0, k = 0;
map<int, int> a;
for (int i = 0; i < q; i++) {
int res = 0;
int c = kol[i];
for (int j = 0; j < n; j++) {
if (a[j] <= t[i] && kol[i] != 0) {
kol[i]--;
}
}
if (kol[i] != 0) {
cout << -1 << endl;
} else {
for (int j = 0; j < n; j++) {
if (a[j] <= t[i] && c != 0) {
a[j] = t[i] + time[i];
c--;
res += j + 1;
}
}
cout << res << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double eps = (1e-10);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
void M() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int countNumBit1(int mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1);
++ret;
}
return ret;
}
long long k, n, fl, vis[10], ok;
long long ans[10];
long long MOD = 1000000007;
int main() {
cin >> n >> k;
int s = n - k;
long long S = 1;
for (int i = 1; i <= s; i++) S = (S * s) % MOD;
long long SS = 1;
for (int i = 0; i < k - 2; i++) SS *= k;
cout << (S * k * SS) % MOD << endl;
}
| 4 |
#include<bits/stdc++.h>
#define first fi
#define second se
#define m_p make_pair
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
using namespace std;
typedef long long ll;
typedef unsigned int uint;
const double E_num = 0.57721566490153286060651209;
const int maxn = 2e5 + 10;
const int N = 5e5 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int t;
int n;
struct node
{
int x,y;
}a[maxn];
bool cmp(node a,node b)
{
return a.x < b.x;
}
int main()
{
IOS;
cin >> t;
while(t--)
{
cin >> n;
for(int i = 1;i <= n; ++i) cin >> a[i].x;
for(int i = 1;i <= n; ++i) cin >> a[i].y;
sort(a + 1,a + 1 + n,cmp);
ll ans= 0;
int xx = 1;
int yy = 1;
//cout << ans << endl;
for(int i = 1;i <= n; ++i)
{
if((xx + yy) % 2 == 0)
{
if(a[i].x - a[i].y == xx - yy)
ans += a[i].x - xx;
else if(((a[i].x - a[i].y) - (xx - yy))&1) ans += ((a[i].x - a[i].y) - (xx - yy) - 1) / 2;
else ans += ((a[i].x - a[i].y) - (xx - yy)) / 2;
}
else
{
if(a[i].x - a[i].y == xx - yy) ans += 0;
else if(((a[i].x - a[i].y) - (xx - yy))&1) ans += ((a[i].x - a[i].y) - (xx - yy) + 1) / 2;
else ans += ((a[i].x - a[i].y) - (xx - yy)) / 2;
}
xx = a[i].x;
yy = a[i].y;
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
struct region {
long long t, T, x, cost;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
region r[n];
for (int i = 0; i < n; i++) {
cin >> r[i].t >> r[i].T >> r[i].x >> r[i].cost;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (r[i].t >= r[i].T)
ans += r[i].cost + r[i].x * m;
else {
if (r[i].t + m <= r[i].T)
ans += r[i].cost;
else {
long long buses = ceil(double(m) / (r[i].T - r[i].t));
ans += min(r[i].cost + m * r[i].x, r[i].cost * buses);
}
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ppi = pair<int, int>;
using ppl = pair<ll, ll>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int N, K;
cin >> N >> K;
vector<int> v(N);
for (long long i = 0; i < N; ++i) cin >> v[i];
vector<int> d(N, 0);
for (long long i = 1; i < N - 1; ++i) {
if (v[i - 1] < v[i] && v[i] > v[i + 1]) {
d[i - 1] = 1;
}
}
for (int i = N - 2; 0 <= i; --i) {
d[i] += d[i + 1];
}
int ansD = 1;
int ansL = 0;
for (long long i = 1; i < N; ++i) {
int L = i - K + 1;
if (0 <= L) {
int R = i;
int ans = d[L] - d[R - 1] + 1;
if (ansD < ans) {
ansD = ans;
ansL = L;
}
}
}
cout << ansD << ' ' << ansL + 1 << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, mini = 1e5 + 1;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> l >> r;
mini = min(mini, r - l + 1);
}
cout << mini << "\n";
for (int i = 0; i < n; i++) cout << (i % mini) << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 7;
long long mp[maxn][maxn];
long long n, k;
long double C(long long n, long long m) {
long double ans = 1;
for (int i = 0; i < m; ++i) {
ans *= n - i;
ans /= m - i;
}
return ans;
}
int main() {
long long sum = 0;
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; ++i) {
mp[i][i] = -1;
for (int j = i + 1; j <= n; ++j) {
scanf("%lld", &mp[i][j]);
mp[j][i] = mp[i][j];
if (mp[i][j] != -1) sum += mp[i][j];
}
}
long double ans = 0;
long long num = 0, tmp = 0;
if (k != 2)
ans = sum * 2 / n;
else {
for (int i = 1; i <= n; ++i) {
num = tmp = 0;
for (int j = 1; j <= n; ++j) {
if (mp[i][j] != -1) {
num++;
tmp += mp[i][j];
}
}
if (num >= k) {
ans += (num - 1) * tmp;
}
}
ans /= (n - 1) * n / 2;
}
printf("%lld", (long long)(ans));
return 0;
}
| 4 |
#include <iostream>
#include <vector>
using namespace std;
template <class T> void readVal(vector<T>& vec, int idx) {
T input;
std::cin >> input;
vec[idx] = input;
}
int main()
{
char ans = '1';
int size;
cin >> size;
vector<int> x(size);
vector<int> y(size);
int dir(0), vecx(0), vecy(0);
for (int i = 0; i < size; i++) {
readVal(x, i);
readVal(y, i);
}
for (int i = 0; i <= size; i++) {
int new_vecx = x[(i + 1) % size] - x[i % size];
int new_vecy = y[(i + 1) % size] - y[i % size];
int cross_prod = (vecx * new_vecy - vecy * new_vecx);
if (cross_prod != 0) {
if (cross_prod * dir >= 0) {
dir = cross_prod > 0 ? 1 : -1;
}
else {
ans = '0';
break;
}
}
vecx = new_vecx;
vecy = new_vecy;
}
cout << ans << "\n";
return 0;
}
| 0 |
// Enjoy your stay.
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(auto it=(X).begin();it!=(X).end();it++)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
int N,a[22];
double dp[22][200010];
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin>>N;
rep(i,N)cin>>a[i];
rep(i,N+1)rep2(j,1,200001)dp[i][j] = i ? INF : 0;
rep(i,N)rep2(j,1,200001){
dp[i][j] = max(dp[i][j], i ? fabs(a[i-1] - j)/a[i-1] : 0);
for(int k = j; k <= 200000; k += j){
dp[i+1][k] = min(dp[i+1][k], dp[i][j]);
}
}
double ans = INF;
rep2(j,1,200001)ans = min(ans, max(dp[N][j], fabs(a[N-1] - j)/a[N-1]));
cout<<fixed<<setprecision(16)<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2>& v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
const long long N = 2e5 + 5, MOD = 1e9 + 7;
long double dist;
long long func(long long a, long long r, long long R) {
return a + dist <= r || R + dist <= a || R + a <= dist;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long ans = 4;
long long x1, y1, r1, R1;
cin >> x1 >> y1 >> r1 >> R1;
long long x2, y2, r2, R2;
cin >> x2 >> y2 >> r2 >> R2;
dist = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
cout << func(r1, r2, R2) + func(R1, r2, R2) + func(r2, r1, R1) +
func(R2, r1, R1);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9, MOD = INF + 7;
const int N = 1e2 + 5;
int a[N];
struct Matrix {
int n, m, A[N][N];
inline Matrix(int _n, int _m) : n(_n), m(_m) { memset(A, 0, sizeof(A)); }
inline Matrix operator*(Matrix &X) {
assert(m == X.n);
Matrix R(n, X.m);
for (int i = 0; i < n; i++)
for (int j = 0; j < X.m; j++) R[i][j] = -INF;
for (int i = 0; i < n; i++)
for (int k = 0; k < m; k++)
for (int j = 0; j < X.m; j++) R[i][j] = max(R[i][j], A[i][k] + X[k][j]);
return (R);
}
inline Matrix operator^(long long pw) {
assert(n == m);
Matrix R(n, n), T = *this;
for (int i = 0; i < n; i++)
for (int i = 0; i < n; i++) R[i][i] = 0;
for (; pw; pw >>= 1, T = T * T)
if (pw & 1) R = R * T;
return (R);
}
inline int *operator[](int i) { return A[i]; }
};
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, t;
cin >> n >> t;
Matrix g(n, n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a[i] > a[j])
g[i][j] = -INF;
else {
g[i][j] = 1;
for (int k = 0; k < j; k++)
if (a[k] <= a[j]) g[i][j] = max(g[i][j], g[i][k] + 1);
}
}
g = g ^ t;
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans = max(ans, g[i][j]);
cout << ans << "\n";
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
long long s=0;
long long t=0;
long long f=9999999999;
int a;
for(int i=1;i<=n;i++)
{
cin>>a;
if(a<0)
{
t+=1;
s+=a*-1;
if(a*-1<f)
f=a*-1;
}
else
{
s+=a;
if(a<f)
f=a;
}
}
if(t%2==0)
cout<<s;
else
cout<<s-f-f;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
cout << "0 0 " << n << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string pre[4] = {"", "0", "00", "000"};
int T[4] = {1, 10, 100, 1000};
int k, m;
bool v[10000];
int ndgt(int x) {
for (int i = 0; i < 3; ++i) {
if (x >= T[3 - i]) return i;
}
return 3;
}
bool print(int x, int s) {
int y = k < s ? s - k : k - s;
if (y < 10000 && !v[y]) {
cout << pre[ndgt(y)] << y << pre[ndgt(x)] << x << endl;
v[y] = true;
return true;
}
return false;
}
int calc(int t, int x) {
int p = 1;
int b = 0, a = 0, op_ = 0, z = x;
for (int i = 0; i < 4; ++i) {
int op = t % 4;
t /= 4;
b += (z % 10) * p;
if (op == 3) {
p *= 10;
} else {
switch (op_) {
case 0:
a = a + b;
break;
case 1:
a = a - b;
break;
case 2:
a = a * b;
break;
}
op_ = op, b = 0, p = 1;
}
z /= 10;
}
return a;
}
int rep[64];
int main1() {
int _1, _2;
while (cin >> _1 >> _2) cout << calc(_1, _2) << endl;
return 0;
}
int main() {
while (cin >> k >> m) {
for (int x = 0; x <= 9999 && m; ++x) {
memset(v, false, sizeof(v));
for (int cb = 0; cb < 64; ++cb) {
int s = calc(cb, x);
rep[cb] = s;
}
sort(rep, rep + 64);
if (print(x, rep[0])) m--;
for (int i = 1; i < 64 && m; ++i) {
if (rep[i] > rep[i - 1]) {
if (print(x, rep[i])) m--;
}
}
}
}
return 0;
}
int main2() {
string s;
int cnt = 0;
while (getline(cin, s)) {
cnt++;
if (s.size() != 8) {
cout << s << endl;
}
}
cout << "cnt=" << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const double eps = 1e-7;
struct data {
int u, v, k;
data(int u = 0, int v = 0, int k = 0) : u(u), v(v), k(k) {}
} D[5005];
int N, M, id[MAXN], idcnt;
double G[MAXN][MAXN], x[MAXN], ans[MAXN], total;
bool vis[MAXN];
struct node {
int v, next, k, id;
} E[5005];
int head[MAXN], Elen;
void add(int u, int v, int k, int id) {
++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen;
E[Elen].k = k, E[Elen].id = id;
}
int fa[MAXN];
int get(int x) {
if (fa[x] != x) fa[x] = get(fa[x]);
return fa[x];
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) fa[i] = i;
for (int i = 1; i <= M; ++i) {
scanf("%d%d%d", &D[i].u, &D[i].v, &D[i].k);
fa[get(D[i].u)] = get(D[i].v);
}
for (int i = 1; i <= N; ++i)
if (get(i) == get(1)) id[i] = ++idcnt;
for (int i = 1; i <= M; ++i)
if (get(D[i].u) == get(1) && get(D[i].v) == get(1)) {
int u = id[D[i].u], v = id[D[i].v];
--G[u][v], ++G[u][u], ++G[v][v], --G[v][u];
}
if (get(N) != get(1)) {
puts("0.000000");
for (int i = 1; i <= M; ++i) puts("0.000000");
return 0;
}
N = idcnt;
for (int i = 1; i <= N; ++i) G[1][i] = 0;
G[1][1] = 1, G[1][N + 1] = 0;
for (int i = 1; i <= N; ++i) G[N][i] = 0;
G[N][N] = 1, G[N][N + 1] = 1;
for (int i = 1; i <= N; ++i) {
int mx = i;
for (int j = i; j <= N; ++j)
if (abs(G[j][i]) > abs(G[mx][i])) mx = j;
swap(G[i], G[mx]);
for (int j = i + 1; j <= N; ++j) {
double tmp = G[j][i] / G[i][i];
for (int k = i; k <= N + 1; ++k) G[j][k] -= tmp * G[i][k];
}
}
for (int i = N; i >= 1; --i) {
double sum = 0;
for (int j = i + 1; j <= N; ++j) sum += G[i][j] * x[j];
x[i] = (G[i][N + 1] - sum) / G[i][i];
}
if (x[N] < 0) {
puts("0.000000");
for (int i = 1; i <= M; ++i) puts("0.000000");
} else {
double tmp = 1e100;
for (int i = 1; i <= M; ++i)
if (get(D[i].u) == get(1) && get(D[i].v) == get(1)) {
tmp = min(tmp, (double)D[i].k / abs(x[id[D[i].v]] - x[id[D[i].u]]));
}
for (int i = 1; i <= N; ++i) x[i] *= tmp;
for (int i = 1; i <= M; ++i)
if (get(D[i].u) == get(1) && get(D[i].v) == get(1)) {
if (id[D[i].u] == 1)
total += x[id[D[i].v]] - x[id[D[i].u]];
else if (id[D[i].v] == 1)
total += x[id[D[i].u]] - x[id[D[i].v]];
}
printf("%.6f\n", total);
for (int i = 1; i <= M; ++i) {
if (get(D[i].u) == get(1) && get(D[i].v) == get(1)) {
printf("%.6f\n", x[id[D[i].v]] - x[id[D[i].u]]);
} else {
puts("0.000000");
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1000], b[1000], c[1000], d[1000];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i] >> d[i];
int best = -1;
for (int i = 1; i <= n; i++) {
int j;
for (j = 1; j <= n; j++)
if (a[j] > a[i] and b[j] > b[i] and c[j] > c[i]) break;
if (j <= n) continue;
if (best == -1 or d[best] > d[i]) best = i;
}
cout << best << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string str;
cin >> str;
int open = 0, close = 0, least = 0;
vector<int> depth(n);
for (int i = 0; i < n; ++i) {
if (str[i] == '(') {
open++;
depth[i] = (i == 0 ? 1 : (depth[i - 1] + 1));
} else {
close++;
depth[i] = (i == 0 ? -1 : (depth[i - 1] - 1));
if (depth[i] < least) least = depth[i];
}
}
if (open != close) {
cout << "0" << endl << "1 1" << endl;
return 0;
}
for (int& d : depth) d -= least;
int num0 = 0, t;
for (int i = 0; i < n; ++i) {
if (depth[i] == 0) {
num0++;
t = i;
}
}
int ans = num0, p1 = 1, p2 = 1;
for (int i = 0; i < n; ++i) {
if (depth[(t + i) % n] == 0) {
int num1 = 0;
int j = 1;
while (depth[(t + i + j) % n] != 0) {
if (depth[(t + i + j) % n] == 1) num1++;
j++;
}
if (num1 > ans) {
ans = num1;
p1 = (t + i + 1) % n + 1;
p2 = (t + i + j) % n + 1;
}
} else if (depth[(t + i) % n] == 1 && depth[(t + i + 1) % n] == 2) {
int num2 = 0;
int j = 1;
while (depth[(t + i + j) % n] != 1) {
if (depth[(t + i + j) % n] == 2) num2++;
j++;
}
if (num0 + num2 > ans) {
ans = num0 + num2;
p1 = (t + i + 1) % n + 1;
p2 = (t + i + j) % n + 1;
}
}
}
cout << ans << endl << p1 << " " << p2 << endl;
return 0;
}
| 4 |
//#include <bits/stdc++.h>
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
//#include "boost/multiprecision/cpp_int.hpp"
//typedef boost::multiprecision::cpp_int ll;
typedef long double dd;
#define i_7 (ll)(1E9+7)
//#define i_7 998244353
#define i_5 i_7-2
ll mod(ll a){
ll c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
typedef pair<ll,ll> l_l;
typedef pair<dd,dd> d_d;
ll inf=(ll)1E16;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define pb push_back
ll max(ll a,ll b){if(a<b)return b;else return a;}
ll min(ll a,ll b){if(a>b)return b;else return a;}
void Max(ll &pos,ll val){pos=max(pos,val);}//Max(dp[n],dp[n-1]);
void Min(ll &pos,ll val){pos=min(pos,val);}
void Add(ll &pos,ll val){pos=mod(pos+val);}
dd EPS=1E-9;
#define fastio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define fi first
#define se second
#define endl "\n"
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
//template<class T>void max(T a,T b){if(a<b)return b;else return a;}
//template<class T>void min(T a,T b){if(a>b)return b;else return a;}
//template<class T>bool Max(T&a, T b){if(a < b){a = b;return 1;}return 0;}
//template<class T>bool Min(T&a, T b){if(a > b){a = b;return 1;}return 0;}
//////////////////////////
int main(){fastio
/*
ll n=10;
ll dp[n][n][n][n];memset(dp,0,sizeof(dp));
rep(i,0,n-1){
rep(j,0,n-1){
rep(k,0,n-1){
rep(l,0,n-1){
if(i-1>=0&&dp[i-1][j][k][l]==0)dp[i][j][k][l]=1;
if(j-1>=0&&dp[i][j-1][k][l]==0)dp[i][j][k][l]=1;
if(k-1>=0&&dp[i][j][k-1][l]==0)dp[i][j][k][l]=1;
if(l-1>=0&&dp[i][j][k][l-1]==0)dp[i][j][k][l]=1;
if(i*j*k*l>0&&dp[i-1][j-1][k-1][l-1]==0)dp[i][j][k][l]=1;
}
}
}
}
rep(i,0,n-1){
rep(j,0,n-1){
cout<<"ij:"<<i<<" "<<j<<endl;
rep(k,0,n-1){
rep(l,0,n-1){
cout<<dp[i][j][k][l]<<" ";
}cout<<endl;
}cout<<endl;
}cout<<endl;
}*/
ll n;cin>>n;
ll a[n];rep(i,0,n-1)cin>>a[i];
sort(a,a+n);
ll sum=0;
rep(i,0,n-1)sum+=a[i];
if(n%2==1){
if(sum%2==1)cout<<"First"<<endl;
else cout<<"Second"<<endl;
return 0;
}
if(a[0]%2==1){
cout<<"First"<<endl;
}else{
if(sum%2==1)cout<<"First"<<endl;
else cout<<"Second"<<endl;
}
return 0;
}
| 0 |
#include <cstdio>
const int MAXN = 2e5+1;
const int mo = 1e9+7;
typedef long long LL;
int fac[MAXN], inv[MAXN];
int pow(int x, int y)
{
int res = 1;
while (y)
{
if(y&1) res = LL(res) * x % mo;
x = LL(x) * x % mo;
y >>= 1;
}
return res;
}
void init(int lmt)
{
fac[0] = inv[0] = 1;
for(int i=1; i<=lmt; ++i)
fac[i] = LL(fac[i-1])*i%mo, inv[i] = pow(fac[i], mo-2);
}
int calc(int x, int y)
{
return LL(fac[x+y]) * inv[x] % mo * inv[y] % mo;
}
int main()
{
int H, W, A, B, i, ans = 0;
scanf("%d%d%d%d", &H, &W, &A, &B);
init(H+W);
for(i=B+1; i<=W; ++i)
ans = (ans + LL(calc(i-1, H-A-1)) * calc(W-i, A-1)) % mo;
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const float eps = 1e-8;
const long long lloo = 1e18;
const int oo = 2e9;
int a[200010], dau[200010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n + k; i++) a[i] = oo;
for (int i = 0; i < n; i++) {
string x;
cin >> x;
if (x == "?")
dau[i] = 1;
else {
int l = 0;
if (x[0] == '-') l = 1;
a[i] = 0;
for (int j = l, _b = x.size() - 1; j <= _b; j++) {
a[i] = a[i] * 10 + x[j] - '0';
}
if (l == 1) a[i] = -a[i];
}
}
for (int i = 0, _b = k - 1; i <= _b; i++) {
int prev = i - k;
int val = -oo;
for (int x = i; x < n + k; x += k) {
if (dau[x] == 0) {
int len = (x - prev) / k - 2;
int l = -len / 2, r = len + l;
if (r >= a[x]) {
int vec = a[x] - 1 - r;
l += vec;
r += vec;
}
if (l <= val) {
int vec = val + 1 - l;
l += vec;
r += vec;
}
if (r >= a[x]) {
cout << "Incorrect sequence";
return 0;
}
for (int z = prev + k; z < x; z += k) a[z] = l++;
prev = x;
val = a[x];
}
}
}
for (int i = 0; i < n; i++) cout << a[i] << ' ';
}
| 5 |
#include <bits/stdc++.h>
long long MOD = 1e9 + 7;
long long qpow(long long a, long long p) {
a = a % MOD;
long long ans = 1;
while (p > 0) {
if (p & 1) ans = ans * a % MOD;
a = a * a % MOD;
p >>= 1;
}
return ans;
}
int k, p;
int main() {
std::cin >> k;
long long a = 1;
int e = 1;
for (int i = 0; i < k; i++) {
long long x;
scanf("%lld", &x);
if (x % 2 == 0) e = 0;
x %= (MOD - 1);
a = (a * x) % (MOD - 1);
}
long long up, low;
if (a == 0) a = MOD - 1;
if (!e) {
up = (1 + qpow(2, a - 1)) * qpow(3, MOD - 2) % MOD;
} else {
up = (qpow(2, a - 1) - 1 + MOD) * qpow(3, MOD - 2) % MOD;
}
low = qpow(2, a - 1);
printf("%lld/%lld", up, low);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 2e5 + 7;
long long a[MAXN];
int dis[233][233];
int val[233][233];
int main(int argc, char const *argv[]) {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
scanf("%lld", &a[i]);
if (a[i] == 0) {
i--;
n--;
}
}
if (n > 400)
printf("3\n");
else {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
dis[i][j] = 1 << 28;
val[i][j] = 1 << 28;
}
}
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
if (a[i] & a[j]) {
dis[i][j] = 1;
val[i][j] = 1;
}
}
}
int ans = 1 << 28;
for (int k = 1; k <= n; ++k) {
for (int i = 1; i < k; ++i) {
for (int j = 1; j < i; ++j) {
ans = min(ans, dis[i][j] + val[i][k] + val[k][j]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
if (ans > 200)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mx = 1e5 + 123;
using namespace std;
int main() {
int n, i, l, r, mn, mx, num = 1;
cin >> n;
cin >> mn >> mx;
for (i = 1; i < n; i++) {
cin >> l >> r;
if (l <= mn && r >= mx) {
num = i + 1;
} else if (l < mn || r > mx) {
num = -1;
}
mn = min(mn, l);
mx = max(mx, r);
}
cout << num;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,ans=0;
cin>>n;
int v[n],c[n];
for(int i=0;i<n;i++)
cin>>v[i];
for(int i=0;i<n;i++)
cin>>c[i];
for(int i=0;i<n;i++)
if(0<v[i]-c[i])
ans+=v[i]-c[i];
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> lucky;
void solver(int len, int num = 0) {
if (len == 0) {
lucky.push_back(num);
return;
}
solver(len - 1, 10 * num + 4);
solver(len - 1, 10 * num + 7);
}
int a[100010];
map<int, int> idx;
int cnt[1024];
const long long mod = 1000000007;
long long modpow(int b, int e) {
if (e == 0) return 1;
if (e & 1) return (modpow(b, e - 1) * b) % mod;
long long m = modpow(b, e >> 1);
return (m * m) % mod;
}
long long f[100010];
long long inv[100010];
long long nCr(int n, int r) {
if (n < r) return 0;
long long num = f[n];
long long den = (inv[r] * inv[n - r]) % mod;
return (num * den) % mod;
}
long long dp[1024][1024];
int main() {
for (int i = 1; i <= 9; i++) {
solver(i);
}
for (unsigned i = 0; i < lucky.size(); i++) {
idx[lucky.at(i)] = i + 1;
}
f[0] = inv[0] = 1;
for (int i = 1; i <= 100000; i++) {
f[i] = f[i - 1] * i;
f[i] %= mod;
inv[i] = modpow(f[i], mod - 2);
}
int n, k, unlucky = 0;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (idx.count(a[i])) {
cnt[idx[a[i]]] += 1;
} else {
++unlucky;
}
}
for (int i = 0; i <= (int)lucky.size(); i++) {
dp[i][0] = 1;
}
for (int i = 1; i <= (int)lucky.size(); i++) {
for (int j = 1; j <= (int)lucky.size(); j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] += dp[i - 1][j - 1] * cnt[i];
dp[i][j] %= mod;
}
}
long long ans = 0;
for (int i = 0; i <= k; i++) {
if (i > (int)lucky.size()) break;
ans += dp[lucky.size()][i] * nCr(unlucky, k - i);
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_M = 100000;
int used[MAX_M];
int main() {
int a, b, m, r0;
scanf("%d%d%d%d", &a, &b, &m, &r0);
memset(used, -1, sizeof(used));
used[r0] = 0;
for (int t = 1, r = r0;; t++) {
r = (a * r + b) % m;
if (used[r] >= 0) {
printf("%d\n", t - used[r]);
break;
}
used[r] = t;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x = INT_MAX;
int d, e;
cin >> n >> d >> e;
e = e * 5;
for (int i = 0; i <= n / d; i++) {
x = min(x, (n - d * i) % e);
if (x == 0) break;
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Num {
double n, d;
Num() {}
Num(double a, double b) {
n = a;
d = b;
}
Num operator+(const Num &x) const { return Num(n * x.d + d * x.n, d * x.d); }
Num operator*(const Num &x) const { return Num(n * x.n, d * x.d); }
bool operator<(const Num &x) const { return n * x.d < d * x.n; }
};
int main() {
double a, b, t, f, s;
int ret = 0;
double x, c, dt, dx;
scanf("%lf %lf %lf %lf %lf", &a, &b, &t, &f, &s);
if (a >= b) {
printf("0");
return 0;
}
x = a * t;
c = s;
while (x < c) {
dt = x / (b - a);
dx = dt * a;
if (x + dx < c) {
ret++;
x = x + dx + a * (dt + f);
} else
break;
}
printf("%d", ret);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long powe(int aa, int b) {
long long ans = 1LL;
long long a = aa * 1LL;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % 1000000007;
a = (a * 1LL * a) % 1000000007;
b = b / 2;
}
return ans;
}
long long min(long long a, long long b) { return a < b ? a : b; }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
int n, m, t, i, j, k, l;
t = 1;
while (t--) {
scanf("%d", &n);
long long a[n + 9];
long long sum = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
sum /= n;
long long ans = 0;
for (i = 0; i < n; i++) {
if (a[i] == sum) continue;
if (a[i] < sum) {
a[i + 1] = a[i + 1] - (sum - a[i]);
ans += sum - a[i];
} else {
a[i + 1] += (a[i] - sum);
ans += a[i] - sum;
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include<iostream>
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono; //----for_getting_execution_time
#define ll long long
#define fi first
#define se second
#define pri pair<ll,ll>
#define M 1000000007
#define pb(x) push_back(x)
#define mpr(x,y) make_pair(x,y)
#define wl(t) int t;cin>>t;while(t--)
#define krish ios::sync_with_stdio(0),cout.tie(0),cin.tie(0)
#define vec vector<ll>
#define inf 3e18
#define ld long double
//sort by second a pair
bool bysec(pri a,pri b) {return (a.se<b.se);}
//sort by second in reverse order
bool bysecriv(pri a,pri b){return (a.se>b.se);}
//sort by first in reverse
bool byrev(pri a , pri b){return (a.fi>a.fi);}
//sort in reverse order
bool rev(int a ,int b){ return (a>b);}
void print(vec a)
{
for(int i=0;i<a.size();i++)
cout<<a[i]<<" ";
cout<<endl;
}
void chal(){cout<<"chal rha hun"<<endl;}
//-------------------------------------------solve here---------------------------------//
//auto stt=high_resolution_clock::now();
int main() {
krish;
wl(t)
{
ll n,k1,k2,w,b;
cin>>n>>k1>>k2>>w>>b;
if((k1+k2)/2>=w&&(n*2-(k1+k2))/2>=b)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
// auto en=high_resolution_clock::now();
// auto diff=duration_cast<microseconds>(en-stt);
// cout<<diff.count()<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void JIZZ(string output = "") {
cout << output;
exit(0);
}
const long double PI = 3.14159265358979323846264338327950288;
const long double eps = 1e-10;
const long long mod = 1e9 + 7;
int nxt[100005][26];
int dp[255][255][255];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
string s;
cin >> s;
for (int i = 0; i < 26; ++i) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i + 1;
}
string str[5];
str[1] = str[2] = str[3] = " ";
int len[5] = {0};
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
while (q--) {
char c;
cin >> c;
if (c == '+') {
int i;
cin >> i >> c;
++len[i];
str[i] += c;
auto update = [&](int i, int j, int k) {
if (i) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i - 1][j][k]][str[1][i] - 'a']);
}
if (j) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j - 1][k]][str[2][j] - 'a']);
}
if (k) {
dp[i][j][k] = min(dp[i][j][k], nxt[dp[i][j][k - 1]][str[3][k] - 'a']);
}
};
if (i == 1) {
for (int i = 0; i <= len[2]; ++i) {
for (int j = 0; j <= len[3]; ++j) {
dp[len[1]][i][j] = 0x3f3f3f3f;
update(len[1], i, j);
}
}
} else if (i == 2) {
for (int i = 0; i <= len[1]; ++i) {
for (int j = 0; j <= len[3]; ++j) {
dp[i][len[2]][j] = 0x3f3f3f3f;
update(i, len[2], j);
}
}
} else {
for (int i = 0; i <= len[1]; ++i) {
for (int j = 0; j <= len[2]; ++j) {
dp[i][j][len[3]] = 0x3f3f3f3f;
update(i, j, len[3]);
}
}
}
} else {
int i;
cin >> i;
--len[i];
str[i].pop_back();
};
;
if (dp[len[1]][len[2]][len[3]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int BIT[5005];
int a[5005];
int n;
void update(int x) {
if (x > n) return;
BIT[x]++;
update(x + (x & -x));
}
int qry(int x) {
if (!x) return 0;
return BIT[x] + qry(x - (x & -x));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0, mx = INT_MIN, f = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (a[i] > a[j]) ans++;
for (int i = 0; i < n; i++) {
memset(BIT, 0, sizeof(BIT));
for (int j = i + 1; j < n; j++) {
int tmp = 0;
if (a[i] > a[j])
tmp++;
else
tmp--;
tmp += (j - i - 1) - 2 * qry(a[j] + 1);
tmp += 2 * qry(a[i] + 1) - (j - i - 1);
if (mx < tmp) {
mx = max(mx, tmp);
f = 1;
} else if (mx == tmp)
f++;
update(a[j] + 1);
}
}
cout << ans - mx << ' ' << f << '\n';
}
| 3 |
#include <bits/stdc++.h>
std::vector<int> G[100033];
bool del[100033];
int legs[100033];
void dfs(int a, int par = 0) {
if (G[a].size() <= 2) {
del[a] = 1;
for (int i = (0), __ = (G[a].size()); i < __; ++i)
if (G[a][i] != par) dfs(G[a][i], a);
}
}
int n;
int a, b;
int cnt;
int main() {
scanf("%d", &n);
for (int i = (0), __ = (n - 1); i < __; ++i) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int a = (1), __ = (n); a <= __; ++a)
if (G[a].size() == 1) dfs(a);
for (int a = (1), __ = (n); a <= __; ++a)
for (int j = (0), __ = (G[a].size()); j < __; ++j)
if (del[G[a][j]]) {
legs[a] = std::min(legs[a] + 1, 2);
}
for (int a = (1), __ = (n); a <= __; ++a)
if (!del[a]) {
cnt = 0;
for (int j = (0), __ = (G[a].size()); j < __; ++j)
if (!del[G[a][j]] && G[G[a][j]].size() - legs[G[a][j]] > 1) {
++cnt;
}
if (cnt > 2) {
puts("No");
return 0;
}
}
puts("Yes");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Q, rM;
long long A[505050];
long long mdm[800][800];
long long i, j, k, l;
int main() {
for (rM = 0; rM * rM <= 500000; rM++)
;
scanf("%lld", &Q);
while (Q--) {
long long T, X, Y;
scanf("%lld%lld%lld", &T, &X, &Y);
if (T == 1) {
A[X] += Y;
for (i = 1; i < rM; i++) {
mdm[i][X % i] += Y;
}
} else {
if (X < rM) {
printf("%lld\n", mdm[X][Y]);
} else {
long long ans = 0;
for (i = Y; i <= 500000; i += X) {
ans += A[i];
}
printf("%lld\n", ans);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int f[150], i, minn;
string s;
int main() {
cin >> s;
for (i = 0; i < s.size(); ++i) f[s[i] - 'a']++;
minn = min((f['n' - 'a'] + f['n' - 'a'] / 2 - 1) / 3, f['e' - 'a'] / 3);
minn = min(minn, min(f['i' - 'a'], f['t' - 'a']));
cout << minn;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long s;
long long fact[20];
long long arr[26];
int nby2;
long long arr1[15], arr2[15];
long long answer = 0;
void init() {
fact[0] = 1;
for (int i = 1; i <= 19; ++i) {
fact[i] = fact[i - 1] * i;
}
}
vector<long long> firsthalf[26];
unordered_map<long long, long long> secondhalf[26];
void solve1(int pos, int kleft, long long val) {
if (kleft < 0) {
return;
}
if (val > s) {
return;
}
if (pos == 0) {
firsthalf[kleft].push_back(val);
return;
}
solve1(pos - 1, kleft, val);
solve1(pos - 1, kleft, val + arr1[pos]);
if (arr1[pos] < 19) {
solve1(pos - 1, kleft - 1, val + fact[arr1[pos]]);
}
}
void solve2(int pos, int kleft, long long val) {
if (kleft < 0) {
return;
}
if (val > s) {
return;
}
if (pos == 0) {
secondhalf[kleft][val]++;
return;
}
solve2(pos - 1, kleft, val);
solve2(pos - 1, kleft, val + arr2[pos]);
if (arr2[pos] < 19) {
solve2(pos - 1, kleft - 1, val + fact[arr2[pos]]);
}
}
int main() {
init();
scanf("%d %d %lld", &n, &k, &s);
for (int i = 1; i <= n; ++i) {
scanf("%lld", arr + i);
}
nby2 = n >> 1;
for (int i = 1; i <= nby2; ++i) {
arr1[i] = arr[i];
}
for (int i = nby2 + 1; i <= n; ++i) {
arr2[i - nby2] = arr[i];
}
solve1(nby2, k, 0LL);
solve2(n - nby2, k, 0LL);
for (int i = 0; i <= k; ++i) {
int sz = firsthalf[i].size();
while (sz--) {
long long cur = firsthalf[i][sz];
for (int l = k - i; l <= k; ++l) {
answer += secondhalf[l][s - cur];
}
}
}
printf("%I64d", answer);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string inttostring(long long int n) {
string ans = "";
while (n) {
long long int digit = n % 10;
n /= 10;
ans += digit - 48;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long int stringtointerger(string a) { return stoi(a); }
long long int countdigit(long long int a) {
long long int ans = 0;
while (a) {
a /= 10;
ans++;
}
return ans;
}
void solve() {
float n;
cin >> n;
float a = 1.0;
float sum = 0;
for (long long int i = n; i >= 1; i--) {
sum += a / i;
}
cout << fixed << setprecision(12) << sum;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m,k,i;
cin>>n>>m;
for(int i=1;i<=m;i++){
cin>>k;
n-=k;
}
if(n<0) cout<<"-1";
else cout<<n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 300010;
int N, a, b, c, d, st, len;
vector<pair<int, int> > E;
vector<int> X;
map<int, int> dx;
struct BIT {
vector<long long> tree, lazy;
void init() {
tree = vector<long long>(4 * MN, 1e18);
lazy = vector<long long>(4 * MN, 0);
}
void prop(int l, int r, int n) {
if (l != r) {
tree[2 * n] += lazy[n];
lazy[2 * n] += lazy[n];
tree[2 * n + 1] += lazy[n];
lazy[2 * n + 1] += lazy[n];
lazy[n] = 0;
}
}
void upd(int a, int b, long long d, int l, int r, int n) {
if (b < l || r < a) return;
if (a <= l && r <= b) {
tree[n] += d;
lazy[n] += d;
return;
}
prop(l, r, n);
int m = (l + r) >> 1;
upd(a, b, d, l, m, 2 * n);
upd(a, b, d, m + 1, r, 2 * n + 1);
tree[n] = min(tree[2 * n], tree[2 * n + 1]);
}
long long quer(int a, int b, int l, int r, int n) {
if (b < l || r < a) return 1e18;
if (a <= l && r <= b) return tree[n];
prop(l, r, n);
int m = (l + r) >> 1;
long long L = quer(a, b, l, m, 2 * n);
long long R = quer(a, b, m + 1, r, 2 * n + 1);
return min(L, R);
}
} bit;
int main() {
scanf("%d %d %d %d %d %d %d", &N, &a, &b, &c, &d, &st, &len);
E.resize(N);
X.push_back(0);
for (int i = 0; i < N; i++) {
scanf("%d %d", &E[i].first, &E[i].second);
X.push_back(E[i].first);
E[i].first = i + 1;
}
for (int i = 0; i < X.size(); i++) dx[X[i]] = i;
bit.init();
bit.upd(0, X.size(), -1e18, 0, MN - 1, 1);
bit.upd(0, MN - 1, st, 0, MN - 1, 1);
for (int i = 0; i < N; i++) {
bit.upd(E[i].first, MN - 1, (E[i].second ? c : -d), 0, MN - 1, 1);
}
long long sum1 = 0, sum2 = 0;
map<int, int>::iterator it = dx.lower_bound(len);
int j = it == dx.end() ? X.size() - 1 : it->second - 1;
if (bit.quer(0, j, 0, MN - 1, 1) >= 0) {
printf("0");
return 0;
}
sum1 += st;
sum2 += st;
for (int i = 1; i < X.size(); i++) {
if (sum1 < 0) {
printf("-1");
return 0;
}
if (sum1 >= 0) {
map<int, int>::iterator it = dx.lower_bound(X[i - 1] + 1 + len);
int j = it == dx.end() ? X.size() - 1 : it->second - 1;
if (sum1 - sum2 + bit.quer(i, j, 0, MN - 1, 1) >= 0) {
printf("%d", X[i - 1] + 1);
return 0;
}
}
sum1 += (E[i - 1].second ? a : -b);
sum2 += (E[i - 1].second ? c : -d);
}
if (sum1 >= 0) {
printf("%d", X.back() + 1);
} else
printf("-1");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long powm(long long a, long long n, long long x = 1000000007) {
long long r = 1;
if (n == 0) return 1;
while (n > 1) {
if (n % 2) r = (r * a) % x;
a = (a * a) % x;
n /= 2;
}
return (a * r) % x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _ = 1;
while (_--) {
string a, b;
cin >> a >> b;
long long j = 0;
for (long long i = 0; i < ((long long)b.size()); i++) {
if (b[i] == a[j]) j++;
}
cout << j + 1;
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 20;
const double eps = 1e-8;
int n, a[N * 3];
vector<int> edg[3 * N];
int main() {
while (cin >> n) {
int st = 0;
map<int, int, greater<int> > q;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
edg[i].clear();
q[a[i]]++;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
edg[x].push_back((y));
edg[y].push_back((x));
}
int ma = 0;
int ans = INF;
for (int i = 1; i <= n; i++) {
q[a[i]]--;
ma = a[i];
for (auto j : edg[i]) {
q[a[j]]--;
ma = max(ma, a[j] + 1);
}
for (auto j : q)
if (j.second > 0) {
ma = max(ma, j.first + 2);
break;
}
for (auto j : edg[i]) q[a[j]]++;
q[a[i]]++;
ans = min(ma, ans);
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005];
int main() {
int n, m, k, x;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
b[i] += x;
b[min(i + n - m + i - 1, n - m + i) + 1] -= x;
}
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += b[i];
printf("%d%c", (a[i] + sum) % k, i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5;
int N, M;
vector<pair<int, int>> V;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int t;
cin >> t;
V.push_back({t, 1});
}
cin >> M;
for (int i = 0; i < M; i++) {
int t;
cin >> t;
V.push_back({t, -1});
}
sort(V.begin(), V.end(), [](pair<int, int>& a, pair<int, int>& b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
});
int best = 0;
int ct = 0;
int x = 0;
int y = 0;
int a = 0;
int b = 0;
for (auto e : V) {
ct += e.second;
(e.second == 1 ? a : b)++;
if (best <= ct) {
best = ct;
x = a;
y = b;
}
}
printf("%d:%d\n", 2 * N + x, 2 * M + y);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
if (n < 6) {
cout << -1 << "\n";
} else {
cout << 1 << " " << 2 << "\n"
<< 1 << " " << 3 << "\n"
<< 1 << " " << 4 << "\n";
for (int i = 5; i <= n; i++) {
cout << 2 << " " << i << "\n";
}
}
for (int i = 2; i <= n; i++) {
cout << 1 << " " << i << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 2005;
using namespace std;
int a, b, n, ans;
int t[maxn];
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
sort(t + 1, t + n + 1);
if (t[b] != t[b + 1]) {
for (int i = t[b]; i < t[b + 1]; i++) ans++;
printf("%d", ans);
} else
printf("0");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
int n, m, a[20][maxn], dis[20][20];
bool dp[70010][20];
vector<int> v[20];
struct mmp {
int x, y;
} p;
vector<mmp> q;
bool check(int d) {
int i, j, k, x, y, z;
for (i = 1; i <= n; i++) {
v[i].clear();
for (j = 1; j <= n; j++)
if (dis[i][j] >= d && i != j) v[i].push_back(j);
}
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << n); j++)
for (k = 1; k <= n; k++) dp[j][k] = false;
q.clear();
p.x = (1 << (i - 1));
p.y = i;
dp[p.x][p.y] = true;
q.push_back(p);
for (j = 0; j < q.size(); j++) {
x = q[j].x;
y = q[j].y;
for (k = 0; k < v[y].size(); k++) {
z = (1 << (v[y][k] - 1));
if ((x & z) == 0 && dp[x | z][v[y][k]] == false) {
p.x = (x | z);
p.y = v[y][k];
dp[p.x][p.y] = true;
q.push_back(p);
}
}
}
for (j = 1; j <= n; j++) {
if (dp[(1 << n) - 1][j] == true) {
for (k = 2; k <= m; k++)
if (abs(a[i][k] - a[j][k - 1]) < d) break;
if (k > m) return true;
}
}
}
return false;
}
int main() {
int i, j, k, l, r, mid;
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i < n; i++) {
for (j = i + 1; j <= n; j++) {
dis[i][j] = dis[j][i] = 1000000000;
for (k = 1; k <= m; k++) {
dis[i][j] = min(dis[i][j], abs(a[i][k] - a[j][k]));
dis[j][i] = min(dis[j][i], abs(a[j][k] - a[i][k]));
}
}
}
l = 0;
r = 1000000000;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid))
l = mid + 1;
else
r = mid - 1;
}
cout << r << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e5+5,mod=1e9+7;
int main() {
int n;
cin>>n;
ll ans=0,sum=0;
vector<int> v;
for (ll i = 0; i < n; ++i)
{
ll x;
cin>>x;
sum+=x;
if(x==0){
ans+=sum/2;
sum=0;
}
}
ans+=sum/2;
cout<<ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int tests() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (a[0] == a[n - 1]) {
cout << n << "\n";
} else {
cout << 1 << "\n";
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int a;
cin >> a;
while (a--) {
tests();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long base = 10000007;
long long large = 1000000000000000000LL;
int main() {
int n, k, m, a;
cin >> n >> k >> m >> a;
vector<int> cnt(n, 0);
vector<int> late(n, -1);
for (int i = 0; i < a; i++) {
int x;
cin >> x;
x--;
cnt[x]++;
late[x] = i;
}
for (int i = 0; i < n; i++) {
vector<pair<pair<int, int>, int> > e;
for (int j = 0; j < n; j++) {
if (i == j) continue;
e.push_back(
pair<pair<int, int>, int>(pair<int, int>(cnt[j], -late[j]), j));
}
if (m > a)
e.push_back(pair<pair<int, int>, int>(
pair<int, int>(cnt[i] + m - a, -(m - 1)), i));
else
e.push_back(
pair<pair<int, int>, int>(pair<int, int>(cnt[i], -late[i]), i));
sort(e.begin(), e.end());
reverse(e.begin(), e.end());
bool find = false;
for (int j = 0; j < k; j++) {
if (e[j].second == i) {
if (e[j].first.first != 0) find = true;
}
}
if (!find) {
cout << 3 << " ";
continue;
}
e.clear();
for (int j = 0; j < n; j++) {
e.push_back(
pair<pair<int, int>, int>(pair<int, int>(cnt[j], -late[j]), j));
}
sort(e.begin(), e.end());
reverse(e.begin(), e.end());
int p = -1;
bool flag = false;
int cnt = 0;
for (int j = 0; j < n && j < k + 1; j++) {
if (flag) {
cnt += p - e[j].first.first;
}
if (j < k && e[j].second == i && e[j].first.first != 0) {
flag = true;
p = e[j].first.first + 1;
}
}
if (cnt > m - a || (k == n && p - 1 > 0)) {
cout << 1 << " ";
continue;
}
if (m - a == 0) {
bool flag = false;
for (int j = 0; j < k; j++) {
if (e[j].second == i && e[j].first.first != 0) {
flag = true;
}
}
if (flag) {
cout << 1 << " ";
continue;
}
}
cout << 2 << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
srand(time(NULL));
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long mod = 1000000007;
long long dp[2222][2222];
long long n, m;
string s;
long long solve(string s) {
long long l = 0, r = 0;
long long res = 0;
for (long long i = 0; i < (long long)(m); i++) {
if (s[i] == '(')
l++;
else
r++;
res = min(res, l - r);
}
if (l > n / 2 || r > n / 2 || n % 2) {
return 0;
}
long long ans = 0;
for (long long i = 0; i <= n - m; i++) {
for (long long jj = 0; jj <= i; jj++) {
long long rr = i - jj;
if (jj < rr) continue;
if (l + jj < r + rr) continue;
if (l + jj > n / 2) continue;
if (r + rr > n / 2) continue;
if (res + jj - rr < 0) continue;
long long lll = n / 2 - l - jj;
long long rrr = n / 2 - r - rr;
long long p = dp[i][jj - rr];
long long q = dp[n - m - i][rrr - lll];
ans += p * q;
ans %= mod;
}
}
return ans;
}
bool check(string x) {
vector<long long> l(x.size());
vector<long long> r(x.size());
for (long long i = 0; i < (long long)(x.size()); i++) {
if (i) {
l[i] = l[i - 1];
r[i] = r[i - 1];
}
if (x[i] == '(')
l[i]++;
else
r[i]++;
if (l[i] < r[i]) return false;
}
return l[x.size() - 1] == r[x.size() - 1];
}
long long brute(string s) {
long long ans = 0;
for (long long i = 0; i <= n - m; i++) {
for (long long j = 0; j < (long long)((1 << i)); j++) {
string p;
for (long long jj = 0; jj < (long long)(i); jj++) {
p += (j & (1 << jj) ? '(' : ')');
}
for (long long k = 0; k < (long long)((1 << (n - m - i))); k++) {
string q;
for (long long kk = 0; kk < (long long)(n - m - i); kk++) {
q += (k & (1 << kk) ? '(' : ')');
}
ans += check(p + s + q);
}
}
}
return ans;
}
int main(void) {
dp[0][0] = 1;
for (long long i = 1; i < 2222; i++) {
dp[i][0] += dp[i - 1][1];
for (long long j = 1; j < 2221; j++) {
dp[i][j] += dp[i - 1][j + 1];
dp[i][j] += dp[i - 1][j - 1];
dp[i][j] %= mod;
}
}
cin >> n >> m >> s;
cout << solve(s) << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using std::cerr;
using std::cin;
using std::cos;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::next_permutation;
using std::pair;
using std::priority_queue;
using std::queue;
using std::random_shuffle;
using std::set;
using std::sin;
using std::sort;
using std::sqrt;
using std::stack;
using std::string;
using std::stringstream;
using std::swap;
using std::vector;
const long double PI = 3.14159265358979323846;
const double eps = 1e-12;
int mod = 1000 * 1000 * 1000 + 7;
vector<vector<long long> > pr(const vector<vector<long long> >& a,
const vector<vector<long long> >& b) {
int m = a.size();
vector<vector<long long> > res(m, vector<long long>(m, 0));
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j)
for (int k = 0; k < m; ++k)
res[i][j] = (res[i][j] + a[i][k] * b[k][j]) % mod;
return res;
}
vector<vector<long long> > pow(vector<vector<long long> > a, long long n) {
int m = a.size();
vector<vector<long long> > res(m, vector<long long>(m, 0));
for (int i = 0; i < m; ++i) res[i][i] = 1;
while (n) {
if (n & 1) res = pr(res, a);
a = pr(a, a);
n >>= 1;
}
return res;
}
int conv(char c) {
int res = c - 'a';
if ((res >= 0) && (res < 26)) return res;
return c - 'A' + 26;
}
int main() {
int m, k;
long long n;
cin >> n >> m >> k;
if (n == 1) {
cout << m << endl;
return 0;
}
vector<int> a(m, 1);
vector<vector<long long> > matr(m, vector<long long>(m, 1));
for (int i = 0; i < k; ++i) {
string s;
cin >> s;
matr[conv(s[0])][conv(s[1])] = 0;
}
vector<vector<long long> > r = pow(matr, n - 1);
long long res = 0;
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) res = (res + r[i][j]) % mod;
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
struct person {
int r, num, k;
person() {}
person(int r, int k, int num) : r(r), k(k), num(num) {}
};
bool operator<(person a, person b) {
if (a.r != b.r) return a.r < b.r;
return a.num < b.num;
}
struct song {
int l, r, num;
song() {}
song(int a, int b, int num) : l(a), r(b), num(num) {}
};
bool operator<(song a, song b) {
if (a.l != b.l) return a.l < b.l;
if (a.r != b.r) return a.r > b.r;
return a.num < b.num;
}
int main() {
int n;
scanf("%d", &n);
song a[n];
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].num = i;
}
sort(a, a + n);
int m;
scanf("%d", &m);
map<int, vector<person>> open;
for (int i = 0; i < m; i++) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
open[l].push_back(person(r, k, i + 1));
}
vector<int> ans(n, -1);
set<person> s;
auto j = open.begin();
for (int i = 0; i < n; i++) {
while (j != open.end()) {
if (j->first > a[i].l) break;
for (person p : j->second) s.insert(p);
j++;
}
auto p = s.lower_bound(person(a[i].r, -1e9, -1e9));
if (p == s.end()) {
printf("NO");
return 0;
}
ans[a[i].num] = p->num;
person tmp = *p;
s.erase(p);
if (p->k == 1) continue;
tmp.k--;
s.insert(tmp);
}
printf("YES\n");
for (int i : ans) printf("%d ", i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = INT_MAX;
const long long MOD = 998244353;
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long g = a;
x = 1;
y = 0;
if (b != 0) g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
long long invMod(long long a, long long m) {
long long x, y;
if (extgcd(a, m, x, y) == 1)
return (x + m) % m;
else
return 0;
}
long long N, M;
bool a[60];
long long w[60];
long long inc, decr;
map<tuple<long long, long long, long long, long long>, long long> mp;
long long dfs(long long i, long long j, long long k, long long in,
long long de) {
if (mp.count(make_tuple(j, k, in, de))) return mp[make_tuple(j, k, in, de)];
if (j == M) {
return k;
}
long long ret = 0;
if (k > 0)
ret = (ret + k * dfs(i, j + 1, k + 2 * a[i] - 1, in, de) % MOD) % MOD;
ret = (ret + in * dfs(i, j + 1, k, in + 1, de) % MOD) % MOD;
if (de > 0) ret = (ret + de * dfs(i, j + 1, k, in, de - 1) % MOD) % MOD;
ret = ret * invMod(k + in + de, MOD) % MOD;
return mp[make_tuple(j, k, in, de)] = ret;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (long long i = 0; i < N; i++) cin >> a[i];
for (long long i = 0; i < N; i++) cin >> w[i];
for (long long i = 0; i < N; i++) {
if (a[i])
inc += w[i];
else
decr += w[i];
}
for (long long i = 0; i < N; i++) {
if (a[i])
inc -= w[i];
else
decr -= w[i];
long long ans = dfs(i, 0, w[i], inc, decr);
cout << ans << endl;
if (a[i])
inc += w[i];
else
decr += w[i];
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[int(1e5)], b[int(1e5)], c, cnt;
map<int, int> cnta, cntb;
map<int, bool> u;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = a[i];
u[a[i]] = 0;
u[b[i]] = 0;
}
sort(b, b + n);
for (int i = 0; i < n; ++i) {
cnta[a[i]]++;
cntb[b[i]]++;
if (cnta[a[i]] != cntb[a[i]] && u[a[i]] == 0) {
c++;
u[a[i]] = 1;
} else if (cnta[a[i]] == cntb[a[i]] && u[a[i]] == 1) {
c--;
u[a[i]] = 0;
}
if (cnta[b[i]] != cntb[b[i]] && u[b[i]] == 0) {
c++;
u[b[i]] = 1;
} else if (cnta[b[i]] == cntb[b[i]] && u[b[i]] == 1) {
c--;
u[b[i]] = 0;
}
if (c == 0) {
cnt++;
}
}
cout << cnt;
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
long long a[n+1], b[n];
for(int i=0; i<n+1; i++)
cin >> a[i];
long long res=0;
for(int i=0; i<n; i++){
cin >> b[i];
if(b[i]>=a[i]){
res+=a[i];
b[i]-=a[i];
if(b[i]>=a[i+1]){
res+=a[i+1];
a[i+1]=0;
}
else{
res+=b[i];
a[i+1]-=b[i];
}
}
else res+=b[i];
}
cout << res;
}
| 0 |
#include<iostream>
#include<set>
#include<vector>
#include<algorithm>
#include<functional>
#include<cassert>
#define MAX 64
#define WMAX 1024
#define CAP_MAX 128
using namespace std;
int water[MAX];
int beaker[MAX];
bool vis[MAX];
bool dfs( int n, int num );
bool pour( int n, int w, int from, int now, int num );
bool pour( int n, int w, int from, int now, int num )
{
if( w == 0 ){
if( dfs( n, num ) ) return true;
return false;
}
if( w < 0 || from >= n || now >= n ) return false;
for(int i = from+1; i < n; ++i){
if( beaker[i] == water[i] ) break;
if( !vis[i] && beaker[i] > w ) return false;
}
int pre = -1;
for(int i = now; i < n; ++i){
if( !vis[i] && beaker[i] <= w ){
if( pre == beaker[i] ) continue;
water[i] += beaker[i];
vis[i] = true;
if( pour( n, w-beaker[i], from, i+1, num+1 ) ) return true;
vis[i] = false;
water[i] -= beaker[i];
pre = beaker[i];
}
}
return false;
}
bool dfs( int n, int num )
{
if( num == n ){
return true;
}
for(int i = 0; i < n; ++i){
if( vis[i] && beaker[i] == water[i] ){
water[i]=0;
if( pour( n, beaker[i], i, i+1, num ) ) return true;
water[i]=beaker[i];
}
}
return false;
}
int main()
{
while(true){
int n;
string res = "NO";
cin >> n;
if( n == 0 ) break;
for(int i = 0; i < MAX; ++i){
beaker[i] = 0;
vis[i] = false;
water[i] = 0;
}
for(int i = 0; i < n; ++i){
cin >> beaker[i];
}
sort(beaker,beaker+n,greater<int>());
water[0]=beaker[0];
vis[0]=true;
if( dfs( n, 1 ) ){
res = "YES";
}
puts(res.c_str());
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long node[100000][2];
long long n, k, m;
cin >> n >> k >> m;
long long all = 0;
for (long long a = 1; a <= n; a++) {
int temp;
cin >> temp;
if (!all || temp != node[all][0]) {
all++;
node[all][0] = temp;
node[all][1] = 1;
} else {
node[all][1]++;
}
if (node[all][1] == k) {
node[all--][1] -= k;
}
}
long long sum = 0;
for (long long a = 1; a <= all; a++) {
sum += node[a][1];
}
long long l = 1, r = all;
while (l < r && node[l][0] == node[r][0]) {
long long temp = (node[l][1] + node[r][1]) % k;
if (temp == 0) {
l++;
r--;
} else {
node[l][1] = temp;
node[r][1] = 0;
break;
}
}
long long ans = 0;
if (l < r) {
long long temp = 0;
for (long long a = l; a <= r; a++) temp += node[a][1];
ans = (m - 1) * temp + sum;
} else if (l == r) {
if ((node[l][1] * m) % k == 0)
ans = 0;
else {
ans = sum + node[l][1] * (m - 1);
ans -= node[l][1] * m - node[l][1] * m % k;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[200005];
void solve() {
string x;
cin >> x;
deque<long long> d;
for (long long i = 0; i < (long long)x.size();) {
long long j = i;
while (j < (long long)x.size() && x[i] == x[j]) j++;
d.push_back(j - i);
i = j;
}
if (x[0] == 'F') d.pop_front();
if (x[x.size() - 1] == 'M') d.pop_back();
if (d.empty()) {
cout << 0 << '\n';
return;
}
long long n = d.size();
vector<long long> v;
for (auto i : d) {
v.push_back(i);
}
long long last = 0, sum = 0, gSum = 0;
for (long long i = 1; i < n; i += 2) {
if (v[i - 1] > last) {
last = v[i] - 1;
} else {
last = last - v[i - 1] + v[i];
}
gSum += v[i];
sum += v[i] + v[i - 1];
}
cout << sum - gSum + last << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
char c[200005];
int main() {
int i;
char t;
t = getchar(), n = 0;
while (t != '\n') c[++n] = t, t = getchar();
for (i = 1; i <= n; i++) c[n + i] = c[i];
int cnt = 1, ans = 1;
for (i = 2; i <= 2 * n; i++) {
if (c[i] != c[i - 1]) {
cnt++;
ans = max(cnt, ans);
ans = min(n, ans);
} else
cnt = 1;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, io, jo, ko;
bool b = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = 0; k < n; k++) {
if (a[k] == a[i] + a[j] && k != i && k != j) {
io = k;
ko = i;
jo = j;
b = 1;
break;
}
}
}
}
if (b)
cout << io + 1 << " " << jo + 1 << " " << ko + 1;
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int i;
double x, v;
} P[500000], Q[500000];
int main() {
int n;
scanf("%d", &n);
int ng = 0, ps = 0;
double maxv = 0.0;
bool ex = false;
for (int i = 0; i < n; ++i) {
scanf("%lf%lf", &P[i].x, &P[i].v);
if (P[i].v > 0)
ps++;
else if (P[i].v < 0)
ng++;
if (P[i].v < 0 && ps > 0) ex = true;
Q[i].i = i;
if (maxv < P[i].v) maxv = P[i].v;
if (maxv < -P[i].v) maxv = -P[i].v;
}
if (!ex) {
printf("-1\n");
return 0;
}
double lo = 0.0, hi = 2e9;
for (int loop = 0; loop < 300; ++loop) {
double mid = (hi + lo) / 2;
double mxx = -1e20;
bool ok = false;
for (int i = 0; i < n && !ok; ++i) {
if (P[i].v > 0) {
if (P[i].x + mid * P[i].v > mxx) mxx = P[i].x + mid * P[i].v;
} else {
if (P[i].x + mid * P[i].v <= mxx) ok = true;
}
}
if (ok)
hi = mid;
else
lo = mid;
}
printf("%.15f\n", lo);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long phi(long long x) {
long long ret = 1;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
ret *= i - 1;
x /= i;
while (x % i == 0) x /= i, ret *= i;
}
}
if (x > 1) ret *= x - 1;
return ret;
}
int main() {
scanf("%I64d%I64d", &n, &k);
if (k % 2 == 0) k--;
while (k != -1 && n != 1) {
n = phi(n);
k -= 2;
}
printf("%I64d\n", n % 1000000007ll);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char x[8][8];
int i, j, w = 0, b = 0;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) {
cin >> x[i][j];
if (x[i][j] == 'q')
b += 9;
else if (x[i][j] == 'r')
b += 5;
else if (x[i][j] == 'n' || x[i][j] == 'b')
b += 3;
else if (x[i][j] == 'p')
b++;
else if (x[i][j] == 'Q')
w += 9;
else if (x[i][j] == 'R')
w += 5;
else if (x[i][j] == 'N' || x[i][j] == 'B')
w += 3;
else if (x[i][j] == 'P')
w++;
}
if (w > b)
cout << "White";
else if (b > w)
cout << "Black";
else
cout << "Draw";
}
| 1 |
// You're not going to master the rest of your life in one day.
// Just relax. Master the day.
// Then just keep doing that every day.
#include<bits/stdc++.h>
using namespace std;
//=========================================================MACROS & CONSTS=========================================================\\
#define int long long
#define ull unsigned long long
#define lld long double
#define endl '\n'
#define pb push_back
#define ff first
#define ss second
#define vi vector<int>
#define pii pair<int,int>
#define sz(x) (int)((x).size())
#define ps(x,y) fixed<<setprecision(y)<<x
#define setbits(x) __builtin_popcountll(x)
#define all(x) (x).begin(), (x).end()
#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define REP(i, st, en) for(__typeof(en) i = (st)-(st>en); i != (en)-(st>en); i += 1-2*(st>en)) // ford: [), back: (]
const double PI = 3.141592653589793238460;
const int mod = 1000000007;
const int INF = (int)1e18;
//=========================================================MACROS & CONSTS=========================================================\\
//=============================================================DEBUGGER=============================================================\\
void _print(int t) {cerr << t;}
void _print(unsigned t) {cerr << t;}
void _print(unsigned long t) {cerr << t;}
void _print(unsigned long long t) {cerr << t;}
void _print(float t) {cerr << t;}
void _print(double t) {cerr << t;}
void _print(long double t) {cerr << t;}
void _print(char t) {cerr << t;}
void _print(const char *t) {cerr << t;}
void _print(const string &t) {cerr << t;}
void _print(bool t) {cerr << (t ? "true" : "false");}
template <class T, class V> void _print(pair <T, V> p);
template <class T> void _print(vector <T> v);
template <class T> void _print(set <T> v);
template <class T, class V> void _print(map <T, V> v);
template <class T> void _print(multiset <T> v);
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.first); cerr << ","; _print(p.second); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x <<" "; _print(x); cerr << endl;
#else
#define debug(x);
#endif
//=============================================================DEBUGGER=============================================================\\
//=========================================================UTILITY FUNCTIONS=========================================================\\
bool comp(const pair<int, int> &a, const pair<int, int> &b){ return (a.first > b.second);}
int expo(int a, int n, int m){ int res = 1; while(n > 0){ if (n & 1) res = (res * a) % m; a = (a * a) % m; n = n >> 1;} return res;}
vector<int> sieve(int n) {int* arr = new int[n + 1](); vector<int> primes; for(int i = 2; i <= n; i++) if (arr[i] == 0){ primes.push_back(i); for(int j = 2 * i; j <= n; j += i) arr[j] = 1;} return primes;}
//=========================================================UTILITY FUNCTIONS=========================================================\\
// Speak Out Loud What You Are Thinking While Solving Problem
// Work Hard And Solve Problems Above Your Level
void solve(){
int n, m;
cin >> n >> m;
int cnt = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
char c;
cin >> c;
if(c == '#')
cnt++;
}
}
cout << expo(2, cnt, mod) - (cnt == m * n) << endl;
}
int32_t main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
fast();
int t = 1;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, I;
cin >> n >> I;
I = I * 8;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
map<int, int> mp;
int distinct = 0, ans = INT_MAX;
int j = 0;
for (int i = 0; i < n; i++) {
mp[arr[i]]++;
if (mp[arr[i]] == 1) distinct++;
while (I < n * ceil(log2(distinct))) {
mp[arr[j]]--;
if (mp[arr[j]] == 0) distinct--;
j++;
}
ans = min(ans, j + n - i - 1);
}
cout << ans << endl;
}
| 1 |
#include<iostream>
using namespace std;
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
int main(){
int am,pm;
char name[15];
rep(i,9){
cin>>name>>am>>pm;
cout<<name<<" "<<am+pm<<" "<<am*200+pm*300<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m, p;
while(cin >> n >> m >> p, n != 0){
vector<int> v;
int sum = 0;
for(int i=0;i<n;++i){
int x;
cin >> x;
v.push_back(x);
sum += x;
}
cout << (v[m-1] ? sum * (100-p) / v[m-1] : 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace p387AGeorgeandSleep {
int read() {
int h, m;
scanf("%d:%d", &h, &m);
return 60 * h + m;
}
void solve(int test_num) {
int s = read();
int t = read();
int res = s - t;
if (res < 0) res += 60 * 24;
printf("%02d:%02d\n", res / 60, res % 60);
}
void solve() { solve(1); }
} // namespace p387AGeorgeandSleep
int main() {
p387AGeorgeandSleep::solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n;
char a[N];
int f[N][N], app[N], ans;
int main() {
scanf("%d", &n);
scanf("%s", a + 1);
ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
f[i][j] = 1;
for (int k = i; k <= j; k++)
if (!(a[k] >= 'a' && a[k] <= 'z')) {
f[i][j] = 0;
break;
}
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
if (f[i][j]) {
memset(app, 0, sizeof app);
int cnt = 0;
for (int k = i; k <= j; k++)
if (!app[a[k]]) app[a[k]] = 1, cnt++;
ans = max(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 100;
int n, m, x, h[N], p[N], sz[N];
vector<int> adj[N], vec[N];
bool vis[N];
void dfs(int root, int par = 0) {
vis[root] = true;
h[root] = h[par] + 1;
p[root] = par;
for (auto u : adj[root])
if (!vis[u])
dfs(u, root);
else if (u ^ par && h[root] - h[u] + 1 >= x) {
cout << 2 << '\n';
cout << h[root] - h[u] + 1 << '\n';
while (h[root] >= h[u]) {
cout << root << ' ';
root = p[root];
}
cout << '\n';
exit(0);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0, v, u; i < m; i++) {
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
x = ceil(sqrt(n));
dfs(1);
int t = x;
cout << 1 << '\n';
for (int i = 1; i <= n; i++)
vec[h[i] % (x - 1)].push_back(i), sz[h[i] % (x - 1)]++;
int ans = 0;
for (int i = 0; i < x - 1; i++)
if (sz[i] > sz[ans]) ans = i;
for (int i = 0; i < x; i++) cout << vec[ans][i] << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double k, b, t;
int n;
cin >> k >> b >> n >> t;
long double m = 1;
while (n > 0 && m <= (t - b) / k) m = m * k + b, n--;
cout << n;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.