solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i = (begin); i < (end); i++)
#define FAST_IO ios_base::sync_with_stdio(0); cin.tie(nullptr); cout.tie(nullptr)
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define SZ(x) ((int)((x).size()))
#define LE(vec) vec[vec.size()-1]
#define TSTS int t; cin >> t; while(t--)solve()
const int INF = 1e9;
const long long LINF = 1e18;
const long double PI = asin(1)/2;
const int MOD = 1e9+7;
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef long long ll;
typedef long double ld;
typedef vector<pii> st;
void setIO()
{
FAST_IO;
}
void setIO (string s) {
setIO();
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
}
bool issqr(int x)
{
int i = 1;
while(i*i<=x)
{
if(i*i == x)
return true;
i++;
}
return false;
}
bool chk(int n)
{
if(n%2 == 0 && issqr(n/2))
{
return true;
}
else if(n%4 == 0 && issqr(n/4))
{
return true;
}
return false;
}
void solve()
{
int n;
cin >> n;
if(chk(n))
{
cout << "YES\n";
}
else
cout << "NO\n";
}
int main()
{
setIO();
TSTS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A[100010], B[100010], C[100010], D[100010];
int main() {
int i, j;
int N, M;
scanf("%d%d%d%d", &N, &M, &i, &j);
for (i = 0; i < N; i++) scanf("%d", &A[i]);
B[0] = -1000000000;
B[M + 1] = 1000000000;
for (i = 0; i < M; i++) scanf("%d", &B[i + 1]);
if (M == 0) {
printf("%d\n", N);
return 0;
}
i = 1;
memset(C, 0, sizeof(C));
for (j = 0; j < N; j++) {
while (B[i + 1] <= A[j]) i++;
if (abs(B[i] - A[j]) < abs(B[i + 1] - A[j])) {
if ((C[i] == 0) || (D[i] > abs(B[i] - A[j]))) {
C[i] = 1;
D[i] = abs(B[i] - A[j]);
} else if ((C[i] == 1) && (D[i] == abs(B[i] - A[j])))
C[i]++;
} else if (abs(B[i] - A[j]) > abs(B[i + 1] - A[j])) {
if ((C[i + 1] == 0) || (D[i + 1] > abs(B[i + 1] - A[j]))) {
C[i + 1] = 1;
D[i + 1] = abs(B[i + 1] - A[j]);
}
} else {
if (C[i] == 0) {
C[i] = 1;
D[i] = abs(B[i] - A[j]);
} else {
if (D[i] == abs(B[i] - A[j]))
C[i]++;
else {
C[i + 1] = 1;
D[i + 1] = abs(B[i + 1] - A[j]);
}
}
}
}
int ans = 0;
for (i = 0; i < M + 1; i++) ans += C[i];
printf("%d\n", N - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string ele;
vector<int> ff(9, 0), ss(9, 0);
for (register int i = 0; i < n; i++) {
cin >> ele;
if (ele == "M")
ff[0]++;
else if (ele == "L")
ff[1]++;
else if (ele == "S")
ff[2]++;
else if (ele == "XS")
ff[3]++;
else if (ele == "XXS")
ff[4]++;
else if (ele == "XXXS")
ff[5]++;
else if (ele == "XL")
ff[6]++;
else if (ele == "XXL")
ff[7]++;
else if (ele == "XXXL")
ff[8]++;
}
for (register int i = 0; i < n; i++) {
cin >> ele;
if (ele == "M")
ss[0]++;
else if (ele == "L")
ss[1]++;
else if (ele == "S")
ss[2]++;
else if (ele == "XS")
ss[3]++;
else if (ele == "XXS")
ss[4]++;
else if (ele == "XXXS")
ss[5]++;
else if (ele == "XL")
ss[6]++;
else if (ele == "XXL")
ss[7]++;
else if (ele == "XXXL")
ss[8]++;
}
int ans{0};
for (register int i = 0; i < 9; i++) {
ans += abs(ff[i] - ss[i]);
}
cout << ans / 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int dp[m + 3][n + 3];
int ar[m + 3][n + 3];
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) cin >> ar[i][j];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + ar[i][j];
}
}
for (int i = 1; i <= m; i++) cout << dp[i][n] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (a[i].first != 1) break;
++cnt;
}
if (cnt == 0) {
cout << "YES " << n - 1 << endl;
cout << n - 1 << endl;
for (int i = 0; i < n - 1; ++i) cout << i + 1 << " " << i + 2 << endl;
} else if (cnt > 0 && cnt < 3) {
cout << "YES " << n - 1 << endl;
cout << n - 1 << endl;
swap(a[1], a[n - 1]);
for (int i = 0; i < n - 1; ++i)
cout << a[i].second << ' ' << a[i + 1].second << endl;
} else {
if (a[n - 2] > a[cnt]) swap(a[n - 2], a[cnt]);
for (int i = cnt; i < n - 1; ++i) {
a[i].first--;
a[i + 1].first--;
}
int space = 0;
for (int i = cnt; i < n; ++i) {
space += a[i].first;
}
if (space < cnt)
cout << "NO" << endl;
else {
cout << "YES " << n - cnt + 1 << "\n";
cout << n - 1 << endl;
for (int i = cnt; i < n - 1; ++i) {
cout << a[i].second << ' ' << a[i + 1].second << endl;
}
cout << (a[n - 1].second) << " " << a[0].second << endl;
a[n - 1].first--;
cout << (a[cnt].second) << " " << a[1].second << endl;
a[cnt].first--;
for (int i = 2, j = cnt; i < cnt; ++i) {
while (a[j].first && i < cnt) {
cout << a[i++].second << " " << a[j].second << endl;
a[j].first--;
}
i--;
++j;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> mynumber(n);
for (int i = 0; i < n; i++) {
cin >> mynumber[i];
}
int total = mynumber[0];
string ans = "YES";
int totalVal = accumulate(mynumber.begin(), mynumber.end(), 0);
if (totalVal == 0) {
cout << "NO" << endl;
} else if (totalVal < 0) {
cout << "YES" << endl;
sort(mynumber.begin(), mynumber.end());
for (int i = 0; i < n; i++) {
cout << mynumber[i];
if (i != n - 1) cout << " ";
}
cout << endl;
} else {
cout << "YES" << endl;
sort(mynumber.begin(), mynumber.end(), greater<int>());
for (int i = 0; i < n; i++) {
cout << mynumber[i];
if (i != n - 1) cout << " ";
}
cout << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 1e6 + 6, OO = 0x3f3f3f3f;
int tc;
long long arr[N];
int n, k, w[N];
long long mx[N], mn[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tc;
while (tc--) {
priority_queue<long long> pq;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
pq.push(arr[i]);
}
for (int i = 0; i < k; i++) {
cin >> w[i];
}
sort(w, w + k);
sort(arr, arr + n, greater<long long>());
int idx = 0;
for (int i = 0; i < k; i++) {
mx[i] = arr[idx];
mn[i] = arr[idx++];
w[i]--;
}
long long ans = 0;
for (int i = 0; i < k; i++) {
if (!w[i]) {
ans += mx[i] + mn[i];
continue;
} else {
idx += w[i] - 1;
mn[i] = arr[idx];
idx++;
}
ans += mx[i] + mn[i];
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int A[2000];
int B[2000];
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < k; i++) cin >> B[i];
vector<int> V;
int Sum[2000];
Sum[0] = A[0];
for (int i = 1; i < n; i++) Sum[i] = Sum[i - 1] + A[i];
for (int i = 0; i < n; i++) V.push_back(B[0] - Sum[i]);
set<int> S;
for (int i = 0; i < k; i++) S.insert(B[i]);
int ansv = 0;
sort(V.begin(), V.end());
for (int i = 0; i < V.size(); i++) {
if (i > 0)
if (V[i] == V[i - 1]) continue;
int amount = 0;
set<int> K;
for (int j = 0; j < n; j++)
if (S.count(V[i] + Sum[j]) != 0 && K.count(V[i] + Sum[j]) == 0) {
amount++;
K.insert(V[i] + Sum[j]);
}
if (amount >= k) ansv++;
}
cout << ansv;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const double PI = 3.14159265358979323846;
const long long maxn = (long long)2701;
const long long mod = (long long)1e9 + 7;
const long long inf = (long long)1e9 + 7;
const double eps = 1e-15;
string pat = "", s[maxn];
int a[maxn], was[maxn], x, n, m;
void get(string ts) {
if (pat == "") {
pat = ts;
return;
}
if (pat.length() != ts.length()) {
cout << "No";
exit(0);
}
for (int i = 0; i < pat.length(); i++) {
if (pat[i] != ts[i]) {
pat[i] = '?';
}
}
}
bool eq(string ts) {
if (ts.length() != pat.length()) {
return false;
}
for (int i = 0; i < ts.length(); i++) {
if (pat[i] != ts[i] && pat[i] != '?') {
return false;
}
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < m; i++) {
cin >> x;
x--;
was[x] = 1;
get(s[x]);
}
for (int i = 0; i < n; i++) {
if (!was[i] && eq(s[i])) {
cout << "No";
return 0;
}
}
cout << "Yes\n" << pat;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1E9;
int grid[309][309];
int DP[309][309][609];
int d1[5] = {1, 0, 1, 0};
int d2[5] = {0, 1, 1, 0};
int rc;
int maxNum(int pos, int pos1, int pos2) {
if (pos1 == rc && pos2 == rc && (pos - pos1) == rc) {
return grid[rc][rc];
}
if (pos1 > rc || pos2 > rc) {
return -INF;
}
if ((pos - pos1) > rc || (pos - pos2) > rc) {
return -INF;
}
int &save = DP[pos1][pos2][pos];
if (save != -1) {
return save;
}
save = -INF;
int point;
if (pos1 == pos2) {
point = grid[pos1][(pos - pos1)];
} else {
point = grid[pos1][(pos - pos1)] + grid[pos2][(pos - pos2)];
}
for (int i = 0; i < 4; i++) {
save = max(save, maxNum(pos + 1, pos1 + d1[i], pos2 + d2[i]) + point);
}
return save;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> rc;
memset(DP, -1, sizeof(DP));
for (int i = 1; i <= rc; i++) {
for (int j = 1; j <= rc; j++) {
cin >> grid[i][j];
}
}
cout << maxNum(2, 1, 1) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
char s[N];
vector<int> ret;
void check(const vector<int>& a, int pos) {
if (a[pos] == 0) return;
vector<int> cur;
int carry = 0, n = a.size();
for (int i = pos - 1, j = n - 1;; --i, --j) {
int sum = carry;
if (i >= 0) sum += a[i];
if (j >= pos) sum += a[j];
cur.push_back(sum % 10);
carry = sum / 10;
if (!carry && i < 0 && j < pos) break;
}
while (cur.size() && cur.back() == 0) cur.pop_back();
reverse(cur.begin(), cur.end());
if (!ret.size()) {
ret = cur;
} else {
if (ret.size() > cur.size() || (ret.size() == cur.size() && ret > cur)) {
ret = cur;
}
}
}
int main() {
int n;
scanf("%d%s", &n, s);
vector<int> a(n);
for (int i = 0; i < n; ++i) a[i] = s[i] - '0';
int L = max(1, n / 2 - 10), R = min(n - 1, n / 2 + 10);
for (int k = L; k <= R; ++k) {
check(a, k);
}
if (!ret.size()) {
for (--L; L > 0 && a[L] == 0; --L)
;
check(a, L);
for (++R; R < n && a[R] == 0; ++R)
;
check(a, R);
}
for (auto& it : ret) printf("%d", it);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[8][8];
int w = 0, b = 0;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
cin >> a[i][j];
switch (a[i][j]) {
case 'Q':
w += 9;
break;
case 'R':
w += 5;
break;
case 'B':
w += 3;
break;
case 'N':
w += 3;
break;
case 'P':
w += 1;
break;
case 'q':
b += 9;
break;
case 'r':
b += 5;
break;
case 'b':
b += 3;
break;
case 'n':
b += 3;
break;
case 'p':
b += 1;
break;
}
}
if (w > b)
cout << "White";
else if (w == b)
cout << "Draw";
else
cout << "Black";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
const long long inf = 1e18;
long long rd() {
long long x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int fa[N], ch[N][2], rt, tt, st[N], tp;
long long vx[N], vy[N], lx[N], rx[N], m0[N], m1[N], tgx[N], tgy[N];
void psup(int x) {
lx[x] = min(vx[x], lx[ch[x][0]]), rx[x] = max(vx[x], rx[ch[x][1]]);
m0[x] = max(vy[x], max(m0[ch[x][0]], m0[ch[x][1]]));
m1[x] = max(vy[x] - vx[x], max(m1[ch[x][0]], m1[ch[x][1]]));
}
void add(int x, long long dx, long long dy) {
if (!x) return;
vx[x] += dx, vy[x] += dy;
lx[x] += dx, rx[x] += dx;
m0[x] += dy, m1[x] += dy - dx;
tgx[x] += dx, tgy[x] += dy;
}
void psdn(int x) {
if (tgx[x] || tgy[x])
add(ch[x][0], tgx[x], tgy[x]), add(ch[x][1], tgx[x], tgy[x]);
tgx[x] = tgy[x] = 0;
}
void rot(int x) {
int y = fa[x], z = fa[y], yy = ch[y][1] == x, w = ch[x][!yy];
if (y != rt) ch[z][ch[z][1] == y] = x;
ch[x][!yy] = y, ch[y][yy] = w;
if (w) fa[w] = y;
fa[y] = x, fa[x] = z;
psup(y), psup(x);
}
void spl(int x, int en) {
int xx = x;
tp = 0;
while (xx) st[++tp] = xx, xx = fa[xx];
while (tp) xx = st[tp--], psdn(xx);
while (fa[x] != en) {
int y = fa[x], z = fa[y];
if (fa[y] != en) ((ch[y][1] == x) ^ (ch[z][1] == y)) ? rot(x) : rot(y);
rot(x);
}
if (!en) rt = x;
}
void inst(long long px) {
long long ly = -inf, ry = -inf;
int x = rt;
while (1) {
psdn(x);
if (vx[x] == px) {
ly = max(ly, m0[ch[x][0]]);
ry = max(ry, m1[ch[x][1]]);
vy[x] = max(vy[x], max(ly, ry + px));
psup(x);
break;
}
bool xx = px > vx[x];
if (xx)
ly = max(ly, max(m0[ch[x][0]], vy[x]));
else
ry = max(ry, max(m1[ch[x][1]], vy[x] - vx[x]));
if (!ch[x][xx]) {
int nx = ++tt;
fa[nx] = x, ch[x][xx] = nx;
vx[nx] = px, vy[nx] = max(ly, ry + px);
psup(nx), x = nx;
break;
}
x = ch[x][xx];
}
spl(x, 0);
}
void modif(int x, long long ll, long long rr, long long dy) {
if (!x || rx[x] < ll || lx[x] > rr) return;
if (ll <= lx[x] && rx[x] <= rr) {
add(x, 0, dy);
return;
}
if (ll <= vx[x] && vx[x] <= rr) vy[x] += dy;
psdn(x);
modif(ch[x][0], ll, rr, dy), modif(ch[x][1], ll, rr, dy);
psup(x);
}
struct node {
long long x, i;
bool operator<(const node &bb) const { return x < bb.x; }
} s1[N], s2[N];
int n, m, t1, t2, c[2];
long long k, bk[N << 1], tb;
int main() {
for (int i = 0; i <= N - 5; ++i)
lx[i] = inf + inf, rx[i] = m0[i] = m1[i] = -inf - inf;
rt = tt = 1, psup(1);
n = rd(), m = rd(), k = rd();
for (int i = 1; i <= n; ++i) {
s1[++t1] = (node){rd(), 0}, s2[++t2] = (node){rd(), 0};
bk[++tb] = s1[t1].x, bk[++tb] = s2[t2].x;
}
for (int i = 1; i <= m; ++i) {
s1[++t1] = (node){rd(), 1}, s2[++t2] = (node){rd(), 1};
bk[++tb] = s1[t1].x, bk[++tb] = s2[t2].x;
}
sort(s1 + 1, s1 + t1 + 1), sort(s2 + 1, s2 + t2 + 1);
sort(bk + 1, bk + tb + 1), tb = unique(bk + 1, bk + tb + 1) - bk - 1;
for (int h = 1, i = 1, j = 1; h < tb; ++h) {
while (i <= t1 && s1[i].x == bk[h]) ++c[s1[i].i], ++i;
while (j <= t2 && s2[j].x == bk[h]) --c[s2[j].i], ++j;
long long ln = bk[h + 1] - bk[h];
int ty = 1 * (bool)c[0] + 2 * (bool)c[1];
if (!ty) continue;
if (ty == 1)
add(rt, ln, ln);
else if (ty == 2)
add(rt, -ln, 0);
else {
inst(-k), inst(k);
modif(rt, -inf * 3, -k - 1, ln);
modif(rt, -k, k, ln * 2);
modif(rt, k + 1, inf * 3, ln);
}
}
printf("%lld\n", m0[rt]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long cl(long double a) {
if (a > (long long)a) {
return (long long)a + 1;
} else {
return (long long)a;
}
}
long long flr(long double a) {
if (a < 0.0) {
return (long long)a - 1;
}
return (long long)a;
}
long long n, k;
long long l1, r1, l2, r2;
void solve() {
cin >> n;
cin >> k;
cin >> l1;
cin >> r1;
cin >> l2;
cin >> r2;
long long ans = 0;
long long mv = 0;
long long tot = 0;
long long cur = 0;
if (l2 > r1 || l1 > r2) {
if (l1 > r2) {
swap(l1, l2);
swap(r1, r2);
}
mv = l2 - r1;
r1 = l2;
} else {
long long op = min(r2 - l2, min(r1 - l1, min(r1 - l2, r2 - l1)));
tot += n * op;
cur = op;
}
ans += mv;
if (tot < k) {
long long d = min(k - tot, (max(r2, r1) - min(l1, l2)) - cur);
long long inc = (max(r2, r1) - min(l1, l2)) - cur;
ans += d;
tot += d;
bool f = false;
if (n == 1) f = true;
if (tot < k) {
for (long long i = 2; i <= n; i++) {
if (tot + inc <= k && 2 * inc > mv + inc) {
tot += inc;
ans += mv + inc;
if (i == n) f = true;
} else {
break;
}
}
if (tot < k) {
if (f || (2 * (k - tot) <= mv + (k - tot)) || inc < (k - tot)) {
ans += 2 * (k - tot);
tot = k;
} else {
ans += mv + (k - tot);
tot = k;
}
}
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
Solution(int _n) : N(_n) {}
void guess(long long n, int k) {
long long l = 1;
long long r = n;
int M = min(4LL * k, n);
mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
string ans;
for (int i = 0; i < N; ++i) {
if (r - l + 1 <= M) {
uniform_int_distribution<long long> dist(l, r);
long long p = dist(gen);
cout << p << " " << p << endl;
fflush(stdout);
cin >> ans;
if (ans[0] == 'y' || ans[0] == 'Y') {
return;
}
} else {
long long m = l + (r - l) / 2;
cout << l << " " << m << endl;
fflush(stdout);
cin >> ans;
if (ans[0] == 'y' || ans[0] == 'Y') {
r = m;
} else {
l = m + 1;
}
}
l = max(1LL, l - k);
r = min(n, r + k);
}
}
private:
int N;
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
int k;
long long p;
cin >> n >> k;
Solution sol(4500);
sol.guess(n, k);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, b;
string a, c;
int main() {
cin >> n;
int l = -2e9, r = 2e9;
for (; n--;) {
cin >> a >> b >> c;
if (a == ">" && c == "Y" || a == "<=" && c == "N")
l = max(l, b + 1);
else if (a == ">=" && c == "Y" || a == "<" && c == "N")
l = max(l, b);
else if (a == "<" && c == "Y" || a == ">=" && c == "N")
r = min(r, b - 1);
else
r = min(r, b);
}
if (l > r)
puts("Impossible");
else
printf("%d", l);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sumDigits(int n) {
int s = 0, r;
while (n > 0) {
r = n % 10;
s = s + r;
n = n / 10;
}
return s;
}
int main() {
int n, s, r;
cin >> n;
s = sumDigits(n);
while (s % 4 != 0) {
n = n + 1;
s = sumDigits(n);
}
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[1000005];
scanf("%s", str);
int n = strlen(str);
int ans = 0;
while (str[--n] == '0') ans++;
if (n == 0) {
cout << ans << endl;
return 0;
}
ans++;
for (; n >= 0; n--) {
if (str[n] == '0') {
ans++;
}
ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
int a, b, c, d;
cin >> a >> b >> c >> d;
int m = max(3 * a / 10, a - a / 250 * c),
v = max(3 * b / 10, b - b / 250 * d);
if (m > v)
cout << "Misha" << endl;
else if (v > m)
cout << "Vasya" << endl;
else
cout << "Tie" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> segs;
int a[110], b[110], pos[110];
int main() {
int n, s1, s2;
cin >> n >> s1 >> s2;
int m;
cin >> m;
segs[-s1] = -s1;
segs[n + s2] = n + s2;
for (int i = 0, _i = (m); i < _i; ++i) {
int a, b;
cin >> a >> b;
if (a == 1) {
pos[i] = -1;
for (__typeof((segs).begin()) j = (segs).begin(), _j = (segs).end();
j != _j; ++j) {
pair<int, int> cur = *j;
map<int, int>::iterator it = j;
++it;
if (it == segs.end()) break;
pair<int, int> nxt = *it;
if (cur.second + b + s1 + s2 <= nxt.first) {
pos[i] = cur.second + s1;
segs[pos[i]] = pos[i] + b;
break;
}
}
cout << pos[i] << '\n';
} else {
b--;
segs.erase(pos[b]);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((2 * b == a + c) && (2 * c == b + d)) {
cout << d + b - a;
} else if ((b * b == a * c) && (c * c == b * d)) {
float r = (float)b / (float)a;
float e = r * d;
if (e == (int)e) {
cout << (int)e << endl;
} else {
cout << 42 << endl;
}
} else {
cout << 42 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int w[1005], b[1005], vis[1005], k[1005], dp[1005][1005];
vector<int> g[1005];
vector<int> a[1005];
void dfs(int x, int in) {
vis[x] = 1;
k[x] = in;
a[in].push_back(x);
for (auto it : g[x]) {
if (!vis[it]) dfs(it, in);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, wt, x, y;
cin >> n >> m >> wt;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
memset(vis, 0, sizeof vis);
memset(k, 0, sizeof k);
int in = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, in);
in++;
}
}
memset(dp, 0, sizeof dp);
for (int i = 1; i <= in; i++) {
for (int j = 1; j <= wt; j++) {
x = i - 1;
int s = 0, ss = 0;
dp[i][j] = dp[i - 1][j];
for (auto it : a[x]) {
s += w[it];
ss += b[it];
if (w[it] <= j) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[it]] + b[it]);
}
}
if (s <= j) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - s] + ss);
}
}
}
int ans = 0;
for (int i = 0; i <= wt; i++) {
ans = max(ans, dp[in][i]);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[222222], tot[222222];
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
std::cin.tie(0);
long long n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
tot[i] = tot[i - 1] + a[i - 1];
}
long long k, cur = 0;
for (int i = 0; i < q; i++) {
cin >> k;
cur += k;
long long die = lower_bound(tot, tot + n + 1, cur) - tot;
if (tot[die] > cur && die) die--;
if (cur >= tot[n]) {
cout << n << endl;
cur = 0;
} else {
cout << n - die << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int u;
int v;
} edge[1000010];
int nn;
void deal(int p, int k) {
for (int i = 1; i < k; i++) {
edge[nn].u = p;
edge[nn++].v = p + i;
}
int temp;
temp = (k - 3) / 2;
for (int i = 1; i < k; i++) {
for (int j = 0; j < temp; j++) {
edge[nn].u = p + i;
edge[nn++].v = p + (i + j) % (k - 1) + 1;
}
}
for (int i = 1; i < k; i++) {
edge[nn].u = p + k;
edge[nn++].v = p + i;
edge[nn].u = p + k + 1;
edge[nn++].v = p + i;
}
edge[nn].u = p + k;
edge[nn++].v = p + k + 1;
}
int main() {
int k, x;
cin >> k;
if (k % 2 == 0) {
cout << "NO" << endl;
} else if (k == 1) {
cout << "YES" << endl;
cout << "2 1" << endl;
cout << "1 2" << endl;
} else {
cout << "YES" << endl;
x = 2 * (k + 2);
deal(1, k);
deal(x / 2 + 1, k);
edge[nn].u = 1;
edge[nn++].v = x / 2 + 1;
cout << x << " " << nn << endl;
for (int i = 0; i < nn; i++) {
printf("%d %d\n", edge[i].u, edge[i].v);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500000, INF = (1 << 30) - 1;
int n, a[N + 9], cnt;
void into(int cas) {
scanf("%d", &n);
cnt = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
cnt += !a[i];
}
}
struct tree {
int min, add;
} tr[N * 4 + 9];
void Pushup(int k) { tr[k].min = min(tr[k << 1].min, tr[k << 1 | 1].min); }
void Update_add(int k, int v) {
tr[k].min += v;
tr[k].add += v;
}
void Pushdown(int k) {
if (!tr[k].add) return;
Update_add(k << 1, tr[k].add);
Update_add(k << 1 | 1, tr[k].add);
tr[k].add = 0;
}
void Build(int l, int r, int k) {
tr[k].min = tr[k].add = 0;
if (l == r) return;
int mid = l + r >> 1;
Build(l, mid, k << 1);
Build(mid + 1, r, k << 1 | 1);
}
void Change(int p, int v, int l, int r, int k) {
if (l == r) {
tr[k].min = v;
return;
}
int mid = l + r >> 1;
Pushdown(k);
p <= mid ? Change(p, v, l, mid, k << 1)
: Change(p, v, mid + 1, r, k << 1 | 1);
Pushup(k);
}
void Change_add(int L, int R, int v, int l, int r, int k) {
if (L <= l && R >= r) {
Update_add(k, v);
return;
}
int mid = l + r >> 1;
Pushdown(k);
if (L <= mid) Change_add(L, R, v, l, mid, k << 1);
if (R > mid) Change_add(L, R, v, mid + 1, r, k << 1 | 1);
Pushup(k);
}
int Query_min(int L, int R, int l, int r, int k) {
if (L <= l && R >= r) return tr[k].min;
int mid = l + r >> 1, res = INF;
Pushdown(k);
if (L <= mid) res = min(res, Query_min(L, R, l, mid, k << 1));
if (R > mid) res = min(res, Query_min(L, R, mid + 1, r, k << 1 | 1));
return res;
}
int mp[N + 9], mx[N + 9], ans;
void Get_ans() {
Build(1, n, 1);
for (int i = 1; i <= n; ++i) mp[i] = 0;
for (int i = 1, c = 0, j = 0; i <= n; ++i) {
if (a[i]) {
int last = mp[a[i]];
if (last) {
--j;
Change_add(last, i - 1, 1, 1, n, 1);
Change(last, INF, 1, n, 1);
}
Change(i, c - ++j, 1, n, 1);
if (Query_min(1, i, 1, n, 1) < 0) Change_add(1, i, 1, 1, n, 1), --j;
for (; Query_min(1, i, 1, n, 1) > 0; ++j) Change_add(1, i, -1, 1, n, 1);
mp[a[i]] = i;
} else
++c;
mx[i] = j;
}
Build(1, n, 1);
for (int i = 1; i <= n; ++i) mp[i] = 0;
ans = min(cnt >> 1, mx[n]);
for (int i = n, c = 0, j = 0; i >= 1; --i) {
if (a[i]) {
int last = mp[a[i]];
if (last) {
--j;
Change_add(i + 1, last, 1, 1, n, 1);
Change(last, INF, 1, n, 1);
}
Change(i, c - ++j, 1, n, 1);
if (Query_min(i, n, 1, n, 1) < 0) Change_add(i, n, 1, 1, n, 1), --j;
for (; Query_min(i, n, 1, n, 1) > 0; ++j) Change_add(i, n, -1, 1, n, 1);
mp[a[i]] = i;
} else
++c;
ans = min(ans, mx[i - 1] + j);
}
}
void work() { Get_ans(); }
void outo() { printf("%d\n", ans); }
int main() {
int T;
scanf("%d", &T);
for (int i = 1; T--; ++i) {
into(i);
work();
outo();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double pi = 3.1415926535897932384626433832795;
const double eln = 2.718281828459045235360287471352;
const int mod = 2146959361;
const int root = 19;
const int maxn = 1048576;
inline int mul(int a, int b, int mod) { return (long long)a * b % mod; }
int power(int a, int b, int mod) {
int ret = 1;
for (int t = a; b; b >>= 1) {
if (b & 1) ret = mul(ret, t, mod);
t = mul(t, t, mod);
}
return ret;
}
int cal_root(int mod) {
int factor[20], num = 0, m = mod - 1, s = m;
for (int i = 2; i * i <= s; i++) {
if (s % i == 0) {
factor[num++] = i;
while (s % i == 0) s /= i;
}
}
if (s != 1) factor[num++] = s;
for (int i = 2;; i++) {
int j = 0;
for (; j < num && power(i, m / factor[j], mod) != 1; j++)
;
if (j == num) return i;
}
}
template <int MOD, int ROOT>
void fft_main(int a[], int len, bool reverse) {
for (int i = 1, j = len / 2; i < len - 1; i++) {
if (i < j) swap(a[i], a[j]);
for (int k = len; j < k; k >>= 1, j ^= k)
;
}
for (int i = 1, s = 1; s < len; i++, s <<= 1) {
int t = (MOD - 1) / (s * 2);
int step = power(ROOT, reverse ? MOD - 1 - t : t, MOD);
for (int j = 0; j < len; j += 2 * s) {
int cur = 1;
for (int k = j; k < j + s; k++) {
int u = a[k], t = mul(cur, a[k + s], MOD);
a[k] = (unsigned int)(u + t) % MOD;
a[k + s] = (unsigned int)(u - t + MOD) % MOD;
cur = mul(cur, step, MOD);
}
}
}
if (reverse) {
int t = power(len, MOD - 2, MOD);
for (int i = 0; i < len; i++) a[i] = mul(a[i], t, MOD);
}
}
template <int MOD, int ROOT>
void fft(int a[], int b[], int n) {
int len = 1;
while (len < 2 * n) len <<= 1;
memset(a + n, 0, sizeof(int) * (len - n));
memset(b + n, 0, sizeof(int) * (len - n));
fft_main<MOD, ROOT>(a, len, 0);
fft_main<MOD, ROOT>(b, len, 0);
for (int i = 0; i < len; i++) a[i] = mul(a[i], b[i], MOD);
fft_main<MOD, ROOT>(a, len, 1);
}
template <int MOD, int ROOT>
void fft(int a[], int n) {
int len = 1;
while (len < 2 * n) len <<= 1;
memset(a + n, 0, sizeof(int) * (len - n));
fft_main<MOD, ROOT>(a, len, 0);
for (int i = 0; i < len; i++) a[i] = mul(a[i], a[i], MOD);
fft_main<MOD, ROOT>(a, len, 1);
}
char s[maxn], t[maxn];
int a[maxn], b[maxn], ans[maxn];
int n, m, k;
int pre[maxn];
void solve(char c) {
for (int i = 0; i < 1048576; i++) a[i] = b[i] = pre[i] = 0;
for (int i = 0; i < n; i++)
if (s[i] == c) {
pre[max(i - k, 0)]++;
pre[min(i + k + 1, n)]--;
}
for (int i = 0; i < n; i++) {
if (i > 0) pre[i] += pre[i - 1];
if (pre[i] > 0) a[i] = 1;
}
for (int i = m - 1; i >= 0; i--)
if (t[i] == c) b[m - 1 - i] = 1;
fft<mod, root>(a, b, n);
for (int i = 0; i < 1048576; i++) ans[i] += a[i];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%s", s);
scanf("%s", t);
solve('A');
solve('T');
solve('G');
solve('C');
int da = 0;
for (int i = 0; i < 2 * n; i++)
if (ans[i] >= m) da++;
printf("%d\n", da);
return 0;
}
| 8 |
#include <bits/stdc++.h>
constexpr int maxn = 500000;
std::vector<int> neighbors[maxn + 1];
int layer[maxn + 1];
int xlayer[maxn / 2];
bool dfs(int pos, int currLayer, int target) {
if (layer[pos]) return false;
layer[pos] = currLayer;
if (currLayer >= target) {
std::cout << "PATH\n" << target << '\n' << pos;
return true;
}
for (int npos : neighbors[pos])
if (dfs(npos, currLayer + 1, target)) {
std::cout << ' ' << pos;
return true;
}
return false;
}
int main() {
using namespace std;
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int tar = (n + 1) >> 1;
for (int i = 1; i <= n; ++i) {
neighbors[i].clear();
layer[i] = 0;
}
for (int i = 1; i < tar; ++i) xlayer[i] = 0;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
neighbors[u].push_back(v);
neighbors[v].push_back(u);
}
if (dfs(1, 1, tar))
cout << '\n';
else {
tar = (tar + 1) >> 1;
cout << "PAIRING\n" << tar << '\n';
int pairs = 0;
for (int i = 1; pairs < tar; ++i) {
int lay = layer[i];
if (xlayer[lay]) {
cout << i << ' ' << xlayer[lay] << '\n';
xlayer[lay] = 0;
++pairs;
} else
xlayer[lay] = i;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
reverse(s.begin(), s.begin() + i);
}
}
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int32_t Accepted = 0;
template <typename T>
void in(T& x) {
static char ch;
static bool neg;
for (ch = neg = 0; ch < '0' || '9' < ch; neg |= ch == '-', ch = getchar())
;
for (x = 0; '0' <= ch && ch <= '9'; (x *= 10) += ch - '0', ch = getchar())
;
x = neg ? -x : x;
}
template <typename T, typename... Types>
void in(T& x, Types&... oth) {
static char ch;
static bool neg;
for (ch = neg = 0; ch < '0' || '9' < ch; neg |= ch == '-', ch = getchar())
;
for (x = 0; '0' <= ch && ch <= '9'; (x *= 10) += ch - '0', ch = getchar())
;
x = neg ? -x : x;
in(oth...);
}
template <typename T>
T _pow_mod(T a, T b, T mod) {
T base = a, res = 1;
while (b) {
if (b & 1) res = (res * base) % mod;
base = (base * base) % mod;
b >>= 1;
}
return res;
}
template <typename T>
T _pow(T a, T b) {
T base = a, res = 1;
while (b) {
if (b & 1) res = (res * base);
base = (base * base);
b >>= 1;
}
return res;
}
template <typename T>
void out(T x) {
char s[65];
int32_t cnt = 0;
if (x > 0)
while (x > 0) s[cnt++] = (x - (x / 10 * 10)) + '0', x /= 10;
else if (x < 0) {
while (x < 0) s[cnt++] = (x / 10 * 10) - x + '0', x /= 10;
s[cnt++] = '-';
}
if (cnt == 0)
putchar('0');
else
for (int32_t i = cnt - 1; ~i; i--) putchar(s[i]);
}
template <typename T>
void print(T x) {
out(x);
putchar('\n');
}
template <typename T, typename... types>
void print(T x, types... oth) {
out(x);
putchar(' ');
print(oth...);
}
constexpr int maxn = 1e5 + 10;
constexpr int mod = 1e9 + 7;
long long dp[maxn][2][2];
char a[maxn], b[maxn];
int32_t main() {
int n;
in(n);
scanf("%s%s", a + 1, b + 1);
for (int i = 1; i <= n; i++) {
if (isdigit(a[i])) a[i] -= '0';
if (isdigit(b[i])) b[i] -= '0';
}
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++) {
if (a[i] == '?' && b[i] == '?') {
dp[i][j | 1][k] += 45 * dp[i - 1][j][k];
dp[i][j | 1][k] %= mod;
dp[i][j][k | 1] += 45 * dp[i - 1][j][k];
dp[i][j][k | 1] %= mod;
dp[i][j][k] += 10 * dp[i - 1][j][k];
dp[i][j][k] %= mod;
} else if (a[i] == '?') {
dp[i][j | 1][k] += (9 - b[i]) * dp[i - 1][j][k];
dp[i][j | 1][k] %= mod;
dp[i][j][k | 1] += b[i] * dp[i - 1][j][k];
dp[i][j][k | 1] %= mod;
dp[i][j][k] += dp[i - 1][j][k];
dp[i][j][k] %= mod;
} else if (b[i] == '?') {
dp[i][j | 1][k] += a[i] * dp[i - 1][j][k];
dp[i][j | 1][k] %= mod;
dp[i][j][k | 1] += (9 - a[i]) * dp[i - 1][j][k];
dp[i][j][k | 1] %= mod;
dp[i][j][k] += dp[i - 1][j][k];
dp[i][j][k] %= mod;
} else {
if (a[i] > b[i])
dp[i][j | 1][k] += dp[i - 1][j][k], dp[i][j][k] %= mod;
else if (a[i] < b[i])
dp[i][j][k | 1] += dp[i - 1][j][k], dp[i][j][k] %= mod;
else
dp[i][j][k] += dp[i - 1][j][k], dp[i][j][k] %= mod;
}
}
print(dp[n][1][1]);
return Accepted;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x, y;
cin >> n >> x >> y;
long long c =
((y - n + (long long)1) * (y - n + (long long)1) + n - (long long)1);
if ((n > y) || c < x) {
cout << -1 << "\n";
} else {
for (long long i = 1; i < n; i++) cout << "1 ";
cout << y - (n - 1);
}
}
int32_t main() {
{ solve(); }
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int count(long long int index, long long int n) {
long long int elemCount = 1;
do {
elemCount *= 2;
} while (elemCount <= n);
elemCount--;
long long int mid = (elemCount + 1) / 2;
long long int currentIndex = mid;
long long int value = n;
long long int restTree = 0;
long long int add = mid / 2;
while (true) {
if (currentIndex == index) break;
value /= 2;
if (currentIndex > index) {
if (add > 0) add *= -1;
} else if (currentIndex < index) {
if (add < 0) add *= -1;
}
currentIndex += add;
add /= 2;
}
return value % 2;
}
int main() {
long long int n, l, r, ans = 0;
cin >> n >> l >> r;
for (long long int x = l; x <= r; x++) {
ans += count(x, n);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 10;
long long s1[maxn], s2[maxn];
long long mmod(int a, int b) { return (1ll * a * b) % mod; }
long long smod(long long a, long long b) { return (1ll * a + b) % mod; }
long long powmod(long long a, long long e) {
if (e == 0) return 1;
if (e & 1) return mmod(a, powmod(a, e - 1));
return powmod(mmod(a, a), e / 2);
}
long long inv(long long x) { return powmod(x, mod - 2); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, alf;
cin >> n >> alf;
for (int i = 0; i < n; ++i) cin >> s1[i];
for (int i = 0; i < n; ++i) cin >> s2[i];
long long p = 0, q = 1;
long long cont = 0;
for (int i = 0; i < n; ++i) {
if (s1[i] == 0) cont++;
if (s2[i] == 0) cont++;
}
long long ccont = 0;
q = powmod(alf, cont);
for (int i = 0; i < n; ++i) {
if (s1[i] == 0 && s2[i] == 0) {
cont -= 2;
long long cant = mmod(mmod(alf - 1, alf), inv(2));
long long rest = powmod(alf, ccont);
p = smod(p, mmod(mmod(cant, powmod(alf, cont)), rest));
ccont++;
} else if (s1[i] == 0) {
cont--;
long long rest = powmod(alf, ccont);
p = smod(p, mmod(mmod(alf - s2[i], powmod(alf, cont)), rest));
} else if (s2[i] == 0) {
cont--;
long long rest = powmod(alf, ccont);
p = smod(p, mmod(mmod(s1[i] - 1, powmod(alf, cont)), rest));
} else if (s2[i] > s1[i])
break;
else if (s1[i] > s2[i]) {
long long rest = powmod(alf, ccont);
p = smod(p, mmod(rest, powmod(alf, cont)));
break;
}
}
cout << mmod(p, inv(q)) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class FPassports {
public:
void solve(istream& cin, ostream& cout) {
int N, P;
cin >> N >> P;
vector<pair<std::pair<int, int>, std::pair<int, int>>> T(N);
for (int i = 0; i < N; ++i) {
cin >> T[i].first.first >> T[i].first.second >> T[i].second.first;
T[i].second.second = i;
}
sort(T.begin(), T.end());
int inf = 2e9;
vector<pair<int, std::pair<int, int>>> W(1 << N, {inf, {-1, 0}});
W[0].first = 1;
for (int b = 0; b < (1 << N); ++b) {
if (W[b].first == inf) continue;
int first = 0;
while (first < N &&
(T[first].first.first + T[first].first.second < W[b].first))
++first;
int bar = first;
while (bar < N &&
T[bar].first.first + T[bar].first.second - 1 < W[b].first)
++bar;
bool canApplyRightAway = !(bar < N && T[bar].first.first <= W[b].first);
int earliestAfter = first;
while (earliestAfter < N && (T[earliestAfter].first.first < W[b].first ||
((b & (1 << earliestAfter)) == 0)))
++earliestAfter;
for (int g = first; g < N; ++g) {
if (b & (1 << g)) continue;
int foo = first, bar = first;
for (int k = first; k <= N; ++k) {
int apply = k == first ? W[b].first
: T[k - 1].first.first + T[k - 1].first.second;
int passBack = apply + T[g].second.first;
if (T[g].first.first <= passBack) break;
if (k == first && !canApplyRightAway) continue;
if (k != first && k != N && T[k].first.first == apply) continue;
if (k == first) {
if (earliestAfter != N &&
W[b].first <= T[earliestAfter].first.first &&
T[earliestAfter].first.first <= passBack)
continue;
} else {
while (foo < N &&
(T[foo].first.first < apply || ((b & (1 << foo)) == 0)))
++foo;
if (foo != N && apply <= T[foo].first.first &&
T[foo].first.first <= passBack)
continue;
}
W[b | (1 << g)] = min(W[b | (1 << g)], {passBack, {g, apply}});
break;
}
}
}
vector<std::pair<int, int>> Ans(N);
if (P == 1) {
if (W[(1 << N) - 1].first == inf) {
cout << "NO\n";
return;
} else {
int m = (1 << N) - 1;
while (m != 0) {
Ans[T[W[m].second.first].second.second] = {1, W[m].second.second};
m ^= 1 << W[m].second.first;
}
}
}
if (P == 2) {
bool found = false;
for (int m = 0; m < (1 << N); ++m) {
int c = ((1 << N) - 1) ^ m;
if (W[m].first != inf && W[c].first != inf) {
while (m != 0) {
Ans[T[W[m].second.first].second.second] = {1, W[m].second.second};
m ^= 1 << W[m].second.first;
}
while (c != 0) {
Ans[T[W[c].second.first].second.second] = {2, W[c].second.second};
c ^= 1 << W[c].second.first;
}
found = true;
break;
}
}
if (!found) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
for (std::pair<int, int> ans : Ans) cout << ans << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
FPassports solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
int n, l, w;
long long Ans;
int main() {
scanf("%d %d %d", &n, &l, &w);
for (int i = 1; i <= n; ++i) {
int x, v;
scanf("%d %d", &x, &v);
if (v == 1)
a.push_back(x);
else
b.push_back(x);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int d1 = 0, d2 = 0, d3 = 0;
for (auto i : a)
if (i < 0) ++d1;
for (auto i : b)
if (i + l > 0) ++d2;
Ans += 1ll * d1 * d2;
if (w > 1) {
int lim = 0;
for (; lim < b.size() && b[lim] + l <= 0; ++lim)
;
for (auto i : a)
if (i + l < 0) {
int l = -1, r = lim;
while (r - l > 1) {
int mid = l + r >> 1;
if (b[mid] < i) {
l = mid;
continue;
}
double t = 1.0 * (b[mid] + ::l - i) / 2;
if (-w * t < i + t)
r = mid;
else
l = mid;
}
Ans += lim - r;
}
for (auto i : a)
if (i >= 0) {
int l = lim - 1, r = b.size();
while (r - l > 1) {
int mid = l + r >> 1;
if (b[mid] < i) {
l = mid;
continue;
}
double t = 1.0 * (b[mid] + ::l - i) / 2;
if (w * t > i + t)
r = mid;
else
l = mid;
}
Ans += b.size() - r;
}
}
printf("%lld\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n;
scanf("%d", &n);
int s = 0;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]), s += a[i];
if (n == 1 || (n == 2 && a[0] == a[1])) return printf("-1\n"), 0;
for (int i = 0; i < n; ++i) {
if (s - a[i] != a[i]) return printf("1\n%d\n", i + 1), 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
char temp[100009];
int A[100009], B[100009], n, maxi, init, i, N, x, y;
int main() {
while (scanf("%s", temp) == 1) {
n = strlen(temp);
maxi = 0;
init = 0;
N = 0;
B[0] = 0;
for (i = 0; i < n; i++) {
if (i != 0) B[i] = B[i - 1];
if (temp[i] == '(' || temp[i] == '[') {
if (temp[i] == '[') B[i]++;
A[N] = i;
N++;
} else if (temp[i] == ')') {
if (N > 0 && temp[A[N - 1]] == '(')
N--;
else {
N = 0;
init = i + 1;
}
if (init < i) {
if (N > 0) {
if (B[i] - B[A[N - 1]] > maxi) {
maxi = B[i] - B[A[N - 1]];
x = A[N - 1] + 1;
y = i;
}
} else if ((init == 0 && B[i] > maxi) || B[i] - B[init - 1] > maxi) {
if (init == 0)
maxi = B[i];
else
maxi = B[i] - B[init - 1];
x = init;
y = i;
}
}
} else if (temp[i] == ']') {
if (N > 0 && temp[A[N - 1]] == '[')
N--;
else {
N = 0;
init = i + 1;
}
if (init < i) {
if (N > 0) {
if (B[i] - B[A[N - 1]] > maxi) {
maxi = B[i] - B[A[N - 1]];
x = A[N - 1] + 1;
y = i;
}
} else if ((init == 0 && B[i] > maxi) || B[i] - B[init - 1] > maxi) {
if (init == 0)
maxi = B[i];
else
maxi = B[i] - B[init - 1];
x = init;
y = i;
}
}
}
}
printf("%d\n", maxi);
if (maxi > 0) {
for (i = x; i <= y; i++) printf("%c", temp[i]);
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
long long s[N], t[N];
void add(int x, int ind, long long *arr) {
for (int i = ind; i < N; i += i & -i) arr[i] += x;
}
long long get(int ind, long long *arr) {
long long ans = 0;
for (int i = ind; i > 0; i -= i & -i) ans += arr[i];
return ans;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long double ans = 0;
for (int i = 1; i <= n; i++)
ans += 0.5 * (n + 1 - i) * i * (i - 1) / (n + 1) / n;
for (int i = 0; i < n; i++) {
long long cnt = get(n, t) - get(a[i], t);
long long sum = get(n, s) - get(a[i], s);
ans += 1.0 * cnt;
ans -= 2.0 * (n - i) * sum / (n + 1) / n;
add(1, a[i], t);
add(i + 1, a[i], s);
}
cout << fixed << setprecision(16) << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, MAXM = 1e5 + 10, ALP = 26, INF = 1e9 + 10,
MOD = 1e9 + 7;
const int hA[4] = {1, 0, -1, 0}, kA[4] = {1, 0, -1, 0};
void solve() {
long long r, g, b, w;
cin >> r >> g >> b >> w;
int ans = r % 2 + g % 2 + b % 2 + w % 2;
if (ans <= 1)
cout << "YES\n";
else {
int nm = min(r, min(g, b));
if (!nm)
cout << "NO\n";
else {
ans = (r - 1) % 2 + (g - 1) % 2 + (b - 1) % 2 + (w + 1) % 2;
if (ans <= 1)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, k;
cin >> n >> k;
int special = 1;
x = 0;
while (x <= n) {
x = k * special;
special++;
}
cout << x;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct part {
int id, a, b;
part() {}
bool operator<(part X) const {
if (a != X.a) return a < X.a;
return b < X.b;
}
} a[100005];
struct actor {
int id, c, d, k;
actor() {}
bool operator<(actor X) const {
if (c != X.c) return c < X.c;
return d < X.d;
}
} b[100005];
int cap[100005], ans[100005];
set<pair<int, int> > S;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
a[i].id = i;
scanf("%d %d", &a[i].a, &a[i].b);
}
sort(a, a + n);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
b[i].id = i;
scanf("%d %d %d", &b[i].c, &b[i].d, &b[i].k);
cap[i] = b[i].k;
}
sort(b, b + m);
bool ok = true;
for (int p1 = 0, p2 = 0; (p1 < n || p2 < m) && ok;) {
int curt;
if (p1 < n && p2 < m)
curt = min(a[p1].a, b[p2].c);
else if (p1 < n)
curt = a[p1].a;
else
curt = b[p2].c;
while (p2 < m && b[p2].c == curt) {
S.insert(make_pair(b[p2].d, b[p2].id));
++p2;
}
while (p1 < n && a[p1].a == curt) {
set<pair<int, int> >::iterator it = S.lower_bound(make_pair(a[p1].b, 0));
if (it == S.end())
ok = false;
else {
int id = it->second;
ans[a[p1].id] = id;
--cap[id];
if (cap[id] == 0) S.erase(it);
}
++p1;
}
}
if (!ok)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < n; ++i) printf("%d ", ans[i] + 1);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 1;
long long d[maxn << 1], inf;
int n, Q, s;
vector<int> to[maxn << 1], w[maxn << 1];
void addEdge(int x, int y, int z) {
to[x].push_back(y);
w[x].push_back(z);
return;
}
struct node {
int i;
long long dis;
};
bool operator<(node a, node b) { return a.dis > b.dis; }
priority_queue<node> q;
void buildtree(int k1, int l, int r) {
if (l == r) {
addEdge(k1 + n, l, 0);
addEdge(l, k1 + maxn + n, 0);
return;
}
int mid = l + r >> 1, lc = k1 << 1, rc = lc | 1;
buildtree(lc, l, mid);
buildtree(rc, mid + 1, r);
addEdge(k1 + n, lc + n, 0);
addEdge(lc + maxn + n, k1 + maxn + n, 0);
addEdge(k1 + n, rc + n, 0);
addEdge(rc + maxn + n, k1 + maxn + n, 0);
return;
}
int op, x, y, z, v;
void add(int k1, int l, int r) {
if (x <= l && r <= y) {
if (op == 2)
addEdge(v, k1 + n, z);
else
addEdge(k1 + n + maxn, v, z);
return;
}
if (l > y || r < x) return;
int mid = l + r >> 1, lc = k1 << 1, rc = lc | 1;
add(lc, l, mid);
add(rc, mid + 1, r);
return;
}
void dijkstra() {
for (int i = 1; i <= maxn * 2; i++) d[i] = inf;
q.push((node){s, 0});
d[s] = 0;
while (!q.empty()) {
node t = q.top();
x = t.i;
q.pop();
if (d[t.i] != t.dis) continue;
int siz = to[t.i].size();
for (int i = 0; i < siz; i++) {
int v = to[x][i];
if (d[v] > d[x] + w[x][i]) {
d[v] = d[x] + w[x][i];
q.push((node){v, d[v]});
}
}
}
}
int main() {
inf = 1, inf <<= 60;
scanf("%d%d%d", &n, &Q, &s);
buildtree(1, 1, n);
for (int i = 1; i <= Q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d%d", &x, &y, &z);
addEdge(x, y, z);
} else {
scanf("%d%d%d%d", &v, &x, &y, &z);
add(1, 1, n);
}
}
dijkstra();
for (int i = 1; i <= n; i++) {
if (d[i] == inf)
printf("-1 ");
else
printf("%I64d ", d[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n, m, q;
int tree[3 * N];
int par[3 * N][2][10];
int D[10][N];
void build(int cur, int l, int r) {
if (l == r) {
for (int i = 0; i < n; i++) par[cur][0][i] = par[cur][1][i] = l * n + i;
int cnt = n;
for (int i = 0; i < n - 1; i++) {
if (D[i][l] == D[i + 1][l])
par[cur][0][i + 1] = par[cur][1][i + 1] = par[cur][0][i], cnt--;
}
tree[cur] = cnt;
return;
} else if (l > r)
return;
int M = l + r >> 1;
build(2 * cur + 1, l, M);
build(2 * cur + 2, M + 1, r);
int cnt = tree[2 * cur + 1] + tree[2 * cur + 2], pp[10];
for (int i = 0; i < n; i++)
par[cur][0][i] = par[2 * cur + 1][0][i],
par[cur][1][i] = par[2 * cur + 2][1][i], pp[i] = par[2 * cur + 1][1][i];
for (int i = 0; i < n; i++) {
if (D[i][M] == D[i][M + 1]) {
if (pp[i] != par[2 * cur + 2][0][i]) {
cnt--;
int W = pp[i], W1 = par[2 * cur + 2][0][i];
for (int j = 0; j < n; j++) {
if (par[cur][0][j] == W) par[cur][0][j] = W1;
if (par[cur][1][j] == W) par[cur][1][j] = W1;
if (pp[j] == W) pp[j] = W1;
}
}
}
}
tree[cur] = cnt;
}
int qry[3 * N][2][10];
int query(int cur, int l, int r, int x, int y) {
if (r < x || y < l || l > r) return 0;
if (x <= l && r <= y) {
for (int i = 0; i < n; i++)
qry[cur][0][i] = par[cur][0][i], qry[cur][1][i] = par[cur][1][i];
return tree[cur];
}
int M = l + r >> 1, cnt = 0, c1, c2, pp[10];
c1 = query(2 * cur + 1, l, M, x, y);
c2 = query(2 * cur + 2, M + 1, r, x, y);
for (int i = 0; i < n; i++) {
if (c1)
qry[cur][0][i] = qry[2 * cur + 1][0][i], pp[i] = qry[2 * cur + 1][1][i];
else
qry[cur][0][i] = qry[2 * cur + 2][0][i];
if (c2)
qry[cur][1][i] = qry[2 * cur + 2][1][i];
else
qry[cur][1][i] = qry[2 * cur + 1][1][i];
}
cnt = c1 + c2;
if (c1 && c2)
for (int i = 0; i < n; i++) {
if (D[i][M] == D[i][M + 1]) {
if (pp[i] != qry[2 * cur + 2][0][i]) {
cnt--;
int W = pp[i], W1 = qry[2 * cur + 2][0][i];
for (int j = 0; j < n; j++) {
if (qry[cur][0][j] == W) qry[cur][0][j] = W1;
if (qry[cur][1][j] == W) qry[cur][1][j] = W1;
if (pp[j] == W) pp[j] = W1;
}
}
}
}
return cnt;
}
int main() {
int LL, RR;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> D[i][j];
}
build(0, 0, m - 1);
for (int i = 0; i < q; i++) {
cin >> LL >> RR;
cout << query(0, 0, m - 1, LL - 1, RR - 1) << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int v[50101], u[50101];
int c[50101], t[50101];
vector<pair<int, int>> sgr[301010][2];
map<int, int> gr[50101];
int pred[50101];
int vis[301010][2];
int ind;
int ord[301010];
int chk[301010];
const int INF = 1010101010;
int dfs(int x, int sty, int ti, int tmp = 1) {
if (vis[x][sty]) return 1;
vis[x][sty] = tmp;
if (sty) {
if (vis[(x + 3 * m) % (6 * m)][sty] == tmp) return 0;
if (x < 3 * m)
chk[x % (3 * m)] = 1;
else
chk[x % (3 * m)] = 2;
}
for (auto y : sgr[x][sty]) {
if (y.second > ti) {
if (!dfs(y.first, sty, ti, tmp)) {
return 0;
}
}
}
if (!sty) ord[ind++] = x;
return 1;
}
int check(int ti) {
for (int i = 0; i < 6 * m; i++) {
chk[i] = 0;
for (int j = 0; j < 2; j++) vis[i][j] = 0;
}
ind = 0;
for (int i = 6 * m - 1; i >= 0; i--) dfs(i, 0, ti);
for (int i = 6 * m - 1; i >= 0; i--) {
if (!dfs(ord[i], 1, ti, i + 1)) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int fail = 0;
for (int i = 0; i < m; i++) {
cin >> v[i] >> u[i] >> c[i] >> t[i];
if (gr[v[i]].count(c[i]))
gr[v[i]][c[i]]++;
else
gr[v[i]][c[i]] = 1;
if (gr[u[i]].count(c[i]))
gr[u[i]][c[i]]++;
else
gr[u[i]][c[i]] = 1;
if (max(gr[v[i]][c[i]], gr[u[i]][c[i]]) > 2) fail = 1;
}
if (fail) {
cout << "No\n";
return 0;
}
for (int i = 1; i <= n; i++) gr[i].clear();
for (int i = 0; i < m; i++) {
if (gr[v[i]].count(c[i])) {
int j = gr[v[i]][c[i]];
sgr[i + 3 * m][0].push_back(make_pair(j, INF));
sgr[j + 3 * m][0].push_back(make_pair(i, INF));
sgr[i][1].push_back(make_pair(j + 3 * m, INF));
sgr[j][1].push_back(make_pair(i + 3 * m, INF));
} else
gr[v[i]][c[i]] = i;
if (gr[u[i]].count(c[i])) {
int j = gr[u[i]][c[i]];
sgr[i + 3 * m][0].push_back(make_pair(j, INF));
sgr[j + 3 * m][0].push_back(make_pair(i, INF));
sgr[i][1].push_back(make_pair(j + 3 * m, INF));
sgr[j][1].push_back(make_pair(i + 3 * m, INF));
} else
gr[u[i]][c[i]] = i;
}
for (int i = 0; i < m; i++) {
sgr[i][0].push_back(make_pair(i + 3 * m, t[i]));
sgr[i + 3 * m][1].push_back(make_pair(i, t[i]));
int hlp = m + 2 * i;
sgr[i][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(i + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
if (pred[v[i]]) {
int j = pred[v[i]];
sgr[j][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(j + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(j, INF));
sgr[j + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
sgr[i][0].push_back(make_pair(j + 3 * m, INF));
sgr[j][0].push_back(make_pair(i + 3 * m, INF));
sgr[j + 3 * m][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(j, INF));
}
pred[v[i]] = hlp;
hlp++;
sgr[i][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(i + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
if (pred[u[i]]) {
int j = pred[u[i]];
sgr[j][0].push_back(make_pair(hlp, INF));
sgr[hlp + 3 * m][0].push_back(make_pair(j + 3 * m, INF));
sgr[hlp][1].push_back(make_pair(j, INF));
sgr[j + 3 * m][1].push_back(make_pair(hlp + 3 * m, INF));
sgr[i][0].push_back(make_pair(j + 3 * m, INF));
sgr[j][0].push_back(make_pair(i + 3 * m, INF));
sgr[j + 3 * m][1].push_back(make_pair(i, INF));
sgr[i + 3 * m][1].push_back(make_pair(j, INF));
}
pred[u[i]] = hlp;
}
int ala = 0;
int yla = INF;
while (ala < yla) {
int mid = (ala + yla) / 2;
if (check(mid))
yla = mid;
else
ala = mid + 1;
}
if (!check(yla) || yla >= INF) {
cout << "No\n";
} else {
cout << "Yes\n";
cout << yla << " ";
int cntr = 0;
for (int i = 0; i < m; i++) {
if (chk[i] == 1) cntr++;
}
cout << cntr << "\n";
for (int i = 0; i < m; i++) {
if (chk[i] == 1) cout << i + 1 << " ";
}
cout << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t, n, m, i, j, k, sum = 0;
cin >> n;
string s;
cin >> s;
long long int mmin = 500000000;
for (i = 0; i < s.size(); i++) {
for (j = i; j < s.size() - 3; j++) {
k = min({abs(s[j] - 'A'), abs(s[j] - 'A' + 26), abs(s[j] - 'A' - 26)}) +
min({abs(s[j + 1] - 'C'), abs(s[j + 1] - 'C' - 26),
abs(s[j + 1] - 'C' + 26)}) +
min({abs(s[j + 2] - 'T'), abs(s[j + 2] - 'T' - 26),
abs(s[j + 2] - 'T' + 26)}) +
min({abs(s[j + 3] - 'G'), abs(s[j + 3] - 'G' - 26),
abs(s[j + 3] - 'G' + 26)});
mmin = min(mmin, k);
}
}
cout << mmin << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K, P;
long long A[20001];
int lst[100];
long long dp[51][20001];
int main() {
std::ios_base::sync_with_stdio(false);
scanf("%d %d %d", &N, &K, &P);
for (int i = 1; i <= N; i++) {
scanf("%lld", &A[i]);
A[i] += A[i - 1];
dp[1][i] = A[i] % P;
}
for (int k = 2; k <= K; k++) {
for (int p = 0; p < P; p++) lst[p] = 0;
for (int i = 1; i <= N; i++) {
if (i == k)
dp[k][i] = A[i] % P;
else if (i > k)
for (int l = 0; l < P; l++)
if (lst[l])
dp[k][i] =
max(dp[k][i], dp[k - 1][lst[l]] + (A[i] - A[lst[l]]) % P);
if (i >= k - 1) lst[A[i] % P] = i;
}
}
printf("%lld\n", dp[K][N]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long pows(long long b, long long e) {
if (e == 0)
return 1;
else if (e % 2 == 0) {
long long a = pow(b, e / 2);
return a * a;
} else {
long long a = pow(b, e / 2);
return b * a * a;
}
}
long long powm(long long x, long long y, long long m) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m = 1000000007) {
if (m == 1) return 0;
long long m0 = m, y = 0, x = 1;
while (a > 1) {
long long q = a / m, t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j, k, x, y, z, e, f, p, q, g, l, r, w, h,
count1 = 0, prod = 1, a, b, c, d, index, x1, x2, diff, ans = 0, sum = 0,
sum1 = 0, sum2 = 0, flag = 0, flag1 = 0, flag2 = 0;
string s, s1, s2;
cin >> s;
n = s.size();
if (n <= 3) {
cout << s;
return 0;
}
if (n == 4) {
s1 += s[0];
if (s[1] == 'a' && s[2] == 't') {
s1 += '@';
} else {
s1 += s[1];
s1 += s[2];
}
s1 += s[3];
} else {
s1 += s[0];
for (i = 1; i < n - 2; i++) {
if (i == n - 3) {
flag = 1;
if (count1 == 0 && s[i] == 'a' && s[i + 1] == 't') {
s1 += '@';
count1++;
} else {
s1 += s[i];
s1 += s[i + 1];
}
i += 1;
} else {
if (s[i] == 'd' && s[i + 1] == 'o' && s[i + 2] == 't') {
s1 += '.';
i += 2;
} else if (count1 == 0 && s[i] == 'a' && s[i + 1] == 't') {
s1 += '@';
i += 1;
count1++;
} else {
s1 += s[i];
}
}
}
while (i < n) {
s1 += s[i];
i++;
}
}
cout << s1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
int32_t main(int32_t argc, char const *argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long x, y, z, a, b, c;
cin >> x >> y >> z >> a >> b >> c;
if (x > a || y > a + b - x) {
cout << "NO"
<< "\n";
return 0;
}
long long resg = a - x;
resg += b - y + c;
if (resg < z) {
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << min(a, b) << " " << (a - min(a, b) + b - min(a, b)) / 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, N, ans;
int main() {
cin >> n >> m >> k;
N = 1000000007;
if (k > n || k == 1) {
ans = 1;
for (int i = 1; i <= n; i++) ans = (ans * m) % N;
} else if (k == n) {
ans = 1;
for (int i = 1; i <= n / 2 + n % 2; i++) ans = (ans * m) % N;
} else if (k <= 2)
ans = m;
else if (k % 2 == 0)
ans = m;
else
ans = m * m;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool flag[1000001] = {false};
int a[1000001];
int dp[1000001] = {0};
int ans = 0;
void dfs(int n, int s) {
if (dp[n] >= s) return;
dp[n] = s;
ans = max(ans, dp[n]);
for (int i = 2; i * n < 1000001; i++)
if (flag[i * n]) dfs(i * n, s + 1);
}
int main() {
int n, t;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), flag[a[i]] = true;
for (int i = 0; i < n; i++) {
if (dp[a[i]] == 0) dfs(a[i], 1);
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long MOD = 10000000061;
const long long INFLL = 1e18;
const int INF = 1e9;
const int NMAX = 1000001;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, d;
cin >> n >> d;
vector<long long> v(n + 1);
for (int i = 0; i < n; ++i) {
cin >> v[i];
};
long long res = 0;
long long last = 0;
for (int i = 0; i < n - 2; ++i) {
long long left = i, right = n - 1, sol = 0;
;
while (left <= right) {
long long mid = left + (right - left) / 2;
if (abs(v[mid] - v[i]) <= d) {
left = mid + 1;
sol = mid;
} else {
right = mid - 1;
}
}
res += ((sol - i) * (sol - i - 1)) / 2;
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, l;
scanf("%lf %lf", &h, &l);
printf("%.10lf\n", (l * l - h * h) / (2 * h));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mypopcnt(int n) {
int res = 0;
for (int i = 0; i < 20; i++)
if ((n >> i) & 1) res++;
return res;
}
int main() {
int md = 1e9 + 7;
string s;
cin >> s;
int k;
cin >> k;
vector<int> pcnt(1001);
for (int i = 1; i <= 1000; i++) pcnt[i] = mypopcnt(i);
vector<int> ops(1001);
ops[1] = 0;
for (int i = 2; i <= 1000; i++) ops[i] = ops[pcnt[i]] + 1;
int m = s.length();
vector<vector<vector<int>>> d(m + 1,
vector<vector<int>>(1001, vector<int>(2)));
d[0][0][false] = 1;
for (int i = 1; i <= m; i++)
for (int b = 0; b <= 1000; b++) {
if (s[i - 1] == '1') {
if (b) d[i][b][false] = d[i - 1][b - 1][false];
if (b) d[i][b][true] = d[i - 1][b - 1][true];
d[i][b][true] += d[i - 1][b][true];
d[i][b][true] += d[i - 1][b][false];
} else {
d[i][b][false] = d[i - 1][b][false];
if (b) d[i][b][true] = d[i - 1][b - 1][true];
d[i][b][true] += d[i - 1][b][true];
}
d[i][b][true] %= md;
d[i][b][false] %= md;
}
int res = 0;
for (int i = 1; i <= 1000; i++)
if (ops[i] == k - 1) {
res += d[m][i][false] + d[m][i][true];
res %= md;
}
if (k == 1) res--;
if (k == 0) res = 1;
if (res < 0) res += md;
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long f[2100][2][2][2100], m, d;
string y, x;
void inp() {}
long long dp(int idx, bool smaller, bool biger, long long mod) {
if (idx == y.size()) {
if (mod == 0) {
return 1;
} else
return 0;
}
if (f[idx][smaller][biger][mod] != -1) return f[idx][smaller][biger][mod];
int limit = 9;
long long res = 0;
for (int i = 0; i <= 9; i++) {
if (i > y[idx] - '0' && smaller == 1) continue;
if (i < x[idx] - '0' && biger == 1) continue;
if (i != d && idx % 2 == 1) continue;
if (i == d && idx % 2 == 0) continue;
bool tmp;
if (i < y[idx] - '0')
tmp = 0;
else
tmp = smaller;
bool tb = biger;
if (i > x[idx] - '0') tb = 0;
long long tam = dp(idx + 1, tmp, tb, (mod * 10 + i) % m) % 1000000007;
res = (res + tam) % 1000000007;
}
f[idx][smaller][biger][mod] = res % 1000000007;
return res % 1000000007;
}
int main() {
memset(f, -1, sizeof(f));
cin >> m >> d;
cin >> x >> y;
cout << dp(0, 1, 1, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
const long long inf = 1e18;
using namespace std;
long long int ans = 1;
long long int modpow(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
void solve() {
int n;
cin >> n;
std::vector<int> c(n + 1);
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
char last = 'A';
long long int cnt = 0;
for (int i = n; i >= 1; i--) {
if (c[i] == 0) continue;
for (int j = i - 1; j >= 1; j--) {
c[j] -= c[i] * (i - j + 1);
}
char ch = 'a';
if (last == 'a') ch = 'b';
while (c[i]) {
c[i]--;
last = ch;
cnt += i;
for (int j = 0; j < i; j++) {
last = ch;
cout << ch;
}
ch++;
if (ch > 'z') ch = 'a';
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t = 1, tt = 1;
while (tt <= t) {
solve();
tt++;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int N;
vector<int> arr;
BIT(int N) {
N++;
this->N = N;
arr = vector<int>(N);
}
void u(int a, int b) {
_u(a, 1);
if (b < N) _u(b + 1, -1);
}
void _u(int idx, int val) {
while (idx <= N) {
arr[idx] += val;
idx += idx & (-idx);
}
}
int q(int idx) {
int s = 0;
while (idx > 0) {
s += arr[idx];
idx -= idx & (-idx);
}
return s;
}
};
int main() {
int N;
cin >> N;
vector<int> a(N);
vector<int> arr(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
arr[i] = i + 1;
}
sort(arr.begin(), arr.end(), [&](int i1, int i2) -> bool {
if (a[i1 - 1] == a[i2 - 1]) return i1 < i2;
return a[i1 - 1] > a[i2 - 1];
});
int M;
cin >> M;
vector<vector<int>> qs(M);
for (int i = 0; i < M; i++) {
int k, idx;
cin >> k >> idx;
qs[i] = {k, idx, i};
}
sort(qs.begin(), qs.end());
BIT bit(N);
int idx = 0;
vector<int> ans(M);
for (int k = 1; k <= N; k++) {
bit.u(arr[k - 1], N);
while (idx < M && qs[idx][0] == k) {
int goal = qs[idx][1];
int l = 1, r = N;
while (l < r) {
int m = (l + r) / 2;
int am = bit.q(m);
if (am == goal && (m == 1 || bit.q(m - 1) != goal)) {
l = m;
break;
} else if (am >= goal) {
r = m - 1;
} else {
l = m + 1;
}
}
ans[qs[idx][2]] = a[l - 1];
idx++;
}
}
for (int i = 0; i < M; i++) {
cout << ans[i] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long bit[200005][2];
int n, k, a, b, q;
long long get(int idx, int t) {
long long ret = 0;
while (idx) {
ret += bit[idx][t];
idx -= (idx & (-idx));
}
return ret;
}
long long update(int idx, int t, long long val) {
while (idx <= n) {
bit[idx][t] += val;
idx += (idx & (-idx));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
int op;
long long int d, v;
int p;
while (q--) {
cin >> op;
if (op == 1) {
cin >> d >> v;
long long int val1 = get(d, 0) - get(d - 1, 0);
if (val1 < b) update(d, 0, min(b - val1, v));
val1 = get(d, 1) - get(d - 1, 1);
if (val1 < a) update(d, 1, min(a - val1, v));
continue;
}
if (op == 2) {
cin >> p;
long long ans = get(p - 1, 0);
if (p + k - 1 <= n) ans += get(n, 1) - get(p + k - 1, 1);
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(long long n) {
if (n <= 1) {
return false;
}
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
inline long long getPow(long long a, long long b) {
long long res = 1ll, tp = a;
while (b) {
if (b & 1ll) {
res *= tp;
}
tp *= tp;
b >>= 1ll;
}
return res;
}
long long coso(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
return abs((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1));
}
inline long long nxt() {
long long x;
cin >> x;
return x;
}
void ok() {
puts("YES");
exit(0);
}
void no() {
puts("NO");
exit(0);
}
const long long N = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> mas(n);
for (int i = 0; i < n; i++) {
cin >> mas[i];
}
vector<vector<long long>> dp(200 + 5, vector<long long>(2, 0LL));
if (mas[0] == -1) {
for (int i = 1; i <= 200; i++) {
dp[i][1] = 1;
}
} else
dp[mas[0]][1] = 1;
for (int i = 1; i < n; i++) {
long long cur = 0;
vector<vector<long long>> dp2(200 + 5, vector<long long>(2, 0LL));
for (int j = 1; j <= 200; j++) {
dp2[j][1] = cur;
cur = (cur + dp[j][0] + dp[j][1]);
while (cur > 998244353) {
cur -= 998244353;
}
}
cur = 0;
for (int j = 200; j >= 1; j--) {
dp2[j][0] =
((dp2[j][0] + dp[j][0] + dp[j][1]) % 998244353 + cur) % 998244353;
while (dp2[j][0] > 998244353) {
dp2[j][0] -= 998244353;
}
cur = (cur + dp[j][0]);
while (cur > 998244353) {
cur -= 998244353;
}
}
for (int j = 1; j <= 200; j++) {
if (mas[i] != -1 && mas[i] != j) {
dp2[j][0] = dp2[j][1] = 0;
}
}
dp = dp2;
}
long long ans = 0LL;
for (int i = 1; i <= 200; i++) {
ans += dp[i][0];
}
cout << ans % 998244353;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100002], p[150000], p1[2000002], co = 0;
bool a1[2000002] = {0};
void sieve() {
long long int i, j;
a1[0] = a1[1] = 1;
for (i = 2; i < 2000002; i++)
if (!a1[i]) {
p[co] = i;
p1[i] = co++;
for (j = i * i; j < 2000002; j += i) a1[j] = 1;
}
}
vector<int> G[100002];
stack<pair<int, int> > s[150002];
pair<int, int> ans[100002];
int dfs(int n, int level, int parent) {
long long int i = 1, j, l = G[n].size(), x = a[n], d = 2;
vector<int> primes;
while (d * d <= x) {
if (x % d == 0) {
if (!a1[d]) {
int pos = p1[d];
if (!s[pos].empty() && s[pos].top().second > ans[n].second)
ans[n] = s[pos].top();
s[pos].push(make_pair(n, level));
primes.push_back(pos);
}
while (x % d == 0) x /= d;
}
d = p[i++];
}
if (x > 1) {
int pos = p1[x];
if (!s[pos].empty() && s[pos].top().second > ans[n].second)
ans[n] = s[pos].top();
s[pos].push(make_pair(n, level));
primes.push_back(pos);
}
for (i = 0; i < l; i++)
if (G[n][i] != parent) dfs(G[n][i], level + 1, n);
int l1 = primes.size();
for (i = 0; i < l1; i++) s[primes[i]].pop();
return 0;
}
int main() {
sieve();
int n, q, i, j, x, y;
scanf("%d%d", &n, &q);
;
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
;
for (i = 0; i < n; i++) ans[i] = make_pair(-1, -1);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
;
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(0, 0, -1);
while (q--) {
int t;
scanf("%d", &t);
;
if (t == 1) {
scanf("%d", &x);
;
x--;
if (ans[x].first == -1)
printf("-1\n");
else
printf("%d\n", ans[x].first + 1);
} else {
scanf("%d%d", &x, &y);
;
x--;
a[x] = y;
for (i = 0; i < n; i++) ans[i] = make_pair(-1, -1);
dfs(0, 0, -1);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool f(long long a, long long b) { return a > b; }
long long b, a[100500], c[100500];
int main() {
long long n, k;
scanf("%I64d%I64d%I64d", &n, &k, &b);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
c[i] = a[i];
}
sort(c, c + n - 1, f);
long long t;
for (int i = 0; i < k - 1; i++) {
b -= c[i];
t = c[i];
}
if (c[k - 1] <= b) {
printf("%I64d", n);
return 0;
}
if (b < 0) {
printf("1");
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] > b) {
printf("%d", i + 1);
return 0;
}
}
printf("%I64d", n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
double nx, ny, T, nc, w, h, Dist[1005];
int n;
struct Point {
double x, y;
} a[1005];
double dir[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
double sqr(double a) { return a * a; }
double dist(double xa, double ya, double xb, double yb) {
return sqrt(sqr(xb - xa) + sqr(yb - ya));
}
double Calc(double x, double y) {
for (int i = 0; i <= n - 1; i++) Dist[i] = dist(x, y, a[i].x, a[i].y);
double Min1 = 1 << 30, pos1, Min2 = 1 << 30;
for (int i = 0; i <= n - 1; i++)
if (Dist[i] < Min1) Min1 = Dist[i], pos1 = i;
for (int i = 0; i <= n - 1; i++)
if (i != pos1 && Dist[i] < Min2) Min2 = Dist[i];
return Min2;
}
int main() {
srand((unsigned)time(NULL));
double Max = 0;
w = 1.0 * IN(), h = 1.0 * IN(), n = IN();
for (int i = 0; i <= n - 1; i++) a[i].x = IN(), a[i].y = IN();
for (int i = 1; i <= 60; i++) {
double nx = rand() * rand() % (int)w, ny = rand() * rand() % (int)h;
T = h, nc = Calc(nx, ny);
while (T > 1e-12) {
bool chg = 0;
double X, Y;
for (int j = 0; j <= 3; j++) {
double x = nx + T * dir[j][0], y = ny + T * dir[j][1];
if (x < 0 || x > w || y < 0 || y > h) continue;
double xc = Calc(x, y);
if (xc > nc) {
X = x, Y = y, nc = xc;
chg = 1;
}
}
if (chg) {
nx = X, ny = Y;
} else
T *= 0.9;
}
Max = max(Max, Calc(nx, ny));
}
printf("%.15lf\n", Max);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
template <typename T, typename U>
using P = pair<T, U>;
using ld = long double;
using ll = long long;
const int inf = 1e9, mod = 1e9 + 7;
const ll INF = 9e18;
const ld EPS = 1e-9, PI = acosl(-1.0);
const int N = 3e5 + 5;
ll st[4 * N], st2[4 * N], lazy[4 * N];
int n, q;
V<P<int, int>> v;
int search(int t) {
int lt = 0, rt = n - 1, ans = -1;
while (lt <= rt) {
int mid = (lt + rt) >> 1;
if (v[mid].first > t) {
rt = mid - 1;
} else
ans = mid, lt = mid + 1;
}
return ans;
}
ll build(int p, int l, int r) {
if (l == r) return st[p] = v[l].first;
int mid = (l + r) >> 1;
return st[p] = max(build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r));
}
void lazyUpd(int p, int l, int r) {
if (lazy[p]) {
st[p] += lazy[p];
if (l != r) {
lazy[p << 1] += lazy[p];
lazy[p << 1 | 1] += lazy[p];
}
lazy[p] = 0;
}
}
void update(int p, int l, int r, int lq, int rq, ll val) {
lazyUpd(p, l, r);
if (lq > r || rq < l) return;
if (lq <= l && r <= rq) {
st[p] += val;
if (l != r) {
lazy[p << 1] += val;
lazy[p << 1 | 1] += val;
}
return;
}
int mid = (l + r) >> 1;
update(p << 1, l, mid, lq, rq, val);
update(p << 1 | 1, mid + 1, r, lq, rq, val);
st[p] = max(st[p << 1], st[p << 1 | 1]);
}
void update(int p, int l, int r, int lq, ll val) {
int rq = lq;
if (lq > r || rq < l) return;
if (lq <= l && r <= rq) {
st2[p] += val;
return;
}
int mid = (l + r) >> 1;
update(p << 1, l, mid, lq, val);
update(p << 1 | 1, mid + 1, r, lq, val);
st2[p] = st2[p << 1] + st2[p << 1 | 1];
}
ll query(int p, int l, int r, int lq, int rq) {
lazyUpd(p, l, r);
if (lq > r || rq < l) return 0;
if (lq <= l && r <= rq) return st[p];
int mid = (l + r) >> 1;
return max(query(p << 1, l, mid, lq, rq),
query(p << 1 | 1, mid + 1, r, lq, rq));
}
ll query2(int p, int l, int r, int lq, int rq) {
if (lq > r || rq < l) return 0;
if (lq <= l && r <= rq) return st2[p];
int mid = (l + r) >> 1;
return query2(p << 1, l, mid, lq, rq) +
query2(p << 1 | 1, mid + 1, r, lq, rq);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> q;
char c;
int t1, t2;
V<P<int, int>> Q;
set<int> ts;
for (int i = (1), _i = (q + 1); i < _i; ++i) {
cin >> c;
if (c == '+') {
cin >> t1 >> t2;
Q.push_back(make_pair(t1, t2));
ts.insert(t1);
} else if (c == '-') {
cin >> t1;
Q.push_back({Q[t1 - 1].first, 0});
} else {
cin >> t2;
ts.insert(t2);
Q.push_back({-1, t2});
}
}
for (int t : ts) v.push_back(make_pair(t, 0));
n = v.size();
build(1, 0, n - 1);
for (auto q : Q) {
if (q.first == -1) {
int i = search(q.second);
if (i == -1) {
cout << 0 << '\n';
continue;
}
ll t = max((ll)q.second,
query(1, 0, n - 1, 0, i) - query2(1, 0, n - 1, i + 1, n - 1));
cout << t - q.second << '\n';
} else {
int t = q.first, d = q.second;
int i = search(t);
update(1, 0, n - 1, 0, i, d - v[i].second);
update(1, 0, n - 1, i, d - v[i].second);
v[i].second = d;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double getd(pair<double, double> a, pair<double, double> b) {
return sqrt((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
int ccw(pair<double, double> a, pair<double, double> b,
pair<double, double> c) {
if ((b.first - a.first) * (c.second - b.second) -
(b.second - a.second) * (c.first - b.first) <
0)
return 1;
else
return -1;
}
pair<double, double> d[3000];
double dist[3000][3000];
int v1[3000], v2[3000];
int main() {
int num;
scanf("%d", &num);
for (int i = 0; i < num; i++) scanf("%lf%lf", &d[i].first, &d[i].second);
sort(d, d + num);
for (int i = 0; i < num; i++)
for (int j = 0; j < num; j++) dist[i][j] = getd(d[i], d[j]);
double beg = 0.0, end = 100000.0;
for (int p = 0; p < 35; p++) {
double med = (beg + end) / 2;
bool flag = false;
for (int q = 0; q < num; q++) {
int pt1 = 0, pt2 = 0;
for (int i = 0; i < num; i++) {
if (dist[q][i] < med) continue;
for (;;) {
if (pt1 <= 1) break;
pair<double, double> a = d[v1[pt1 - 2]], b = d[v1[pt1 - 1]];
if (ccw(a, b, d[i]) != 1)
pt1--;
else
break;
}
v1[pt1++] = i;
}
for (int i = 0; i < num; i++) {
if (dist[q][i] < med) continue;
for (;;) {
if (pt2 <= 1) break;
pair<double, double> a = d[v2[pt2 - 2]], b = d[v2[pt2 - 1]];
if (ccw(a, b, d[i]) != -1)
pt2--;
else
break;
}
v2[pt2++] = i;
}
for (int i = pt2 - 2; i >= 1; i--) v1[pt1++] = v2[i];
int zn = pt1;
if (zn <= 1) continue;
double maxi = 0.0;
int pt = 1;
for (int i = 0; i < zn; i++) {
for (;;) {
if (pt == zn) pt = 0;
int n = pt + 1;
if (n == zn) n = 0;
if (dist[v1[i]][v1[pt]] < dist[v1[i]][v1[n]])
pt++;
else
break;
}
maxi = max(maxi, dist[v1[i]][v1[pt]]);
}
if (maxi > med) {
flag = true;
break;
}
}
if (flag)
beg = med;
else
end = med;
}
printf("%.10lf\n", beg / 2);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
void primeFactors(int n) {
while (n % 2 == 0) {
m[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
m[i]++;
n = n / i;
}
}
if (n > 2) m[n]++;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int sum(long long a) {
int sum = 0;
while (a > 0) {
sum = sum + (a % 10);
a = a / 10;
}
return sum;
}
int count_digit(long long n) {
int count = 0;
while (n > 0) {
if (n % 10 == 9) {
count++;
n = n / 10;
continue;
} else {
return count;
n = n / 10;
}
}
}
int binarySearch(int x, int y, long long z, long long v[]) {
int low = x;
int high = y;
int mid = x + (y - x) / 2;
while (low <= high) {
if (v[mid] == z) return mid;
if (v[mid] < z) return binarySearch(mid + 1, high, z, v);
if (v[mid] > z) return binarySearch(low, mid - 1, z, v);
}
return -1;
}
long long modularExponentiation(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % M, n / 2, M);
else
return (x * modularExponentiation((x * x) % M, (n - 1) / 2, M)) % M;
}
long long binaryExponentiation(long long x, long long n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return binaryExponentiation(x * x, n / 2);
else
return x * binaryExponentiation(x * x, (n - 1) / 2);
}
int binary(int n) {
int c = 0;
while (n > 0) {
if (n % 2 == 1) {
return pow(2, c);
}
n = n / 2;
c++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests = 1;
while (tests--) {
int n, m, l, r;
long long t, tprev = 0, s, f;
cin >> n >> m >> s >> f;
while (m--) {
cin >> t >> l >> r;
if (t - 1 - tprev > 0) {
if (f > s) {
for (int i = 0; i < min(f - s, t - 1 - tprev); i++) cout << 'R';
s = s + min(f - s, t - 1 - tprev);
} else if (s > f) {
for (int i = 0; i < min(s - f, t - 1 - tprev); i++) cout << "L";
s = s - min(s - f, t - 1 - tprev);
}
}
if (f > s) {
if ((s < l && s + 1 < l) || s > r) {
cout << "R";
s++;
} else
cout << "X";
} else if (s > f) {
if ((s > r && s - 1 > r) || s < l) {
s--;
cout << 'L';
} else
cout << "X";
}
tprev = t;
}
if (s != f) {
if (f > s) {
for (int i = 0; i < f - s; i++) cout << "R";
} else {
for (int i = 0; i < s - f; i++) cout << "L";
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[10], num[10];
const long long inf =
(long long)9 * 10000 * 10000 * 10000 * 10000 * 100 + (long long)10;
long long sum, ans = inf;
long long make(long long a, long long b, long long c, long long numa,
long long numb, long long numc) {
long long dif_ab, dif_ac, newc, newb;
dif_ab = numb - numa;
dif_ac = numc - numa;
newb = a + dif_ab;
newc = a + dif_ac;
if (newc < c) return inf;
if (newb < b) return inf;
return (a + newb + newc) - sum;
}
int main() {
cin >> a[1] >> a[2] >> a[3];
sum = a[1] + a[2] + a[3];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) {
num[1] = 0;
num[2] = 0;
num[3] = 0;
for (int t = 1; t <= 3; t++) {
if (t > i) num[t]++;
if (t <= j) num[t]++;
}
long long fr = make(a[1], a[2], a[3], num[1], num[2], num[3]);
ans = min(ans, fr);
long long sec = make(a[2], a[1], a[3], num[2], num[1], num[3]);
ans = min(ans, sec);
long long trd = make(a[3], a[1], a[2], num[3], num[1], num[2]);
ans = min(ans, trd);
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
vector<long long> adjlist[200010];
long long neigh[200010];
long long exists[200010];
void solve() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
exists[i] = 1;
adjlist[i].clear();
neigh[i] = 0;
}
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
adjlist[a].push_back(b);
neigh[a]++;
adjlist[b].push_back(a);
neigh[b]++;
}
if (k * (k - 1) / 2 > m) {
cout << "-1\n";
return;
}
queue<long long> q;
for (long long i = 1; i <= n; i++) {
sort(adjlist[i].begin(), adjlist[i].end());
if (neigh[i] < k - 1) q.push(i);
}
while (!q.empty()) {
long long x = q.front();
q.pop();
if (exists[x] == 0) continue;
exists[x] = 0;
for (auto i : adjlist[x])
if (exists[i]) {
neigh[i]--;
if (neigh[i] < k - 1) q.push(i);
}
}
for (long long i = 1; i <= n; i++) {
if (neigh[i] < k) q.push(i);
}
while (!q.empty()) {
long long cur = q.front();
q.pop();
if (exists[cur] == 0) continue;
exists[cur] = 0;
if (neigh[cur] == k - 1) {
bool canclique = true;
vector<long long> vv;
for (auto i : adjlist[cur])
if (exists[i]) {
vv.push_back(i);
}
for (long long i = 0; i < (long long)vv.size() and canclique; i++) {
for (long long j = i + 1; j < (long long)vv.size() and canclique; j++) {
if (!binary_search(adjlist[vv[i]].begin(), adjlist[vv[i]].end(),
vv[j]))
canclique = false;
}
}
if (canclique) {
cout << "2\n";
cout << cur << " ";
for (auto i : vv) {
cout << i << " ";
}
cout << "\n";
return;
}
}
for (auto i : adjlist[cur])
if (exists[i]) {
neigh[i]--;
if (neigh[i] < k) q.push(i);
}
}
vector<long long> ans;
for (long long i = 1; i <= n; i++)
if (exists[i]) {
ans.push_back(i);
}
if (ans.empty()) {
cout << "-1\n";
return;
} else {
cout << 1 << " " << ans.size() << "\n";
for (auto i : ans) {
cout << i << " ";
}
cout << "\n";
return;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510, MOD = 1e9 + 7;
int n, m;
char s[N][N];
int dp[2][N][N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int x1 = n; x1 >= 1; x1--) {
bool xx1 = x1 & 1;
for (int y1 = m; y1 >= 1; y1--) {
for (int x2 = 1; x2 <= n; x2++) {
int y2 = n - x2 + m - x1 - y1 + 2;
if (x1 > x2 || y1 > y2 || s[x1][y1] != s[x2][y2]) {
dp[xx1][y1][x2] = 0;
continue;
}
int ans = 0;
if (x1 == x2 && y1 == y2) {
ans = 1;
} else if (x1 == x2 && y1 + 1 == y2) {
ans = 1;
} else if (x1 + 1 == x2 && y1 == y2) {
ans = 1;
} else {
ans = (ans + dp[!xx1][y1][x2 - 1]) % MOD;
ans = (ans + dp[!xx1][y1][x2]) % MOD;
ans = (ans + dp[xx1][y1 + 1][x2 - 1]) % MOD;
ans = (ans + dp[xx1][y1 + 1][x2]) % MOD;
}
dp[xx1][y1][x2] = ans;
}
}
}
printf("%d\n", dp[1][1][n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1500 + 100;
int n, m;
char a[maxn][maxn];
bool mark[maxn][maxn];
pair<int, int> p[maxn][maxn];
bool yes;
void dfs(int x, int y, int ax, int ay) {
int xx = x, yy = y;
if (x == n) ax++;
if (y == m) ay++;
if (x == -1) ax--;
if (y == -1) ay--;
x = (x + n) % n, y = (y + m) % m;
if (a[x][y] == '#') return;
if (p[x][y].first != 7777) {
if (p[x][y].first != ax || p[x][y].second != ay) yes = 1;
return;
}
p[x][y].first = ax;
p[x][y].second = ay;
if (mark[x][y]) return;
mark[x][y] = 1;
dfs(x - 1, y, ax, ay);
dfs(x + 1, y, ax, ay);
dfs(x, y - 1, ax, ay);
dfs(x, y + 1, ax, ay);
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0, _n = (int)(n); i < _n; i++) cin >> a[i];
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
if (a[i][j] == 'S') x = i, y = j;
for (int i = 0, _n = (int)(n); i < _n; i++)
for (int j = 0, _n = (int)(m); j < _n; j++)
p[i][j].first = 7777, p[i][j].second = 7777;
dfs(x, y, 0, 0);
cout << (yes ? "YES" : "NO") << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
cin >> x >> y;
string ans;
for (int i = 0; i < x.size(); ++i) {
if (x[i] < y[i]) {
cout << -1 << '\n';
return 0;
}
}
cout << y << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int b[N];
long long a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n;
cin >> n;
int mx = 0;
for (int i = 0; i < n; ++i) cin >> b[i], mx = max(mx, b[i]);
for (int i = 0; i < n; ++i)
if (b[i] == mx && b[(n + i - 1) % n] < mx) {
if (!b[(n + i - 1) % n]) b[(n + i - 1) % n] = mx;
cout << "Yes" << '\n';
a[i] = b[i];
int j = (n + i - 1) % n;
while (j != i) {
a[j] = a[(j + 1) % n] + b[j];
j = (n + j - 1) % n;
}
for (int j = 0; j < n; ++j) cout << a[j] << ' ';
return 0;
}
if (mx == 0) {
cout << "Yes" << '\n';
for (int i = 0; i < n; ++i) cout << 1 << ' ';
return 0;
}
cout << "No";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long modd = 1000 * 1000 * 1000 + 7;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
};
int main() {
ios_base::sync_with_stdio(false);
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(0, modd);
int test_cases;
cin >> test_cases;
for (int t = (1); t < (1) + (test_cases); ++t) {
int n;
cin >> n;
map<char, int> freq;
int tot = 0;
for (int i = (0); i < (0) + (n); ++i) {
string s;
cin >> s;
tot += s.size();
for (char c : s) {
freq[c]++;
}
}
bool possible = true;
for (auto x : freq) {
if (x.second % n != 0) {
possible = false;
}
}
if (possible) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, c, a, b, d[1234567], e;
int main() {
cin >> a >> b;
for (i = 1; i <= a; i++) {
cin >> d[i];
}
long long ans = 0;
sort(d + 1, d + a + 1);
for (i = a; i >= 1; i--) {
ans += d[i];
if (ans >= b) {
cout << a - i + 1;
exit(0);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000080798150871LL;
string str[1111];
long long c[4111][4111];
long long maskk[8] = {};
int main() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
string b;
cin >> b;
string result(n, ' ');
for (int i = 0; i < b.size(); i++) {
if (b[i] == '1') {
for (int u = i; u < i + str.size(); u++) {
if (u == n || (result[u] != ' ' && result[u] != str[u - i])) {
cout << "No solution" << endl;
return 0;
}
result[u] = str[u - i];
}
}
}
for (int i = 0; i < result.size(); i++) {
if (result.substr(i, str.size()) == str && b[i] == '0') {
cout << "No solution" << endl;
return 0;
}
}
string was = result;
for (int i = 0; i < result.size(); i++) {
if (result[i] == ' ') {
result[i] = rand() % k + 'a';
}
}
for (int e = 0; e < 1111; e++) {
bool can = true;
for (int i = 0; i < result.size(); i++) {
if (result.substr(i, str.size()) == str && b[i] == '0') {
for (int t = i; t < i + str.size(); t++) {
if (was[t] == ' ') {
result[t]++;
if (result[t] > 'a' + k - 1) result[t] = 'a';
break;
}
}
can = false;
break;
}
}
if (can) {
cout << result << endl;
return 0;
}
}
cout << "No solution" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MX1 = 1e5 + 5;
const int MX2 = 1e6 + 5;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b % 2) res = (res * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return res;
}
long long int mmi(long long int a) { return power(a, mod - 2); }
long long int cntbit(long long int n) {
long long int cnt = 0;
while (n) {
n &= (n - 1);
cnt++;
}
return cnt;
}
long long int a, b, yl, gr, bl;
void solve() {
cin >> a >> b;
cin >> yl >> gr >> bl;
long long int x = 2 * yl + gr;
long long int y = 3 * bl + gr;
x = max(0LL, x - a);
y = max(0LL, y - b);
cout << x + y;
}
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long p[105], ans = 0;
struct note {
long long k, c;
} a[105];
bool cmp(const note i, const note j) { return i.c < j.c; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].k >> a[i].c;
sort(a, a + n, cmp);
cin >> m;
for (int i = 0; i < m; i++) cin >> p[i];
p[m] = 1000000000000000ll;
long long i = 0, j = 0, x = 0;
while (i < n && j <= m) {
if (p[j] - x <= a[i].k) {
long long z = p[j] - x;
a[i].k -= z;
x = p[j];
ans += z * a[i].c * (j + 1);
j++;
if (!a[i].k) i++;
} else {
long long z = a[i].k;
x += z;
ans += z * a[i].c * (j + 1);
i++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
void solution();
int main() {
ios_base::sync_with_stdio(false);
solution();
return EXIT_SUCCESS;
}
void solution() {
int n, k, ans = 0;
cin >> n >> k;
--k;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
v[i].second *= -1;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
if (v[i] == v[k]) {
++ans;
}
}
cout << ans << endl;
return;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int M, P;
long long T;
int A[22][22];
int R[22][22];
int TMP[22][22];
int ncr[22][22];
int X[1 << 20];
int B[22];
int mmul(int x, int y) { return (1ll * x * y) % P; }
void madd(int& x, int y) {
x += y;
if (x >= P) x -= P;
}
void matmul(int X[22][22], int Y[22][22], int Z[22][22]) {
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= M; j++) {
X[i][j] = 0;
for (int k = 0; k <= M; k++) {
madd(X[i][j], mmul(Y[i][k], Z[k][j]));
}
}
}
}
void solve(int x, int pos, vector<int>& V) {
if (pos == 0) {
X[x] = 0;
for (int i = 0; i <= M; i++) {
madd(X[x], mmul(B[i], V[i]));
}
return;
}
pos--;
int sz = M - pos;
int flp = 1 << pos;
for (int i = 0; i < 2 * flp; i += flp) {
vector<int> NV((sz + 1) * flp);
for (int j = 0; j < sz; j++) {
for (int k = 0; k < flp; k++) {
madd(NV[j * flp + k], V[j * (flp * 2) + i + k]);
madd(NV[(j + 1) * flp + k], V[j * (flp * 2) + (flp - i) + k]);
}
}
solve(x | i, pos, NV);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> M >> T >> P;
for (int i = 0; i < 1 << M; i++) {
cin >> X[i];
X[i] %= P;
}
for (int i = 0; i <= M; i++) {
cin >> B[i];
B[i] %= P;
}
for (int i = ncr[0][0] = 1; i < 22; i++) {
for (int j = ncr[i][0] = ncr[i][i] = 1; j < i; j++) {
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % P;
}
}
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= M; j++) {
R[i][j] = i == j ? 1 : 0;
for (int k = 0; k <= i && k <= j; k++) {
int v = mmul(ncr[i][k], ncr[M - i][j - k]);
v = mmul(v, B[i + j - 2 * k]);
A[i][j] = (A[i][j] + v) % P;
}
}
}
for (int i = 63 - __builtin_clzll(T); i >= 0; i--) {
matmul(TMP, R, R);
memcpy(R, TMP, sizeof(R));
if (T & 1LL << i) {
matmul(TMP, R, A);
memcpy(R, TMP, sizeof(R));
}
}
for (int i = 0; i <= M; i++) {
B[i] = R[i][0];
}
vector<int> V(X, X + (1 << M));
solve(0, M, V);
for (int i = 0; i < 1 << M; i++) {
cout << X[i] << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct vec {
long double x, y;
bool operator==(const vec &a) const { return x == a.x && y == a.y; }
bool operator<(const vec &a) const {
if (a.x != x) return x < a.x;
return y < a.y;
}
vec operator+(const vec &a) const { return {x + a.x, y + a.y}; }
vec operator*(const long double &a) const { return {x * a, y * a}; }
vec operator-(const vec &a) const { return {x - a.x, y - a.y}; }
vec operator/(const long double &a) const { return {x / a, y / a}; }
long double len() const { return sqrt(x * x + y * y); }
long double dot(const vec &a) const { return x * a.x + y * a.y; }
long double crs(const vec &a) const { return x * a.y - y * a.x; }
vec proj(const vec &a) const {
return (a / a.len()) * (*this).dot(a) / a.len();
}
};
struct P {
long long x, y;
bool operator<(const P &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
}
};
bool as(P a, P b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
long long x, y, z, mod = 1000000007;
vector<int> v[203010], v1;
int i, n, m, k, a, d, b, c, dx[10] = {1, 0, -1, 0}, dy[10] = {0, 1, 0, -1};
int e[33][33][2];
int o[31][33];
int l[1203001];
int par[211001];
int j[31];
set<P> s;
queue<int> q, q1;
long long u[201101];
char r[31][33];
map<int, int> p;
int f(int n) {
if (n == (1 << a) - 1) return 0;
if (l[n] >= 0) return l[n];
l[n] = 987654321;
for (int p = 1, i = 1;; p *= 2, i++)
if ((p & n) == 0) {
l[n] = f(n + p) + j[i];
for (int t = 1; t <= b; t++)
l[n] = min(f(n | e[i][t][1]) + e[i][t][0], l[n]);
break;
}
return l[n];
}
int main() {
memset(l, -1, sizeof(l));
scanf("%d %d", &a, &b);
for (int t = 1; t <= a; t++) scanf("%s", r[t] + 1);
for (int t = 1; t <= a; t++) {
for (int w = 1; w <= b; w++) {
for (int i = 1; i <= a; i++)
if (i != t && r[t][w] == r[i][w]) goto qwe;
d += (1 << (t - 1));
break;
qwe:;
}
}
for (int t = 1; t <= a; t++) {
for (int w = 1; w <= b; w++) scanf("%d", &o[t][w]);
j[t] = 987654321;
for (int w = 1; w <= b; w++) j[t] = min(j[t], o[t][w]);
}
for (int t = 1; t <= a; t++) {
for (int w = 1; w <= b; w++) {
int k = 0;
for (int i = 1; i <= a; i++)
if (r[i][w] == r[t][w])
k = max(k, o[i][w]), e[t][w][0] += o[i][w],
e[t][w][1] ^= (1 << (i - 1));
e[t][w][0] -= k;
}
}
printf("%d", f(d));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long gett(long long span, long long cuts) {
if (cuts <= 0) return span;
++cuts;
if (cuts > span) return -1;
return span / cuts;
}
long long solve() {
if (n - 1 + m - 1 < k) return -1;
long long res = 0;
for (long long i = 0; i <= 40000; i++)
res = max(res, n / (i + 1) * gett(m, k - i));
long long cdo;
for (long long i = 1; i <= 40000 && i <= n; i++) {
cdo = n / i - 1;
res = max(res, i * gett(m, k - cdo));
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
cout << solve() << endl;
cin.get();
cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100002];
int main() {
int n;
cin >> n;
bool flag = false;
int MAX = min(n, 2), ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i > 1 && a[i] == a[i - 1] + a[i - 2]) {
if (!flag) ans += 2;
flag = true;
ans++;
} else {
MAX = max(MAX, ans);
ans = 0;
flag = false;
}
}
cout << max(ans, MAX) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[200100], b[200100];
int main() {
int i, cnt, ans;
long long sum, t, z;
scanf("%d%d", &n, &k);
n++;
for (i = 0; i < (n); i++) scanf("%I64d", &a[i]);
sum = 0ll;
cnt = 0;
for (i = 0; i < (n); i++) {
sum += a[i];
b[i] = sum;
if (sum % 2 != 0) break;
sum /= 2;
cnt++;
}
sum = 0ll;
ans = 0;
for (i = n - 1; i >= 0; i--) {
if (i <= cnt) {
t = sum * 2 + b[i];
z = a[i] - t;
if (z >= -k && z <= k && (i != n - 1 || z != 0)) ans++;
}
sum = sum * 2 + a[i];
if (sum < -1000000000000000000ll || sum > 1000000000000000000ll) break;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ad;
string address;
cin >> ad;
if (ad[0] == 'h') {
address = "http://";
ad = ad.substr(4, ad.npos);
} else {
address = "ftp://";
ad = ad.substr(3, ad.npos);
}
int posru = ad.find("ru", 1);
address += ad.substr(0, posru) + ".ru";
ad = ad.substr(posru + 2, ad.npos);
if (ad.length()) address += "/" + ad;
cout << address;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
const int N = 15, inf = 1e9;
int _, n, a[N + 1], sum[1 << N], f[N + 1][1 << N][N + 1], id[N + 1];
pii p[N + 1][1 << N][N + 1];
signed main() {
for (scanf("%d", &_); _; _--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int msk = 1; msk < 1 << n; msk++)
sum[msk] = sum[msk ^ (msk & -msk)] + a[__builtin_ffs(msk)];
for (int i = 0; i <= n; i++)
for (int msk = 0; msk < 1 << n; msk++)
for (int j = 0; j <= n; j++) f[i][msk][j] = inf;
f[0][0][0] = 0;
for (int i = 0; i < n; i++)
for (int msk = 0; msk < 1 << n; msk++)
for (int j = 0; j < n; j++)
if (f[i][msk][j] != inf) {
int rmsk = msk ^ ((1 << n) - 1);
for (int nmsk = rmsk; nmsk; nmsk = (nmsk - 1) & rmsk) {
if (sum[nmsk] <= f[i][msk][j] || !(nmsk >> j)) continue;
int k = j + __builtin_ffs(nmsk >> j);
if (f[i + 1][msk | nmsk][k] > sum[nmsk]) {
f[i + 1][msk | nmsk][k] = sum[nmsk];
p[i + 1][msk | nmsk][k] = make_pair(msk, j);
}
}
}
int ai, aj;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
if (f[i][(1 << n) - 1][j] != inf) ai = i, aj = j;
vector<pii> ans;
for (int i = 0; i < n; i++) id[i] = i + 1;
for (int i = ai, msk = (1 << n) - 1, j = aj; i; i--) {
int pmsk = p[i][msk][j].first, pj = p[i][msk][j].second;
for (int bt = 0; bt < n; bt++)
if (((msk ^ pmsk) >> bt & 1) && bt != j - 1)
ans.push_back(make_pair(bt, j - 1));
msk = pmsk, j = pj;
}
printf("%d\n", ans.size());
for (pii i : ans) {
printf("%d %d\n", id[i.first], id[i.second]);
id[i.first] = -1;
for (int j = i.first; j < n; j++)
if (id[j] != -1) id[j]--;
}
}
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, ans;
cin >> n >> a >> b;
ans = ((a + b) % n + n) % n;
if (ans == 0) ans = n;
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 100005;
int n;
long long k;
int a[N], arr[N], top = 0;
long long inv[N];
struct T1 {
int C[N];
void update(int x, int num) {
while (x) {
C[x] += num;
x -= (x & (-x));
}
}
int query(int x) {
int ans = 0;
while (x <= top) {
ans += C[x];
x += (x & (-x));
}
return ans;
}
} S;
struct T2 {
int C[N];
void update(int x, int num) {
while (x <= top) {
C[x] += num;
x += (x & (-x));
}
}
int query(int x) {
int ans = 0;
while (x) {
ans += C[x];
x -= (x & (-x));
}
return ans;
}
} T;
void init() {
read(n);
read(k);
for (int i = 1; i <= n; ++i) read(a[i]), arr[++top] = a[i];
sort(arr + 1, arr + top + 1);
top = unique(arr + 1, arr + top + 1) - arr - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(arr + 1, arr + top + 1, a[i]) - arr;
}
void solve() {
long long ans = 0, tot = 0;
for (int i = n; i >= 1; --i) {
tot += T.query(a[i] - 1);
T.update(a[i], 1);
}
for (int l = 1, r = 1; l < n; ++l) {
if (l == r) {
tot -= S.query(a[r] + 1);
T.update(a[r], -1);
tot -= T.query(a[r] - 1);
++r;
}
tot += S.query(a[l] + 1);
tot += T.query(a[l] - 1);
S.update(a[l], 1);
while (tot > k && r <= n) {
tot -= S.query(a[r] + 1);
T.update(a[r], -1);
tot -= T.query(a[r] - 1);
++r;
}
ans += n - r + 1;
}
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, l, r;
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &k);
l = 1, r = n * m;
while (l <= r) {
long long chk = 0ll, t = (l + r) / 2ll;
for (int i = 1; i <= n; i++) chk += min(t / i, m);
if (chk >= k)
r = t - 1ll;
else
l = t + 1ll;
}
printf("%I64d", l);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char sl = '\n';
int power(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = ret * a;
a = a * a;
b >>= 1;
}
return ret;
}
int ans[100001 + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
long long ans1(0);
while (n--) {
int x;
map<int, int> tmp;
cin >> x;
for (int i = 2; i * i <= x; ++i) {
while (!(x % i)) {
tmp[i]++;
tmp[i] %= k;
x /= i;
}
}
if (x > 1) tmp[x]++;
long long number = 1LL;
long long other = 1LL;
for (auto i : tmp) {
if (i.second) {
number = number * power(i.first, i.second);
for (int j = 0; j < (k - i.second) && other <= (1LL * 100001 + 1); j++)
other *= i.first;
}
}
if (other < 100001) ans1 += ans[other];
ans[number]++;
}
cout << ans1 << sl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, k1, k2;
cin >> n >> k1 >> k2;
bool flag = false;
for (long long i = 0; i < k1; i++) {
long long x;
cin >> x;
if (x == n) {
flag = true;
}
}
for (long long i = 0; i < k2; i++) {
long long x;
cin >> x;
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long l3[3][100005];
int main() {
long long n;
cin >> n;
long long l1[n + 1], l2[n + 1];
map<long long, long long> mp, mp2;
vector<long long> v;
for (int i = 1; i <= n; i++) {
cin >> l1[i] >> l2[i];
mp[l1[i]] = 1;
mp[l2[i]] = 2;
mp2[l1[i]] = i;
mp2[l2[i]] = i;
v.push_back(l1[i]);
v.push_back(l2[i]);
if (i <= n / 2) {
l3[1][i] = 1;
l3[2][i] = 1;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() && i < n; i++) {
if (mp[v[i]] == 1)
l3[1][mp2[v[i]]] = 1;
else
l3[2][mp2[v[i]]] = 1;
}
for (int i = 1; i <= n; i++) cout << l3[1][i];
cout << endl;
for (int i = 1; i <= n; i++) cout << l3[2][i];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[10][50];
int main() {
int n = 6, m = 26, i, j, k;
for (i = 1; i <= n; i++) a[i][1] = a[i][m] = '|';
for (i = 1; i <= m; i++) a[1][i] = a[n][i] = '-';
a[1][1] = a[1][m] = a[n][1] = a[n][m] = '+';
for (i = 2; i < n; i++)
for (j = 2; j < m; j++) a[i][j] = '.';
a[2][m - 1] = 'D';
a[2][m - 2] = a[3][m - 2] = a[5][m - 2] = '|';
cin >> k;
for (j = 2; j < m - 2; j += 2)
for (i = 2; i < n; i++) {
if (j > 2 && i == 4) continue;
if (k > 0)
a[i][j] = 'O';
else
a[i][j] = '#';
k--;
}
for (i = 1; i <= n; i++, cout << "\n") {
for (j = 1; j <= m; j++) cout << a[i][j];
if (i == 2 || i == 5) cout << ")";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int a;
scanf("%d", &a);
return a;
}
int main() {
int t, test = 0;
cin >> t;
while (t--) {
string a, b, c;
cin >> a >> b >> c;
int cheak = 1;
for (int i = 0; i < a.length(); i++) {
if (a[i] == c[i] || b[i] == c[i])
continue;
else {
cheak = 0;
break;
}
}
if (cheak)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroint-loops")
using namespace std;
const int N = 1000090, M = 1000000007;
int B[N];
void up(int i, int v) {
for (; i <= N; i += (i & (-i))) B[i] += v;
}
int n;
int flift(int x) {
int lft = 0, sum = 0;
for (int i = 19; i >= 0; i--) {
int idx = (lft + (1 << i));
if (idx < N and sum + B[idx] < x) {
sum += B[idx];
lft += (1 << i);
}
}
return lft + 1;
}
int main(void) {
int q, x;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%d", &x), up(x, 1);
for (int Q = 0; Q < q; ++Q) {
scanf("%d", &x);
if (x > 0)
up(x, 1), n++;
else {
x = -1 * x, n--;
int p = flift(x);
up(p, -1);
}
}
int ans = flift(1);
if (ans > n + q)
puts("0");
else
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
vector<int> r, m;
int rc[7001], mc[7001];
int mov(int p, int s) {
int np = p + s;
if (np > n) np -= n;
return np;
}
int main() {
fill(rc, rc + 7001, -1);
fill(mc, mc + 7001, -1);
cin >> n;
cin >> k;
while (k--) {
cin >> x;
r.push_back(x);
}
cin >> k;
while (k--) {
cin >> x;
m.push_back(x);
}
rc[1] = mc[1] = 0;
bool change = true;
bool lf, uf;
while (change) {
change = false;
for (int i = n; i > 1; i--) {
if (mc[i] == -1) {
lf = uf = false;
for (int j = 0; j < m.size(); j++) {
int np = mov(i, m[j]);
if (rc[np] == 0)
lf = true;
else if (rc[np] == -1)
uf = true;
}
if (lf)
mc[i] = 1, change = true;
else if (!uf)
mc[i] = 0, change = true;
}
if (rc[i] == -1) {
lf = uf = false;
for (int j = 0; j < r.size(); j++) {
int np = mov(i, r[j]);
if (mc[np] == 0)
lf = true;
else if (mc[np] == -1)
uf = true;
}
if (lf)
rc[i] = 1, change = true;
else if (!uf)
rc[i] = 0, change = true;
}
}
}
for (int i = 2; i <= n; i++) {
if (i != 2) printf(" ");
if (rc[i] == 0)
printf("Lose");
else if (rc[i] == -1)
printf("Loop");
else
printf("Win");
}
puts("");
for (int i = 2; i <= n; i++) {
if (i != 2) printf(" ");
if (mc[i] == 0)
printf("Lose");
else if (mc[i] == -1)
printf("Loop");
else
printf("Win");
}
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char* sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
struct node {
node *l, *r, *p;
long long val, size, pier, ost;
bool flip;
node(long long _val)
: l(0), r(0), p(0), val(_val), size(1), pier(_val), ost(_val), flip(0) {}
void update() {
touch();
size = 1;
pier = val;
ost = val;
if (l) {
size += l->size;
if (l->pier != -1) pier = l->pier;
}
if (r) {
size += r->size;
if (pier == -1) {
pier = r->pier;
}
if (r->ost != -1) ost = r->ost;
}
if (l && ost == -1) {
ost = l->ost;
}
}
void touch() {
if (flip) {
swap(l, r);
if (l) l->reverse();
if (r) r->reverse();
flip = 0;
}
}
void touch_path() {
if (p) p->touch_path();
touch();
}
node*& get_child(bool right) { return right ? r : l; }
static void add_child(node* x, node* q, bool right) {
if (x) x->get_child(right) = q;
if (q) q->p = x;
}
inline bool is_right() { return p && p->r == this; }
void rotate() {
if (!p) return;
node* oldp = p;
bool right = is_right();
add_child(p->p, this, p->is_right());
add_child(oldp, get_child(!right), right);
add_child(this, oldp, !right);
oldp->update();
update();
}
void splay_() {
while (p) {
if (is_right() ^ p->is_right())
rotate();
else
p->rotate();
rotate();
}
}
void splay() {
touch_path();
splay_();
}
void set_val(long long nval) {
val = nval;
update();
}
void reverse() {
swap(pier, ost);
flip = !flip;
}
node* get_first() {
node* res = this;
while (1) {
res->touch();
if (!res->l) break;
res = res->l;
}
res->splay_();
return res;
}
node* remove() {
if (l) l->p = nullptr;
if (r) r->p = nullptr;
node* root = join(l, r);
l = r = nullptr;
return root;
}
static node* join(node* a, node* b) {
if (!a) return b;
while (1) {
a->touch();
if (!a->r) break;
a = a->r;
}
a->splay_();
add_child(a, b, true);
a->update();
return a;
}
node* get_kth(long long k) {
assert(size > k);
node* res = this;
while (1) {
res->touch();
if (res->l) {
if (res->l->size > k) {
res = res->l;
continue;
} else
k -= res->l->size;
}
if (k == 0) {
res->splay_();
return res;
}
k--;
res = res->r;
}
}
pair<node*, node*> split(long long k) {
if (k == 0) return {nullptr, this};
if (k >= size) return {this, nullptr};
node* x = get_kth(k);
node* res = x->l;
x->l->p = nullptr;
x->l = nullptr;
x->update();
return {res, x};
}
};
struct LCnode : node {
LCnode(long long _val) : node(_val){};
void LCsplay() {
node* ak = this;
node* par = ak->p;
while (par && (par->l == ak || par->r == ak)) {
ak = par;
par = ak->p;
}
ak->p = nullptr;
splay();
p = par;
}
void access() {
node* right = nullptr;
LCnode* cur = this;
while (cur) {
cur->LCsplay();
cur->r = right;
cur->update();
right = cur;
cur = (LCnode*)cur->p;
}
splay();
}
void to_root() {
access();
reverse();
touch();
}
void link(LCnode* par) {
to_root();
p = par;
}
void get_path(LCnode* v) {
v->to_root();
access();
}
void cut(LCnode* v) {
get_path(v);
v->p = l = nullptr;
update();
}
bool connected(LCnode* v) {
get_path(v);
return get_first() == v;
}
~LCnode() { l = r = nullptr; };
};
long long n;
vector<vector<long long>> d;
vector<vector<long long>> res;
vector<LCnode*> t, c;
vector<long long> a, b;
void dfs(long long v, long long oj) {
for (long long el : d[v])
if (el != oj) {
dfs(el, v);
}
if (oj != -1) {
t[v]->get_path(t[oj]);
long long id = t[v]->ost;
res.push_back({v, oj, a[id], b[id]});
c[id]->cut(t[a[id]]);
t[b[id]]->cut(c[id]);
t[v]->link(t[oj]);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> n;
d.resize(n);
t.resize(n);
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++) {
long long aa, bb;
cin >> aa >> bb;
aa--;
bb--;
d[aa].push_back(bb);
d[bb].push_back(aa);
}
for (long long i = (0); i <= ((long long)(n)-1); i++) {
t[i] = new LCnode(-1);
}
a.resize(n - 1);
b.resize(n - 1);
c.resize(n - 1);
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
c[i] = new LCnode(i);
c[i]->link(t[a[i]]);
c[i]->link(t[b[i]]);
}
dfs(0, -1);
cout << n - 1 << "\n";
for (auto el : res) {
for (long long pom : el) cout << pom + 1 << " ";
cout << "\n";
}
for (long long i = (0); i <= ((long long)(n)-1); i++) delete t[i];
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++) delete c[i];
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
const double PI = 3.14159265359;
const double eps = 1e-7;
long long add(long long x, long long y, long long M = MOD) {
return (x + y + 2 * M) % M;
}
long long mult(long long x, long long y, long long M = MOD) {
return (add(x, 0, M) * add(y, 0, M)) % M;
}
long long fast_expo(long long x, long long y, long long M = MOD) {
if (x == 0) return 0;
if (y == 0) return 1;
long long res = 1;
long long mid = fast_expo(x, y / 2, M);
if (y % 2 != 0) res = x;
return mult(mult(mid, mid, M), res, M);
}
long long inver(long long x, long long M = MOD) { return fast_expo(x, M - 2); }
long long gcd(long long e1, long long e2) {
if (e2 == 0) return e1;
return gcd(e2, e1 % e2);
}
const int TAM = 2000 + 5;
int n, m;
int a[TAM][TAM];
int t[TAM];
bool detectRow(int i) {
bool ok = true;
for (int j = 0; j < m; j++) {
if (t[j] - a[i][j] <= 0) return false;
}
return true;
}
int main() {
string s;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
a[i][j] = s[j] - '0';
t[j] += s[j] - '0';
}
}
bool ok = false;
for (int i = 0; i < n; i++) ok = ok or detectRow(i);
if (ok)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long mx = a[n - 1];
b[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (a[i] <= mx)
b[i] = mx + 1 - a[i];
else
b[i] = 0;
mx = max(a[i], mx);
}
for (int i = 0; i < n; i++) {
cout << b[i] << ' ';
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4,avx2,abm,fma,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long INF = 0x3f3f3f3f;
long long inf = pow(10, 18);
long long modulo = 998244353;
void deal() {
long long t;
cin >> t;
for (long long l = 0; l < t; l++) {
long long n, m;
cin >> n >> m;
vector<vector<long long> > arr(n, vector<long long>(2));
vector<vector<long long> > took(n, vector<long long>(2, 0));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 2; j++) {
cin >> arr[i][j];
}
}
vector<long long> s(2, 0);
for (long long i = 0; i < n; i++) {
long long cr = m;
for (long long j = 0; j < 2; j++) {
long long mn = min(cr, arr[i][j]);
took[i][j] = mn;
cr -= mn;
s[j] += arr[i][j] - mn;
}
}
for (long long i = 0; i < n; i++) {
if (s[1] > s[0]) {
long long dif = (s[1] - s[0]) / 2;
long long mn = min({dif, took[i][0], arr[i][1] - took[i][1]});
took[i][0] -= mn;
took[i][1] += mn;
s[1] -= mn;
s[0] += mn;
}
}
cout << abs(s[0] - s[1]) << '\n';
for (long long i = 0; i < n; i++) {
cout << took[i][0] << ' ' << took[i][1] << '\n';
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
deal();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long const oo = 1000000007, e5 = 100007;
long long N;
long long factorial[25];
void __init__() {
factorial[0] = 1;
for (long long i = 1; i < 25; i++) {
factorial[i] = factorial[i - 1] * i;
}
}
long long solve(long long num) {
long long resutl = 1, biggestDividend;
long long overCounted = 0;
long long remaindersCountOf[25];
long long accumulateRemaindersCountTo[25];
long long cpyOfNum = num;
for (long long i = 0; i < 25; i++) {
remaindersCountOf[i] = 0;
}
for (long long i = 2; i < 25; i++) {
++remaindersCountOf[num % i];
num /= i;
biggestDividend = i;
if (num == 0) break;
}
accumulateRemaindersCountTo[0] = remaindersCountOf[0];
for (long long i = 1; i < 25; i++) {
accumulateRemaindersCountTo[i] =
accumulateRemaindersCountTo[i - 1] + remaindersCountOf[i];
}
for (long long i = 2; i < biggestDividend; i++) {
resutl *= (accumulateRemaindersCountTo[i - 1] + 2 - i);
}
for (long long i = 0; i < biggestDividend; i++) {
resutl /= factorial[remaindersCountOf[i]];
}
if (remaindersCountOf[0]) {
overCounted = 1;
for (long long i = 2; i < biggestDividend; i++) {
overCounted *= (accumulateRemaindersCountTo[i - 1] + 1 - i);
}
for (long long i = 1; i < biggestDividend; i++) {
overCounted /= factorial[remaindersCountOf[i]];
}
overCounted /= factorial[remaindersCountOf[0] - 1];
}
return resutl - overCounted - 1;
}
int main() {
long long num;
__init__();
cin >> N;
for (long long i = 0; i < N; i++) {
cin >> num;
cout << solve(num) << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[70][11][(1 << 10) + 5][2];
int d[70];
long long dfs(int pos, int base, int s, int lz, bool limit) {
if (pos == 0) return s == 0;
if (!limit && ~dp[pos][base][s][lz]) return dp[pos][base][s][lz];
long long ret = 0;
int up = limit ? d[pos] : base - 1;
for (int i = 0; i <= up; ++i) {
if (!lz || i || pos == 1)
ret += dfs(pos - 1, base, s ^ 1 << i, 0, limit && i == up);
else
ret += dfs(pos - 1, base, s, 1, limit && i == up);
}
if (!limit) dp[pos][base][s][lz] = ret;
return ret;
}
long long solve(long long x, int base) {
if (x == 0) return 0;
int cnt = 0;
while (x) {
d[++cnt] = x % base;
x /= base;
}
return dfs(cnt, base, 0, 1, true);
}
int main() {
memset(dp, -1, sizeof(dp));
int T;
scanf("%d", &T);
while (T--) {
int base;
long long l, r;
scanf("%d%I64d%I64d", &base, &l, &r);
printf("%I64d\n", solve(r, base) - solve(l - 1, base));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t, x, y, z,
mx, mn, s;
char c[1000009], d[1000009], ch;
struct point {
int num, pos;
} pp[1000009];
bool cmp(point a1, point a2) {
if (a1.num == a2.num) {
return a1.pos < a2.pos;
} else {
return a1.num < a2.num;
}
}
int main() {
while (scanf("%d", &n) != EOF) {
ans = 0;
x = -1;
for (i = 0; i < n; i++) {
scanf("%d", &pp[i].num);
pp[i].pos = i;
}
sort(pp, pp + n, cmp);
for (i = 0; i < n; i++) {
if (i > x) {
x = pp[i].pos;
ans++;
} else {
x = max(x, pp[i].pos);
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.