solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, candies = 0;
cin >> n;
long long int ar[n + 1], temp;
for (long long int i = 0; i <= n; i++) ar[i] = 0;
for (int i = 1; i <= n; i++) {
cin >> temp;
ar[temp]++;
}
sort(ar, ar + n + 1);
candies += ar[n];
long long int tem1;
tem1 = ar[n];
for (int i = n - 1; i > 0; i--) {
if (tem1 == 0 || ar[i] == 0) break;
if (tem1 > ar[i])
tem1 = ar[i];
else if (tem1 <= ar[i])
tem1 -= 1;
candies += tem1;
}
cout << candies << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long u, v;
cin >> u >> v;
if (u == 0 && v == 0) {
cout << 0;
return 0;
}
if (u == v) {
cout << "1\n" << u;
return 0;
}
if (u & 1 ^ v & 1 || u > v) {
cout << -1;
return 0;
}
long long mid = (v - u) / 2;
long long c = u + mid, d = mid;
if ((c ^ d) == u) {
cout << "2\n" << c << " " << d << "\n";
return 0;
}
cout << "3\n" << (v - u) / 2 << " " << (v - u) / 2 << " " << u;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
int bit[100009];
int mx[100009];
int main() {
int n;
cin >> n;
for (int i = 0; i <= n - 1; ++i) cin >> bit[i];
string m;
cin >> m;
int ans = 0;
for (int i = 0; i <= n - 1; ++i)
if (m[i] == '1') ans += bit[i];
mx[0] = max(0, bit[0]);
for (int i = 1; i <= n - 1; ++i) {
mx[i] = max(0, bit[i]) + mx[i - 1];
}
int have = 0;
for (int i = n - 1; i >= 0; --i) {
if (m[i] == '1') {
ans = max(ans, have + (i == 0 ? 0 : mx[i - 1]));
have += bit[i];
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 1024;
const int LEN = 21;
const int BASE = 1000000000;
const double EPS = 1e-7;
int n, m;
int A[MAX];
int B[MAX];
bool check(double x) {
for (int i = (0); i < (n); ++i) {
x -= (m + x) / A[i];
if (x < 0) return 0;
x -= (m + x) / B[i];
if (x < 0) return 0;
}
return 1;
}
int main() {
cin >> n >> m;
for (int i = (0); i < (n); ++i) cin >> A[i];
for (int i = (0); i < (n); ++i) cin >> B[i];
double l = 0, r = 1e+10;
for (int it = (0); it < (256); ++it) {
double m = (l + r) / 2;
if (check(m))
r = m;
else
l = m;
}
if (l > 2e+9)
cout << -1 << endl;
else
printf("%0.11f\n", l);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
set<int> s1;
int ctr = 0;
for (int i = 0; i < n; i++) {
int x = s1.size();
while (s1.size() != (x + 1)) {
s1.insert(arr[i]);
if (s1.size() != (x + 1)) {
ctr++;
arr[i]++;
}
}
}
cout << ctr;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, q, a[110000];
vector<pair<int, int> > Q[110000];
bool b[1 << 20];
vector<int> jj;
int ans[110000];
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= q; i++) {
int l, x;
cin >> l >> x;
Q[l].push_back(make_pair(x, i));
}
int aa = 1;
b[0] = 1;
jj.push_back(0);
for (int i = 1; i <= n; i++) {
if (b[a[i]]) {
aa *= 2;
aa %= mod;
} else {
int m = jj.size();
for (int j = 0; j < m; j++) {
jj.push_back(a[i] ^ jj[j]);
b[a[i] ^ jj[j]] = 1;
}
}
for (auto j = Q[i].begin(); j != Q[i].end(); j++) {
ans[(*j).second] = aa * b[(*j).first];
}
}
for (int i = 1; i <= q; i++) cout << ans[i] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, t;
bool pos[101] = {false}, more, map[101] = {false};
string s;
cin >> n >> k;
char ch;
for (i = 0; i < n; i++) {
cin >> ch;
if (ch == 'G') pos[i] = true;
if (ch == 'T') {
t = i;
map[i] = true;
}
if (ch == '.') map[i] = true;
}
more = true;
while (more == true) {
more = false;
for (i = 0; i < n; i++) {
if (pos[i] == true) {
if (i - k >= 0 && pos[i - k] == false && map[i - k] == true) {
pos[i - k] = true;
more = true;
}
if (i + k < n && pos[i + k] == false && map[i + k] == true) {
pos[i + k] = true;
}
}
}
}
if (pos[t] == true)
cout << "YES";
else
cout << "NO";
}
| 0 |
// #pragma GCC target ("avx,avx2")
// #include <bits/extc++.h>
#include <bits/stdc++.h>
#define f first
#define s second
using namespace std;
// using namespace __gnu_pbds;
typedef long long ll;
typedef long double ld;
//===============================
const int N = 2e5+5, mod = 1e9+7, len = 30;
int n, m, d[N], dp[N][2];
vector<int> adj[N];
void BFS()
{
queue<int> q;
q.push(0);
d[0] = 0;
int vis[N] = {};
while(!q.empty())
{
int u = q.front();
q.pop();
if(vis[u])
continue;
vis[u] = 1;
for(int v : adj[u])
q.push(v), d[v] = min(d[v], d[u]+1);
}
}
int sol(int u, int bit)
{
if(!u)
return 0;
int &ret = dp[u][bit];
if(~ret)
return ret;
ret = d[u];
for(int v : adj[u])
{
if(d[v] > d[u])
ret = min(ret, sol(v, bit));
else if(!bit)
ret = min(ret, sol(v, 1));
}
return ret;
}
void run_case()
{
cin >> n >> m;
for(int i=0; i<n; i++)
adj[i].clear();
for(int i=0; i<m; i++)
{
int x, y;
cin >> x >> y;
adj[x-1].push_back(y-1);
}
memset(dp, -1, sizeof dp);
memset(d, 0x3f3f3f3f, sizeof d);
BFS();
for(int i=0; i<n; i++)
cout << sol(i, 0) << " ";
cout << endl;
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie();
// #ifdef LOCAL
// freopen("in.txt", "rt", stdin);
// freopen("out.txt", "wt", stdout);
// #endif
int t;
cin >> t;
while(t--)
run_case();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
long long s = 0;
int n, a[200001];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
for (int i = 0; i < n; i++)
if (((double)(s - a[i]) / (n - 1)) == a[i]) v.push_back(i + 1);
int m = (signed)v.size();
cout << m << endl;
for (int i = 0; i < m; i++) cout << v[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char pole[8][8];
vector<int> mine[8][8];
int din[8][8];
string ans[2];
bool check(int x, int y, int step) {
if (x > 7 || y > 7 || x < 0 || y < 0)
return false;
else {
for (int i = 0; i < mine[x][y].size(); i++) {
if (step == mine[x][y][i] || step == mine[x][y][i] + 1) return false;
}
}
return true;
}
bool dfs(int x, int y, int step) {
if (mine[x][y].size() == 0 || mine[x][y][0] < step) return true;
bool h = false, f = false;
if (check(x - 1, y + 1, step + 1)) {
h = dfs(x - 1, y + 1, step + 1);
}
if (check(x - 1, y, step + 1)) {
if (h) f = true;
h = dfs(x - 1, y, step + 1);
}
if (check(x, y + 1, step + 1)) {
if (h) f = true;
h = dfs(x, y + 1, step + 1);
}
if (check(x + 1, y + 1, step + 1)) {
if (h) f = true;
h = dfs(x + 1, y + 1, step + 1);
}
if (check(x + 1, y - 1, step + 1)) {
if (h) f = true;
h = dfs(x + 1, y - 1, step + 1);
}
if (check(x - 1, y - 1, step + 1)) {
if (h) f = true;
h = dfs(x - 1, y - 1, step + 1);
}
if (check(x + 1, y, step + 1)) {
if (h) f = true;
h = dfs(x + 1, y, step + 1);
}
if (check(x, y - 1, step + 1)) {
if (h) f = true;
h = dfs(x, y - 1, step + 1);
}
if (check(x, y, step + 1)) {
if (h) f = true;
h = dfs(x, y, step + 1);
}
if (h || f) return true;
return false;
}
int main() {
ans[0] = "LOSE";
ans[1] = "WIN";
for (int i = 0; i < 8; i++) {
string str;
cin >> str;
for (int s = 0; s < str.length(); s++) pole[i][s] = str[s];
}
for (int i = 0; i < 8; i++) {
for (int s = 0; s < 8; s++) {
if (pole[i][s] == 'S') {
int k = 0;
for (int q = i; q < 8; q++) {
mine[q][s].push_back(k);
k++;
}
}
}
}
cout << ans[dfs(7, 0, 0)];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 3e5 + 10;
long long fen[maxn], ps[maxn], a[maxn];
int ind[maxn][4];
long long n, k;
long long get(int x) {
long long sum = 0;
for (; x > 0; x &= x - 1) {
sum += fen[x];
}
return sum;
}
void add(int x) {
for (x++; x < maxn - 3; x += (x & -x)) {
fen[x]++;
}
}
long long check(long long m) {
memset(fen, 0, sizeof(fen));
vector<pair<long long, pair<int, int>>> vec;
long long cnt = 0;
for (int i = 0; i <= n; i++) {
vec.push_back({ps[i], {i, 0}});
vec.push_back({ps[i] - m, {i, 1}});
}
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
long long j = vec[i].second.first, ty = vec[i].second.second;
ind[j][ty] = i;
}
for (int i = 0; i <= n; i++) {
cnt += get(ind[i][1]);
add(ind[i][0]);
}
return cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
ps[i + 1] = ps[i] + a[i];
}
long long l = -1e16, r = 1e16;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (check(mid) < k) {
r = mid;
} else {
l = mid;
}
}
cout << l;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> deg(n, -1);
vector<int> sum(n, -1);
list<int> dl;
for (int i = 0; i < n; i++) {
cin >> deg[i] >> sum[i];
if (deg[i] == 1 && deg[sum[i]] != 1) dl.push_back(i);
}
vector<pair<int, int> > vec;
while (!dl.empty()) {
int ind = *dl.begin();
dl.pop_front();
vec.push_back(make_pair(ind, sum[ind]));
deg[sum[ind]] -= 1;
sum[sum[ind]] ^= ind;
if (deg[sum[ind]] == 1 && deg[sum[sum[ind]]] != 1) dl.push_back(sum[ind]);
}
cout << vec.size() << endl;
for (int i = 0; i < vec.size(); i++)
cout << vec[i].first << " " << vec[i].second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class comp {
public:
bool operator()(pair<int, int> &a, pair<int, int> &b) {
return a.second > b.second;
}
};
int col[1000001] = {0};
bool ans[1000001];
int main() {
int n, a;
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a;
int na = 0, c;
priority_queue<pair<int, int>, vector<pair<int, int> >, comp> myQueue;
for (int i = 1; i <= 1000000; i++) {
ans[i] = true;
if (i == a) continue;
myQueue.push(make_pair(i, 0));
}
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == a) {
na++;
} else {
col[c]++;
myQueue.push(make_pair(c, col[c]));
}
while (!myQueue.empty()) {
pair<int, int> y = myQueue.top();
if (y.second >= na) break;
myQueue.pop();
if (col[y.first] != y.second) {
continue;
} else {
ans[y.first] = false;
}
}
}
for (int i = 1; i <= 1000000; i++) {
if (i == a) continue;
if (ans[i]) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MP = 2e5 + 10;
const int MN = 2000 + 10;
long long fac[MP], rev[MP], ans[MN];
pair<int, int> pts[MN];
long long powmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
long long newt(long long n, long long k) {
return fac[n] * rev[k] % MOD * rev[n - k] % MOD;
}
long long paths(int fr, int to) {
int h = pts[to].first - pts[fr].first;
int w = pts[to].second - pts[fr].second;
if (h < 0 || w < 0) return 0;
return newt(h + w, w);
}
int main() {
std::ios::sync_with_stdio(false);
fac[0] = 1;
for (int i = 1; i < MP; ++i) fac[i] = fac[i - 1] * i % MOD;
for (int i = 0; i < MP; ++i) rev[i] = powmod(fac[i], MOD - 2);
int h, w, n;
cin >> h >> w >> n;
for (int i = 1; i <= n; ++i) {
cin >> pts[i].first >> pts[i].second;
}
sort(pts + 1, pts + n + 1);
pts[0] = {1, 1};
pts[n + 1] = {h, w};
ans[0] = 1;
for (int i = 1; i <= n + 1; ++i) {
ans[i] = paths(0, i);
for (int j = 1; j < i; ++j) {
ans[i] = (ans[i] - ans[j] * paths(j, i)) % MOD;
}
}
cout << ((ans[n + 1] + MOD) % MOD) << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
pair<int, bool> solve(int u, int p) {
int i, res = 0, cnt = 1;
pair<int, bool> x;
for (i = 0; i < v[u].size(); i++) {
if (v[u][i] == p) continue;
x = solve(v[u][i], u);
if (x.second) {
res += x.first + 1;
} else {
res += x.first;
cnt++;
}
}
if (cnt % 2 == 0)
x.second = 1;
else
x.second = 0;
x.first = res;
return x;
}
int main() {
int n, i, x, y;
pair<int, bool> res;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
res = solve(1, -1);
if (res.second == 1)
cout << res.first << endl;
else
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct nd {
int l, r, id;
friend bool operator<(nd aa, nd bb) { return aa.r < bb.r; }
} a[200010];
priority_queue<nd> q;
int cmp(nd xx, nd yy) { return xx.l < yy.l; }
int n, k, c[200010], ans[200010];
int main() {
scanf("%d%d", &n, &k);
int mxr = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
c[a[i].l]++;
c[a[i].r + 1]--;
a[i].id = i;
mxr = max(mxr, a[i].r);
}
int j = 1, cnt = 0;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= mxr; i++) {
while (a[j].l <= i && j <= n) {
q.push(a[j]);
j++;
}
c[i] += c[i - 1];
while (c[i] > k) {
nd t = q.top();
q.pop();
c[i]--;
c[t.r + 1]++;
ans[++cnt] = t.id;
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s, k;
char curmax = 0;
int main() {
cin >> s;
int n = s.length();
for (int i = 0; i < s.length(); ++i) {
if (s[i] > curmax) curmax = s[i];
}
int point = 0;
for (int i = 0; i < s.length(); ++i)
if (s[i] == curmax) {
point = i;
cout << s[i];
}
for (char k = curmax - 1; (int)k > 96; --k)
for (int i = point; i < s.length(); ++i)
if (s[i] == k) {
point = i;
cout << s[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 1e5 + 5;
int n, x, y;
long long a[N], up[N], down[N];
vector<int> v[N];
void dfs(int root, int x) {
long long mx = 0, mn = 0;
for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++)
if (*it != root) {
dfs(x, *it);
mx = max(mx, up[*it]);
mn = min(mn, down[*it]);
}
long long t = mx + mn + a[x];
up[x] = mx;
down[x] = mn;
if (t > 0)
down[x] -= t;
else
up[x] -= t;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) cin >> a[i];
dfs(0, 1);
cout << up[1] - down[1] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string a, c;
int b, d, p;
int pos[110];
p = 0;
cin >> b >> d;
cin >> a;
cin >> c;
int t = 0, la, lc;
la = a.length();
lc = c.length();
int k = 0;
for (int i = 0; i < lc; i++) {
k = 0;
for (int j = 0; j < la; j++)
if (a[j] == c[(i + k) % lc]) k++;
pos[i] = k;
}
int sum = 0;
int j = 0;
for (int i = 0; i < b; i++) {
sum += pos[j];
j = (j + pos[j]) % lc;
}
sum /= lc;
p = sum / d;
cout << p << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[15] = {1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987};
int n, c;
cin >> n;
for (int i = 1; i <= n; i++) {
c = 0;
for (int j = 0; j < 15; j++) {
if (i == a[j]) {
c = 1;
break;
}
}
if (c == 1)
cout << "O";
else
cout << "o";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct pat {
int x, y;
pat(int x = 0, int y = 0) : x(x), y(y) {}
bool operator<(const pat &p) const { return x == p.x ? y < p.y : x < p.x; }
};
template <typename TP>
inline void read(TP &tar) {
TP ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret = ret * 10 + (ch - '0');
ch = getchar();
}
tar = ret * f;
}
namespace RKK {
const int N = 18, S = 1 << 17;
const int mo = 1000000007, inv2 = 500000004;
int bcnt(int x) { return __builtin_popcount(x); }
int lbit(int x) { return __builtin_ffs(x); }
int add(int a, const int &b) {
a += b;
if (a >= mo)
a -= mo;
else if (a < 0)
a += mo;
return a;
}
void doadd(int &a, const int &b) {
a += b;
if (a >= mo)
a -= mo;
else if (a < 0)
a += mo;
}
void fwtand(int *a, int len, int tp) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += i << 1)
for (int k = 0; k < i; k++) doadd(a[j + k], tp * a[j + k + i]);
}
void fwtor(int *a, int len, int tp) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += i << 1)
for (int k = 0; k < i; k++) doadd(a[j + k + i], tp * a[j + k]);
}
void fwtxor(int *a, int len, int tp) {
int x, y;
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j += i << 1)
for (int k = 0; k < i; k++) {
x = a[j + k], y = a[j + k + i];
a[j + k] = add(x, y), a[j + k + i] = add(x, -y);
if (tp == -1)
a[j + k] = (long long)a[j + k] * inv2 % mo,
a[j + k + i] = (long long)a[j + k + i] * inv2 % mo;
}
}
int n, mxlen = 1, mxlog, mxa, bc[S];
int f[N][S], g[S];
int a[S], b[S], c[S], fib[S];
int main() {
fib[0] = 0, fib[1] = 1;
for (int i = 2; i < S; i++) fib[i] = add(fib[i - 1], fib[i - 2]);
for (int i = 1; i < S; i++) bc[i] = bcnt(i);
read(n);
for (int i = 1, w; i <= n; i++)
read(w), mxa = max(mxa, w), f[bc[w]][w]++, a[w]++, doadd(b[w], fib[w]);
while (mxlen <= mxa) mxlen <<= 1, mxlog++;
for (int i = 0; i <= mxlog; i++) fwtor(f[i], mxlen, 1);
for (int i = 0; i <= mxlog; i++) {
memset(g, 0, mxlen * 4);
for (int j = 0; j <= i; j++)
for (int s = 0; s < mxlen; s++)
doadd(g[s], 1ll * f[j][s] * f[i - j][s] % mo);
fwtor(g, mxlen, -1);
for (int s = 0; s < mxlen; s++)
if (bc[s] == i) doadd(c[s], g[s]);
}
fwtxor(a, mxlen, 1);
for (int i = 0; i < mxlen; i++) a[i] = 1ll * a[i] * a[i] % mo;
fwtxor(a, mxlen, -1);
for (int i = 0; i < mxlen; i++) a[i] = 1ll * a[i] * fib[i] % mo;
for (int i = 0; i < mxlen; i++) c[i] = 1ll * c[i] * fib[i] % mo;
fwtand(a, mxlen, 1), fwtand(b, mxlen, 1), fwtand(c, mxlen, 1);
for (int i = 0; i < mxlen; i++) c[i] = 1ll * a[i] * b[i] % mo * c[i] % mo;
fwtand(c, mxlen, -1);
int ans = 0;
for (int i = 1; i < mxlen; i <<= 1) doadd(ans, c[i]);
printf("%d\n", ans);
return 0;
}
} // namespace RKK
int main() { return RKK::main(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << "," << a.second << ")";
}
template <class A>
ostream &operator<<(ostream &out, const vector<A> &a) {
for (const A &it : a) out << it << " ";
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
return in >> a.first >> a.second;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &i : a) in >> i;
return in;
}
ifstream cinn("in.txt");
ofstream coutt("out.txt");
long long poww(const long long &a, long long b,
const long long &m = 1000000007) {
if (b == 0) return 1;
long long first = poww(a, b / 2, m);
first = first * first % m;
if (b & 1) first = first * a % m;
return first;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long _sum(long long n) { return (n * (n + 1)) / 2; }
bool isPalindrome(string str) {
long long l = 0;
long long h = str.length() - 1;
while (h > l) {
if (str[l++] != str[h--]) {
return false;
}
}
return true;
}
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
long long distSq(pair<long long, long long> p, pair<long long, long long> q) {
return (p.first - q.first) * (p.first - q.first) +
(p.second - q.second) * (p.second - q.second);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, c, h, b, m, k, f, f2, t2, t3, i, j, ans, mnt, mxt, r, j1, j2;
cin >> t;
while (t--) {
cin >> n >> k;
string s;
cin >> s;
long long w = 0, ws = 0, l = 0;
vector<long long> loss;
for (i = 0; i < (long long)s.length(); i++) {
if (s[i] == 'W') {
w++;
if (i == 0 || s[i - 1] == 'L') ws++;
}
if (s[i] == 'L') {
l++;
if (i == 0 || s[i - 1] == 'W') loss.push_back(0);
loss.back()++;
}
}
if (k >= l) {
cout << 2 * n - 1 << '\n';
continue;
}
if (w == 0) {
if (k == 0)
cout << 0 << '\n';
else
cout << 2 * k - 1 << '\n';
continue;
}
w += k;
if (s[0] == 'L') loss[0] = 1e15;
if (s[n - 1] == 'L') loss.back() = 1e15;
sort((loss).begin(), (loss).end());
for (i = 0; i < loss.size(); i++) {
if (k < loss[i]) break;
k -= loss[i];
ws--;
}
cout << 2 * w - ws << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x;
int y;
};
struct PointPair {
Point p1;
Point p2;
PointPair(const Point p1, const Point p2) {
this->p1 = p1;
this->p2 = p2;
}
};
vector<PointPair> get_parallel_point_pairs(Point points[]) {
vector<PointPair> v;
for (int i = 0; i < 3 - 1; ++i)
for (int j = i + 1; j < 3; ++j) {
if (points[i].x == points[j].x || points[i].y == points[j].y) {
PointPair pair(points[i], points[j]);
v.push_back(pair);
}
}
return v;
}
int get_min_segment_number(Point points[]) {
vector<PointPair> v_point_pair = get_parallel_point_pairs(points);
int n_segment = -1;
switch (v_point_pair.size()) {
case 0:
n_segment = 3;
break;
case 3:
n_segment = 1;
break;
case 2:
n_segment = 2;
break;
case 1:
Point p1 = v_point_pair[0].p1;
Point p2 = v_point_pair[0].p2;
Point p3;
for (int i = 0; i < 3; ++i)
if ((points[i].x != p1.x || points[i].y != p1.y) &&
(points[i].x != p2.x || points[i].y != p2.y)) {
p3 = points[i];
break;
}
if (p1.y == p2.y) {
if (p3.x < p1.x && p3.x < p2.x || p3.x > p1.x && p3.x > p2.x)
n_segment = 2;
else
n_segment = 3;
} else {
if (p3.y < p1.y && p3.y < p2.y || p3.y > p1.y && p3.y > p2.y)
n_segment = 2;
else
n_segment = 3;
}
break;
}
return n_segment;
}
int main() {
Point points[3];
for (int i = 0; i < 3; ++i) cin >> points[i].x >> points[i].y;
int n_segment = get_min_segment_number(points);
cout << n_segment << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct student_marks {
int n;
vector<int> a;
};
int main() {
int n, l, r;
cin >> n >> l >> r;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int q = 1;
for (int i = 0; i < l - 1; i++)
if (a[i] != b[i]) {
q = 0;
break;
}
for (int i = r; i < n; i++)
if (a[i] != b[i]) {
q = 0;
break;
}
if (q == 1)
cout << "TRUTH";
else
cout << "LIE";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int oo = (int)1e9;
int frqp[30], frqs[30];
using namespace std;
vector<pair<int, int> > getFactors(int n) {
vector<pair<int, int> > res;
int d = 1;
for (int i = 2; i * i <= n; i += d, d = 2) {
if (n % i == 0) {
res.push_back(make_pair(i, 0));
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int main() {
string s, p;
cin >> s >> p;
int ps = (int)p.size();
int ss = (int)s.size();
if (ps > ss) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < ps; ++i) {
frqp[p[i] - 'a']++;
if (s[i] == '?')
frqs[26]++;
else
frqs[s[i] - 'a']++;
}
long long res = 0;
int idx = ps;
do {
int inv = 0;
for (int i = 0; i < 26; ++i) {
if (frqp[i] < frqs[i]) inv = 1;
}
if (!inv) {
res++;
}
if (idx >= ss) break;
if (s[idx - ps] == '?')
frqs[26]--;
else
frqs[s[idx - ps] - 'a']--;
if (s[idx] == '?')
frqs[26]++;
else
frqs[s[idx] - 'a']++;
} while (idx++ < ss);
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int NumberOfDragon, power;
cin >> power >> NumberOfDragon;
int i, count = 0;
pair<int, int> dragon[10000];
for (i = 0; i < NumberOfDragon; i++) {
cin >> dragon[i].first;
cin >> dragon[i].second;
}
sort(dragon, dragon + NumberOfDragon);
for (i = 0; i < NumberOfDragon; i++) {
if (power > dragon[i].first) {
power = power + dragon[i].second;
count++;
}
}
if (count == NumberOfDragon) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ch[400050][2], size[400050], rev[400050], fa[400050];
void update(int x) { size[x] = size[ch[x][0]] + size[ch[x][1]] + 1; }
void pushr(int x) { swap(ch[x][0], ch[x][1]), rev[x] ^= 1; }
void pushdown(int x) {
if (rev[x]) {
if (ch[x][0]) pushr(ch[x][0]);
if (ch[x][1]) pushr(ch[x][1]);
rev[x] = 0;
}
}
int nroot(int x) { return ch[fa[x]][0] == x || ch[fa[x]][1] == x; }
int get(int x) { return ch[fa[x]][1] == x; }
void rotate(int x) {
int f = fa[x], gf = fa[f], k = get(x);
if (nroot(f)) ch[gf][get(f)] = x;
fa[x] = gf;
if (ch[x][!k]) fa[ch[x][!k]] = f;
ch[f][k] = ch[x][!k];
ch[x][!k] = f, fa[f] = x;
update(f), update(x);
}
int sta[400050];
void splay(int x) {
int now = x, top = 0;
sta[++top] = now;
while (nroot(now)) sta[++top] = now = fa[now];
while (top) pushdown(sta[top--]);
while (nroot(x)) {
int f = fa[x];
if (nroot(f)) rotate(get(x) == get(f) ? f : x);
rotate(x);
}
update(x);
}
void access(int x) {
for (int y = 0; x; x = fa[y = x]) splay(x), ch[x][1] = y, pushdown(x);
}
int getroot(int x) {
access(x), splay(x);
for (; ch[x][0];) pushdown(x), x = ch[x][0];
splay(x);
return x;
}
void link(int x, int y) {
access(x);
fa[x] = y;
}
void cut(int x, int y) {
access(x), splay(y);
fa[x] = ch[y][1] = 0;
update(y);
}
int logg[400050], mi[400050][22], ma[400050][22], n, w, qq, a[400050],
ls[400050], ANS[400050], nxt[400050], vis[400050];
vector<int> ha[400050];
int getmi(int l, int r) {
int k = logg[r - l + 1];
return min(mi[l][k], mi[r - (1 << k) + 1][k]);
}
int getma(int l, int r) {
int k = logg[r - l + 1];
return max(ma[l][k], ma[r - (1 << k) + 1][k]);
}
int calc(int l, int r) { return getma(l, r) - getmi(l, r); }
struct Q {
int v, id;
} q[400050];
int cmp(Q x, Q y) { return x.v < y.v; }
int gnxt(int x, int k) {
int l = x, r = n + 1;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (calc(x, mid) > k)
r = mid;
else
l = mid;
}
return r;
}
int main() {
scanf("%d%d%d", &n, &w, &qq);
int blo = sqrt(n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) mi[i][0] = ma[i][0] = a[i], size[i] = 1;
logg[1] = 0;
for (int i = 2; i <= n; i++) logg[i] = logg[i >> 1] + 1;
mi[n + 1][0] = -1e9, ma[n + 1][0] = 1e9;
for (int j = 1; j <= 17; j++)
for (int i = 1; i <= n + 1; i++)
mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]),
ma[i][j] = max(ma[i][j - 1], ma[i + (1 << (j - 1))][j - 1]);
for (int i = 1; i <= qq; i++) {
scanf("%d", &q[i].v);
q[i].v = w - q[i].v;
q[i].id = i;
}
sort(q + 1, q + 1 + qq, cmp);
for (int i = 1; i <= qq; i++) ls[i] = q[i].v;
for (int i = 1; i <= n; i++) nxt[i] = i, ha[1].push_back(i);
for (int i = 1; i <= qq; i++) {
for (int ii = 0; ii < ha[i].size(); ii++) {
int pos = ha[i][ii], j = nxt[pos] + 1;
cut(pos, nxt[pos]);
while (j <= n && j - pos <= blo && calc(pos, j) <= q[i].v) j++;
if (j - pos > blo)
vis[pos] = 1;
else {
nxt[pos] = j;
link(pos, nxt[pos]);
int jj = lower_bound(ls + 1, ls + 1 + qq, calc(pos, nxt[pos])) - ls;
ha[jj].push_back(pos);
}
}
int gs = 0;
for (int j = 1; j <= n; j = gnxt(j, q[i].v)) {
if (!vis[j]) access(j), splay(j), gs += size[j] - 1, j = getroot(j);
if (j > n) break;
gs++;
}
ANS[q[i].id] = gs - 1;
}
for (int i = 1; i <= qq; i++) printf("%d\n", ANS[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
struct ufs {
int fa, siz, val;
} f[800010];
int find(int x) {
while (x != f[x].fa) x = f[x].fa;
return x;
}
int dis(int x) {
int d = 0;
while (x != f[x].fa) d ^= f[x].val, x = f[x].fa;
return d;
}
struct ufsstk {
int x, y;
ufs fx, fy;
} stk[800010];
int tp;
struct base {
int a[32];
void insert(int x) {
for (int i = 30; ~i; --i)
if (x & (1 << i)) {
if (a[i])
x ^= a[i];
else {
a[i] = x;
break;
}
}
}
int query(int s) {
for (int i = 30; ~i; --i)
if ((s ^ a[i]) < s) s ^= a[i];
return s;
}
} nul;
void unit(int x, int y, int w) {
w ^= dis(x) ^ dis(y);
x = find(x), y = find(y);
if (x == y) return;
if (f[x].siz < f[y].siz) std::swap(x, y);
stk[++tp] = (ufsstk){x, y, f[x], f[y]};
f[y].fa = x, f[y].val ^= w, f[x].siz += f[y].siz;
}
void undo() {
f[stk[tp].x] = stk[tp].fx, f[stk[tp].y] = stk[tp].fy;
tp--;
}
struct edge {
int x, y, w;
};
struct node {
int l, r;
std::vector<edge> p;
std::vector<edge> q;
} tr[800010];
void build(int o, int l, int r) {
tr[o].l = l, tr[o].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
}
void insp(int o, int l, int r, edge e) {
if (r < tr[o].l || tr[o].r < l) return;
if (l <= tr[o].l && tr[o].r <= r) return tr[o].p.push_back(e);
insp(o << 1, l, r, e), insp(o << 1 | 1, l, r, e);
}
void insq(int o, int v, edge q) {
if (v < tr[o].l || tr[o].r < v) return;
if (tr[o].l == tr[o].r) return tr[o].q.push_back(q);
insq(o << 1, v, q), insq(o << 1 | 1, v, q);
}
void solve(int o, base s) {
int beg = tp;
for (auto e : tr[o].p) {
if (find(e.x) != find(e.y))
unit(e.x, e.y, e.w);
else {
s.insert(dis(e.x) ^ dis(e.y) ^ e.w);
}
}
if (tr[o].l == tr[o].r) {
for (auto q : tr[o].q) printf("%d\n", s.query(dis(q.x) ^ dis(q.y)));
} else {
solve(o << 1, s);
solve(o << 1 | 1, s);
}
while (tp != beg) undo();
}
int n, m, q, id;
std::map<std::pair<int, int>, std::pair<int, int> > ha;
std::pair<int, int> ee[800010];
int tt;
std::map<std::pair<int, int>, bool> op;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ha[std::make_pair(u, v)] = std::make_pair(w, 0);
ee[++tt] = std::make_pair(u, v);
op[std::make_pair(u, v)] = 1;
}
scanf("%d", &q);
build(1, 0, q + 1);
for (int i = 1; i <= q; ++i) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ha[std::make_pair(u, v)] = std::make_pair(w, i);
ee[++tt] = std::make_pair(u, v);
op[std::make_pair(u, v)] = 1;
} else if (opt == 2) {
int u, v;
scanf("%d%d", &u, &v);
insp(1, ha[std::make_pair(u, v)].second, i,
(edge){u, v, ha[std::make_pair(u, v)].first});
op[std::make_pair(u, v)] = 0;
} else if (opt == 3) {
int u, v;
scanf("%d%d", &u, &v);
insq(1, i, (edge){u, v, 0});
}
}
for (int i = 0; i <= tt; ++i) {
if (op[ee[i]]) {
insp(1, ha[ee[i]].second, q + 1,
(edge){ee[i].first, ee[i].second, ha[ee[i]].first});
ha[ee[i]] = std::make_pair(0, 0);
}
}
for (int i = 1; i <= n; ++i) f[i] = (ufs){i, 1, 0};
solve(1, nul);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
struct node {
int xi;
int yi;
} a[N];
int n, m;
int c[N << 1];
struct th {
int maxx;
int minn;
};
th tl[N], tr[N];
int sum[N];
long long ans = 0;
inline bool cmp(node x, node y) { return x.xi < y.xi; }
inline int read() {
int v = 0, c = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') c = -1;
ch = getchar();
}
while (isdigit(ch)) {
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
inline void solve(int l, int r) {
if (l == r) {
ans++;
return;
}
int mid = (l + r) >> 1;
solve(l, mid);
solve(mid + 1, r);
tl[mid].maxx = tl[mid].minn = a[mid].yi;
for (int i = mid - 1; i >= l; --i) {
tl[i].maxx = max(tl[i + 1].maxx, a[i].yi);
tl[i].minn = min(tl[i + 1].minn, a[i].yi);
}
tr[mid + 1].maxx = tr[mid + 1].minn = a[mid + 1].yi;
for (int i = mid + 2; i <= r; ++i) {
tr[i].maxx = max(tr[i - 1].maxx, a[i].yi);
tr[i].minn = min(tr[i - 1].minn, a[i].yi);
}
for (int i = mid; i >= l; --i) {
int to = i + tl[i].maxx - tl[i].minn;
if (to <= mid || to > r) continue;
if (tr[to].maxx < tl[i].maxx && tr[to].minn > tl[i].minn) ans++;
}
for (int i = mid + 1; i <= r; ++i) {
int to = i - (tr[i].maxx - tr[i].minn);
if (to >= mid + 1 || to < l) continue;
if (tl[to].maxx < tr[i].maxx && tr[i].minn < tl[to].minn) ans++;
}
int ll = mid + 1, rr = mid + 1;
for (int i = mid; i >= l; --i) {
while (rr <= r && tr[rr].maxx < tl[i].maxx) c[rr + tr[rr].minn]++, ++rr;
while (ll < rr && tr[ll].minn > tl[i].minn) c[ll + tr[ll].minn]--, ++ll;
ans += c[i + tl[i].maxx];
}
for (int i = ll; i < rr; ++i) c[i + tr[i].minn]--;
ll = rr = mid;
for (int i = mid + 1; i <= r; ++i) {
while (ll >= l && tl[ll].maxx < tr[i].maxx) c[ll - tl[ll].minn + N]++, --ll;
while (rr > ll && tl[rr].minn > tr[i].minn) c[rr - tl[rr].minn + N]--, --rr;
ans += c[i - tr[i].maxx + N];
}
for (int i = rr; i > ll; --i) c[i - tl[i].minn + N]--;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i)
a[i].xi = read(), a[i].yi = read(), sum[a[i].xi] = a[i].yi;
for (int i = 1; i <= n; ++i) a[i].yi = sum[i];
solve(1, n);
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const long long INF = 1e15;
const long long MOD = 1e9 + 7;
const int N = 100005;
const int M = 600000;
long long all[4005], cnt[4005], C[4005][4005];
int main() {
for (int i = 0; i <= 4000; i++) C[i][0] = C[i][i] = 1;
for (int i = 2; i <= 4000; i++) {
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
all[0] = 1;
for (int i = 1; i <= 4000; i++) {
all[i] = all[i - 1];
for (int j = 0; j < i; j++) {
all[i] += C[i - 1][j] * all[i - 1 - j] % MOD;
all[i] %= MOD;
}
}
cnt[1] = 1;
cnt[2] = 3;
for (int i = 3; i <= 4000; i++) {
cnt[i] = 1;
for (int j = 1; j < i; j++) {
cnt[i] += C[i][j] * (all[i - j] - cnt[i - j]) % MOD;
cnt[i] %= MOD;
}
}
int n;
scanf("%d", &n);
cout << cnt[n] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 7, MAX_N = 2001;
long long dp[MAX_N][MAX_N];
int main() {
long long n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i <= n; i++) {
dp[1][i] = 1;
}
for (int i = 2; i <= k; i++) {
for (int j = 1; j <= n; j++) {
for (int p = 1; p * j <= n; p++) {
dp[i][j * p] += dp[i - 1][j];
dp[i][j * p] %= N;
}
}
}
for (int i = 1; i <= n; i++) {
ans += dp[k][i];
ans %= N;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, q;
long long ans[MAXN];
int a[MAXN];
long long pref[MAXN];
long long get(int l, int r) {
if (l == 0)
return pref[r];
else
return pref[r] - pref[l - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d", &n);
for (auto i = 0; i != n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (auto i = 0; i != n; i++) {
pref[i] = a[i];
if (i > 0) pref[i] += pref[i - 1];
}
if (n == 1) ans[0] = 0;
for (auto i = 1; i != n; i++) {
int r = n - 1;
long long k = i;
long long mul = 1;
ans[i] = 0;
while (r > 0) {
int l = max(0ll, r - k);
ans[i] += mul * get(l, r - 1);
k *= i;
mul++;
r = l;
}
}
scanf("%d", &q);
for (auto i = 0; i != q; i++) {
int k;
scanf("%d", &k);
k = min(k, n - 1);
printf("%lld ", ans[k]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
vector<int> G[N];
vector<int> r_G[N];
int vis[N + 10];
int par[2][N + 10];
int src;
int n, m;
bool cycle(int u) {
if (vis[u] == -1) return true;
if (vis[u] == 1) return false;
vis[u] = -1;
for (int v : G[u]) {
if (cycle(v)) return true;
}
vis[u] = 1;
return false;
}
void BFS() {
queue<pair<int, int> > Q;
Q.push(make_pair(0, src));
par[0][src] = -1;
while (not Q.empty()) {
pair<int, int> now = Q.front();
Q.pop();
int p = now.first, u = now.second;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (not par[p ^ 1][v]) {
par[p ^ 1][v] = u;
Q.push(make_pair(p ^ 1, v));
}
}
}
}
vector<int> seq;
void path() {
for (int u = 1; u <= n; u++) {
if (par[1][u] && G[u].size() == 0) {
int p = 1, v = u;
while (v != -1) {
seq.push_back(v);
v = par[p][v];
p ^= 1;
}
reverse(seq.begin(), seq.end());
break;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int u = 1; u <= n; u++) {
int x;
scanf("%d", &x);
for (int i = 1; i <= x; i++) {
int v;
scanf("%d", &v);
G[u].push_back(v);
r_G[v].push_back(i);
}
}
scanf("%d", &src);
BFS();
path();
if (!seq.size()) {
if (cycle(src))
printf("Draw\n");
else
printf("Lose\n");
} else {
printf("Win\n");
for (int i = 0; i < seq.size(); i++) printf("%d ", seq[i]);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
string s[n + 5];
long long int i, j, fl = 0;
map<char, long long int> mm;
string sk = "", sk1 = "";
for (i = 0; i < m; i++) {
sk += 'A';
}
for (i = 0; i < n; i++) {
sk1 += 'A';
}
for (i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == sk && i != 0 && i != n - 1) {
fl = 1;
}
}
string t1 = "";
string t2 = "";
for (i = 0; i < n; i++) {
t1 += s[i][0];
t2 += s[i][m - 1];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
mm[s[i][j]] = 1;
}
}
if (mm['P'] == 0) {
cout << 0 << endl;
continue;
}
if (t1 == sk1 || t2 == sk1 || s[0] == sk || s[n - 1] == sk) {
cout << 1 << endl;
continue;
}
for (i = 1; i < m - 1; i++) {
string tt = "";
for (j = 0; j < n; j++) {
tt += s[j][i];
}
if (tt == sk1) {
fl = 1;
}
}
if (fl == 1) {
cout << 2 << endl;
continue;
}
if (s[0][0] == 'A' || s[0][m - 1] == 'A' || s[n - 1][0] == 'A' ||
s[n - 1][m - 1] == 'A') {
cout << 2 << endl;
continue;
}
if (mm['A'] == 0) {
cout << "MORTAL" << endl;
continue;
}
fl = 0;
for (i = 0; i < n; i++) {
if (s[i][0] == 'A' || s[i][m - 1] == 'A') {
fl = 1;
break;
}
}
for (i = 0; i < m; i++) {
if (s[0][i] == 'A' || s[n - 1][i] == 'A') {
fl = 1;
break;
}
}
if (fl == 1) {
cout << 3 << endl;
continue;
}
cout << 4 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 4005;
int a[N], ls[N], rs[N], sz[N];
int st[N], tot;
long long lw[N], rw[N], f[N][N];
void dfs(int u) {
int i, j;
sz[u] = 1;
if (ls[u]) {
dfs(ls[u]);
for (i = min(sz[u], m); i >= 0; i--)
for (j = min(sz[ls[u]], m); j >= 0; j--)
f[u][i + j] = max(f[u][i + j], f[ls[u]][j] + lw[u] * j * (m - j));
sz[u] += sz[ls[u]];
}
if (rs[u]) {
dfs(rs[u]);
for (i = min(sz[u], m); i >= 0; i--)
for (j = min(sz[rs[u]], m); j >= 0; j--)
f[u][i + j] =
max(f[u][i + j], f[u][i] + f[rs[u]][j] + rw[u] * j * (m - j));
sz[u] += sz[rs[u]];
}
}
int main() {
int i;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
while (tot > 0 && a[st[tot]] > a[i])
ls[i] = st[tot], lw[i] = a[st[tot]] - a[i], tot--;
if (tot) rs[st[tot]] = i, rw[st[tot]] = a[i] - a[st[tot]];
st[++tot] = i;
}
dfs(st[1]);
cout << f[st[1]][m];
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, m;
cin >> n;
if (n % 2 == 0) {
k = ((n * n) / 4) + 1;
m = k - 2;
} else {
k = ((n * n) - 1) / 2;
m = ((n * n) + 1) / 2;
}
if (k != 0 && m != 0)
cout << k << " " << m << endl;
else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double ax, bx, cx, ay, by, cy, d1, d2;
cin >> ax >> ay >> bx >> by >> cx >> cy;
if (sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by)) +
sqrt((bx - cx) * (bx - cx) + (by - cy) * (by - cy)) ==
sqrt((ax - cx) * (ax - cx) + (ay - cy) * (ay - cy))) {
cout << "NO";
return 0;
}
d1 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
d2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy);
if (d1 == d2)
cout << "Yes";
else
cout << "No";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
for (int i = 0;; i++)
if (i / 2 >= N && i / 3 >= M && i / 2 + i / 3 - i / 6 >= N + M)
cout << i, exit(0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int oo = 2 * 1e9;
char a[N][N];
void paintH(int i, int j) {
char c = 'a' + i % 4 + j % 4;
a[i][j] = a[i][j + 1] = c;
}
void paintV(int i, int j) {
char c = 'a' + i % 4 + j % 4;
a[i][j] = a[i + 1][j] = c;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= m + 1; ++j) a[i][j] = '#';
if (n & 1) {
k -= m / 2;
for (int j = 1; j <= m; j += 2) paintH(n, j);
}
if (k < 0 || k & 1) {
cout << "NO\n";
return;
}
for (int i = 1; i < n; i += 2)
for (int j = 1; j < m; j += 2)
if (k) {
paintH(i, j);
paintH(i + 1, j);
k -= 2;
} else {
paintV(i, j);
paintV(i, j + 1);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] == '#') paintV(i, j);
if (k) {
cout << "NO\n";
return;
};
cout << "YES\n";
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cout << a[i][j];
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void home() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long double x, y;
int a, b;
int main() {
home();
int n;
cin >> n;
vector<pair<long double, int> > A(n);
for (int i = 0; i < n; ++i) {
cin >> x >> y;
A[i] = make_pair(atan2(y, x), i + 1);
}
long double ans = 2 * acos(-1.0);
sort(A.begin(), A.end());
for (int i = 0; i < n; i++) {
long double d = A[(i + 1) % n].first - A[i].first;
if (d < 0) d += 2 * acos(-1.0);
if (d < ans) {
ans = d;
a = A[i].second;
b = A[(i + 1) % n].second;
}
}
cout << a << " " << b;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, x, y, i;
int main() {
cin >> a >> b >> x >> y;
cout << max(abs(x - a), abs(y - b));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 200007;
struct cT {
cT() : cho(0) {}
int id, p, cho;
} com[MAXN];
struct qT {
qT() {}
qT(int _id, int _p, int _cc) : id(_id), p(_p), cc(_cc) {}
bool operator<(const qT &a) const {
return ((p ^ a.p) ? (p < a.p) : ((cc ^ a.cc) ? (cc > a.cc) : (id > a.id)));
}
int id, p, cc;
} now;
int n, m;
int s[MAXN], ad[MAXN];
priority_queue<qT> q;
void init();
void input();
void work();
bool cmp_s(const cT &a, const cT &b) {
return ((a.p ^ b.p) ? (a.p > b.p) : (a.id > b.id));
}
bool cmp_id(const cT &a, const cT &b) { return (a.id < b.id); }
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &com[i].p);
for (int i = 1; i <= m; ++i) scanf("%d", &s[i]);
}
void work() {
for (int i = 0; i < n; ++i) com[i].id = i;
sort(com, com + n, cmp_s);
for (int i = 1; i <= m; ++i) q.push(qT(i, s[i], 0));
memset(ad, 0, sizeof(ad));
int ans = 0, ok = 0;
for (int i = 0; i < n; ++i) {
while (1) {
if (q.empty()) break;
now = q.top();
if (now.p > com[i].p) {
now.p = (now.p + 1) / 2;
++now.cc;
q.pop();
q.push(now);
} else if (now.p == com[i].p) {
q.pop();
com[i].cho = now.id;
ans += now.cc;
ad[now.id] = now.cc;
++ok;
break;
} else {
break;
}
}
if (q.empty()) break;
}
sort(com, com + n, cmp_id);
printf("%d %d\n", ok, ans);
for (int i = 1; i <= m; ++i) printf("%d ", ad[i]);
printf("\n");
for (int i = 0; i < n; ++i) printf("%d ", com[i].cho);
printf("\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[101][101];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
for (int j = min(a - 1, c - 1); j <= max(a - 1, c - 1); j++) {
for (int k = min(b - 1, d - 1); k <= max(b - 1, d - 1); k++) {
arr[j][k]++;
}
}
}
long long sum = 0;
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
sum += arr[i][j];
}
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 44;
const int mod = 1e9 + 9, b = 8883;
long long rcshnt[MN];
int n;
char a[MN];
bool check(int len) {
;
long long curr = 0;
for (int i = 0; i < len; ++i) curr = (curr * b + a[i]) % mod;
long long pre = curr;
;
for (int i = len; i < n - 1; ++i) {
;
;
curr = ((curr - a[i - len] * rcshnt[len - 1]) % mod * b + a[i]) % mod;
;
if ((pre - curr) % mod == 0) {
;
return true;
}
};
return false;
}
int main() {
scanf("%s", a);
n = strlen(a);
rcshnt[0] = 1;
for (int i = 1; i < MN; ++i) {
rcshnt[i] = rcshnt[i - 1] * b % mod;
}
for (int i = 0; i < 10; ++i)
;
vector<int> pre;
long long ph = 0, sh = 0;
for (int i = 0; i < n - 1; ++i) {
ph = (ph * b + a[i]) % mod;
sh = (sh + a[n - i - 1] * rcshnt[i]) % mod;
if (ph == sh) {
pre.push_back(i + 1);
;
}
}
int low = 1, high = n - 1, ans = 0;
while (low <= high) {
int med = (low + high) / 2;
if (check(med)) {
ans = med;
low = med + 1;
} else
high = med - 1;
}
int res = -1;
for (auto c : pre) {
if (c <= ans) res = max(res, c);
}
if (res <= 0) {
printf("Just a legend\n");
} else {
a[res] = 0;
printf("%s\n", a);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename t>
t maxi(t x, t y) {
return x > y ? x : y;
}
template <typename t>
t mini(t x, t y) {
return x < y ? x : y;
}
void solve() {
long long int n, h, m;
cin >> n >> h >> m;
long long int sm = 0;
long long int a[n];
for (int i = 0; i < n; ++i) a[i] = h;
for (int i = 0; i < m; ++i) {
long long int l, r, k;
cin >> l >> r >> k;
l--;
r--;
for (int i = l; i < r + 1; ++i) a[i] = mini(a[i], k);
}
for (int i = 0; i < n; ++i) sm += (a[i] * a[i]);
cout << sm << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i;
int main() {
cin >> n;
if (n % 2 == 0) return cout << "NO", 0;
for (cout << "YES\n"; i < n + n; i++)
cout << (i < n ? i % 2 ? i + i + 1 : i + i
: i % 2 ? i - n + i - n + 1
: i - n + i - n) +
1
<< " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int t, x, y, a, b;
int main() {
cin >> t;
while (t--) {
cin >> x >> y >> a >> b;
if ((y - x) % (a + b) == 0)
cout << (y - x) / (a + b) << endl;
else
cout << -1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 1000000007;
pair<long long, long long> dfs(int v, const vector<vector<int>> &children,
const vector<int> &black) {
long long zero = 0;
long long one = 0;
(black[v] ? one : zero) = 1;
for (const auto &child : children[v]) {
const auto result = dfs(child, children, black);
long long t_zero = (zero * result.second + zero * result.first) % mod;
one =
(one * result.second + zero * result.second + one * result.first) % mod;
zero = t_zero;
}
return {zero, one};
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int>> children(n);
for (int i = 1; i < n; ++i) {
int p;
cin >> p;
children[p].emplace_back(i);
}
vector<int> black(n);
for (auto &e : black) cin >> e;
const auto ans = dfs(0, children, black);
cout << ans.second << endl;
return EXIT_SUCCESS;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int L = (1 << 19) + 1;
char ibuf[L], *iS, *iT, c;
int f;
char gc() {
if (iS == iT) {
iT = (iS = ibuf) + fread(ibuf, 1, L, stdin);
return iS == iT ? EOF : *iS++;
}
return *iS++;
}
template <class I>
void gi(I& x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc())
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15);
x *= f;
}
}; // namespace io
using io::gc;
using io::gi;
vector<int> f[100010];
int n, a, m, k;
int main() {
gi(n);
gi(k);
gi(m);
for (register int i = 1; i <= n; i++) gi(a), f[a % m].push_back(a);
for (register int i = 0; i <= m - 1; i++)
if (f[i].size() >= k) {
puts("Yes");
for (register int j = 0; j <= k - 1; j++) printf("%d ", f[i][j]);
return 0;
}
puts("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
inline long long read() {
char tempt = getchar();
long long x = 0, f = 0;
while (tempt < '0' || tempt > '9') f |= tempt == '-', tempt = getchar();
while (tempt >= '0' && tempt <= '9')
x = x * 10 + tempt - '0', tempt = getchar();
return f ? -x : x;
}
inline long long qmi(long long m, long long k, long long p) {
long long res = 1 % p, t = m;
while (k) {
if (k & 1) res = res * t % p;
t = t * t % p;
k >>= 1;
}
return res;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long N = 1e5 + 10;
char s[N];
char t[N];
long long p;
long long ans;
vector<long long> dp[26];
bool check(long long i) {
char ct = t[i];
long long tmp = ct - 'a';
long long l = 0, r = dp[tmp].size() - 1;
while (l < r) {
long long mid = l + r + 1 >> 1;
if (dp[tmp][mid] <= p)
l = mid;
else
r = mid - 1;
}
if (l == 0 || l == dp[tmp].size() - 1) {
p = -1000;
return false;
} else {
p = dp[ct - 'a'][l] - 1;
if (i == 1) ans++;
return true;
}
return false;
}
signed main() {
long long T;
cin >> T;
for (register long long _ = 1; _ <= T; _++) {
for (long long i = 0; i < 26; i++) {
dp[i].clear();
dp[i].push_back(-100000);
}
scanf("%s", s + 1);
scanf("%s", t + 1);
long long lens = strlen(s + 1);
for (register long long i = 1; i <= lens; i++) {
char tc = s[i];
dp[tc - 'a'].push_back(i);
}
for (long long i = 0; i < 26; i++) {
dp[i].push_back(0x3f3f3f3f);
}
long long lent = strlen(t + 1);
p = lens;
ans = 0;
bool flag = false;
bool bans = true;
for (long long i = lent; i >= 1; i--) {
if (p >= 1 && p != 0x3f3f3f3f && check(i)) {
flag = true;
continue;
} else {
if (!flag) {
bans = false;
break;
}
flag = false;
p = lens;
ans++;
i++;
}
}
if (!bans)
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
int t, k;
int ans[100010], sum[100010];
void init() {
scanf("%d%d", &t, &k);
ans[0] = 1;
for (int i = 1; i <= 100000; i++) {
ans[i] = ans[i - 1];
if (i >= k) {
ans[i] += ans[i - k];
if (ans[i] >= 1000000007) ans[i] -= 1000000007;
}
sum[i] = sum[i - 1] + ans[i];
if (sum[i] >= 1000000007) sum[i] -= 1000000007;
}
}
void solve() {
for (int i = 1; i <= t; i++) {
int tmpa, tmpb;
scanf("%d%d", &tmpa, &tmpb);
printf("%d\n", (sum[tmpb] - sum[tmpa - 1] + 1000000007) % 1000000007);
}
}
int main() {
init();
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1005][1005], l[1005][1005], r[1005][1005], u[1005][1005],
d[1005][1005];
vector<pair<char, long long int>> b;
vector<pair<char, pair<long long int, long long int>>> v;
long long int check(long long int x, long long int y) {
char c;
long long int z;
for (long long int i = 0; i < b.size(); i++) {
c = b[i].first;
z = b[i].second;
if (c == 'N') {
if (u[x][y] >= z)
x -= z;
else
return 0;
}
if (c == 'S') {
if (d[x][y] >= z)
x += z;
else
return 0;
}
if (c == 'E') {
if (r[x][y] >= z)
y += z;
else
return 0;
}
if (c == 'W') {
if (l[x][y] >= z)
y -= z;
else
return 0;
}
}
return 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, x, k, y;
cin >> n >> m;
char ch;
string s;
for (long long int i = 1; i <= n; i++) {
cin >> s;
for (long long int j = 0; j < m; j++) {
if (s[j] != '#') {
if (s[j] != '.')
v.push_back({s[j], {i, j + 1}}), a[i][j + 1] = 0;
else
a[i][j + 1] = 0;
} else
a[i][j + 1] = 1;
}
}
cin >> k;
for (long long int i = 0; i < k; i++) {
cin >> ch >> x;
b.push_back({ch, x});
}
for (long long int i = 1; i <= n; i++) {
x = 0;
for (long long int j = 1; j <= m; j++) {
if (a[i][j] == 0)
l[i][j] = x++;
else
x = 0, l[i][j] = x;
}
x = 0;
for (long long int j = m; j >= 1; j--) {
if (a[i][j] == 0)
r[i][j] = x++;
else
x = 0, r[i][j] = x;
}
}
for (long long int j = 1; j <= m; j++) {
x = 0;
for (long long int i = 1; i <= n; i++) {
if (a[i][j] == 0)
u[i][j] = x++;
else
x = 0, u[i][j] = x;
}
x = 0;
for (long long int i = n; i >= 1; i--) {
if (a[i][j] == 0)
d[i][j] = x++;
else
x = 0, d[i][j] = x;
}
}
string ans;
long long int f = 0;
for (long long int i = 0; i < v.size(); i++) {
x = v[i].second.first;
y = v[i].second.second;
if (check(x, y)) {
ans += v[i].first;
f = 1;
}
}
if (!f) {
cout << "no solution" << endl;
return 0;
}
sort(ans.begin(), ans.end());
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t, a, b, tp;
string s1, s2;
char s3[100010];
vector<int> posa, posb;
char distinto(char a, char b) {
for (char x = 'a'; x <= 'z'; x++)
if (x != a && x != b) return x;
return '%';
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> t) {
cin >> s1 >> s2;
for (int i = (0); i < (n); i++) s3[i] = '$';
s3[n] = 0;
tp = n - t;
a = b = 0;
for (int i = (0); i < (n); i++)
if (s1[i] == s2[i]) {
posa.push_back(i);
a++;
} else {
posb.push_back(i);
b++;
}
if (tp <= a || (tp > a && 2 * (tp - a) <= b)) {
int c = min(a, tp);
for (int i = (0); i < (c); i++) s3[posa[i]] = s1[posa[i]];
if (tp > a) {
int c = (tp - a);
for (int i = (0); i < (c); i++) {
s3[posb[i]] = s1[posb[i]];
}
for (int i = (c); i < (2 * c); i++) {
s3[posb[i]] = s2[posb[i]];
}
}
for (int i = (0); i < (n); i++)
if (s3[i] == '$') s3[i] = distinto(s1[i], s2[i]);
cout << s3 << endl;
} else {
cout << -1 << endl;
}
posa.clear();
posb.clear();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10000005], l[10000005], r[10000005];
long long c[10000005], ans = 0;
stack<pair<int, long long> > A;
deque<pair<int, long long> > B, C;
int TakeInputAndInitialise() {
int n, m;
vector<vector<int> > u(1), v(1);
scanf("%d%d", &n, &m);
while (n--) {
int k;
scanf("%d", &k);
vector<int> a, b;
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
a.push_back(x);
}
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
b.push_back(x);
}
u.push_back(a);
v.push_back(b);
}
int q, i = 1;
scanf("%d", &q);
while (q--) {
int id, mul;
scanf("%d%d", &id, &mul);
vector<int> &x = u[id], &y = v[id];
for (int j = 0, k = x.size(); j < k; ++j, ++i) {
a[i] = x[j];
c[i] = 1ll * mul * y[j];
}
}
return m;
}
void PreProcess(int n) {
stack<pair<int, int> > S;
for (int i = 1; i <= n; ++i) {
int j = max(1, i - a[i] + 1);
while (!S.empty() && j <= S.top().second) {
j = min(j, S.top().first);
S.pop();
}
l[i] = j;
S.push(make_pair(j, i));
}
while (!S.empty()) {
S.pop();
}
for (int i = n; i > 0; --i) {
int j = min(n, i + a[i] - 1);
while (!S.empty() && S.top().first <= j) {
j = max(j, S.top().second);
S.pop();
}
r[i] = j;
S.push(make_pair(i, j));
}
while (!S.empty()) {
S.pop();
}
}
long long QueryLeft(int i) {
int j = l[i] - 1;
long long x = LLONG_MAX;
while (!A.empty() && j <= A.top().first) {
x = min(x, A.top().second);
A.pop();
}
A.push(make_pair(j, x));
return x + c[i];
}
long long QueryRight(int i) {
while (!B.empty() && B.front().first < i) {
B.pop_front();
}
if (!B.empty()) {
return B.front().second;
}
while (!C.empty() && C.front().first < i) {
C.pop_front();
}
return C.front().second;
}
void UpdateLeft(int i) { A.push(make_pair(i, ans)); }
void UpdateRight(int i) {
int j = r[i + 1];
long long x = ans + c[i + 1];
while (!C.empty() && C.front().first < j) {
if (C.front().second < x) {
B.push_back(C.front());
}
C.pop_front();
}
while (!B.empty() && j <= B.back().first) {
C.push_front(B.back());
B.pop_back();
}
while (!B.empty() && x < B.back().second) {
B.pop_back();
}
while (!C.empty() && C.front().first == j) {
x = min(x, C.front().second);
C.pop_front();
}
B.push_back(make_pair(j, x));
}
int main() {
int n = TakeInputAndInitialise();
PreProcess(n);
UpdateLeft(0);
UpdateRight(0);
for (int i = 1; i <= n; ++i) {
ans = min(QueryLeft(i), QueryRight(i));
UpdateLeft(i);
UpdateRight(i);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a;
long long int tree[4 * (long long int)(1e6) + 5];
long long int v[(long long int)(1e6) + 5];
set<long long int> se;
void build(long long int wai, long long int start, long long int end) {
if (start > end) return;
if (start == end) {
tree[wai] = 1;
return;
}
build(wai * 2, start, (start + end) / 2),
build(wai * 2 + 1, (start + end) / 2 + 1, end);
tree[wai] = tree[wai * 2] + tree[wai * 2 + 1];
}
void update(long long int wai, long long int start, long long int end,
long long int ind) {
if (start > end || start > ind || end < ind) return;
if (start == end) {
tree[wai] = 0;
return;
}
update(wai * 2, start, (start + end) / 2, ind),
update(wai * 2 + 1, (start + end) / 2 + 1, end, ind);
tree[wai] = tree[wai * 2] + tree[wai * 2 + 1];
}
long long int query(long long int wai, long long int start, long long int end,
long long int l, long long int r) {
if (start > end || start > r || end < l) return 0;
if (start >= l && end <= r) return tree[wai];
return query(wai * 2, start, (start + end) / 2, l, r) +
query(wai * 2 + 1, (start + end) / 2 + 1, end, l, r);
}
long long int query2(long long int wai, long long int start, long long int end,
long long int val) {
if (start == end) return start;
if (tree[wai * 2] >= val)
return query2(wai * 2, start, (start + end) / 2, val);
return query2(wai * 2 + 1, (start + end) / 2 + 1, end, val - tree[wai * 2]);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
build(1, 1, n);
for (long long int i = 0; i < n; i++) {
cin >> a;
v[i] = query(1, 1, n, 1, a + 1) - 1;
update(1, 1, n, a + 1);
}
build(1, 1, n);
for (long long int i = 0; i < n; i++) {
cin >> a;
v[i] += query(1, 1, n, 1, a + 1) - 1;
update(1, 1, n, a + 1);
}
for (long long int i = n - 1; i > -1; i--) {
if (v[i] > n - i - 1) v[i - 1] += 1, v[i] -= (n - i);
}
build(1, 1, n);
for (long long int i = 0; i < n; i++) {
cout << query2(1, 1, n, v[i] + 1) - 1 << " ";
update(1, 1, n, query2(1, 1, n, v[i] + 1));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long dp[1001][1001];
long long sdp[1001][1001];
long long ssdp[1001][1001];
long long ssdp2[1001];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
dp[i][j] = 1;
}
}
for (int u = 1; u <= m; ++u) {
for (int l = 1; l <= n; ++l) {
for (int r = 1; r <= n; ++r) {
sdp[l][r] = (sdp[l][r - 1] + dp[l][r]) % MOD;
}
}
for (int r = 1; r <= n; ++r) {
for (int l = 1; l <= n; ++l) {
ssdp[r][l] = (ssdp[r][l - 1] + sdp[l][r]) % MOD;
}
ssdp2[r] = (sdp[r][r - 1] + ssdp2[r - 1]) % MOD;
}
for (int r = 1; r <= n; ++r) {
for (int l = 1; l <= n; ++l) {
if (l <= r) {
dp[l][r] = ssdp[n][l] - ssdp[r - 1][l];
} else {
dp[l][r] = ssdp[n][l] - ssdp[r - 1][r] - ssdp2[l] + ssdp2[r];
}
dp[l][r] %= MOD;
}
}
}
cout << (dp[n][1] + MOD) % MOD;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const double INF = DBL_MAX;
bool iszero(const double a) { return fabs(a) <= eps; }
double sqr(const double a) { return a * a; }
int sgn(const double a) {
if (a < -eps) return -1;
return (a > eps);
}
int cmp(const double a, const double b) { return sgn(a - b); }
int inint() {
int t;
scanf("%d", &t);
return t;
}
const int N = 200100;
int n, m, q;
struct Edge {
int id;
int to, nxt;
} edge[N << 1];
int head[N], tot;
int Low[N], DFN[N], Instack[N], Stack[N], Belong[N];
int Index, top;
int scc;
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v) {
edge[tot].id = u;
edge[tot].to = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
void Tarjan(int u, int f = -1) {
int v;
Low[u] = DFN[u] = ++Index;
Stack[++top] = u;
Instack[u] = true;
for (int i = head[u]; i >= 0; i = edge[i].nxt) {
v = edge[i].to;
if ((i ^ 1) == f) continue;
if (!DFN[v]) {
Tarjan(v, i);
if (Low[u] > Low[v]) Low[u] = Low[v];
} else if (Instack[v]) {
if (Low[u] > DFN[v]) Low[u] = DFN[v];
}
}
if (Low[u] == DFN[u]) {
scc++;
do {
v = Stack[top--];
Instack[v] = false;
Belong[v] = scc;
} while (v - u && top);
}
}
void solve(int N) {
memset(DFN, 0, sizeof(DFN));
memset(Instack, 0, sizeof(Instack));
Index = scc = top = 0;
for (int i = 1; i <= N; i++)
if (!DFN[i]) Tarjan(i);
init();
for (int i = 0; i < 2 * m; i += 2) {
int u = edge[i].id, v = edge[i].to;
u = Belong[u];
v = Belong[v];
if (u == v) continue;
addedge(u, v);
addedge(v, u);
}
}
int cnt, l[N], r[N], a[N], b[N], c[N], d[N];
bool vis[N];
bool ans;
void dfs1(int u, int f = -1) {
if (l[u]) return;
cnt++;
l[u] = cnt;
a[u] = b[u] = c[u] = d[u] = cnt;
for (int i = head[u]; i >= 0; i = edge[i].nxt) {
int v = edge[i].to;
if (f - v) dfs1(v, u);
}
r[u] = cnt;
}
void update(int i, int j) {
a[i] = min(a[i], l[j]);
b[j] = min(b[j], l[i]);
c[i] = max(c[i], l[j]);
d[j] = max(d[j], r[i]);
}
void dfs2(int u, int f = -1) {
if (vis[u]) return;
vis[u] = true;
for (int i = head[u]; i >= 0; i = edge[i].nxt) {
int v = edge[i].to;
if (f - v) {
dfs2(v, u);
if (!ans) return;
a[u] = min(a[u], a[v]);
b[u] = min(b[u], b[v]);
c[u] = max(c[u], c[v]);
d[u] = max(d[u], d[v]);
}
}
ans = !((a[u] < l[u] || c[u] > r[u]) && (b[u] < l[u] || d[u] > r[u]));
}
int main() {
init();
n = inint();
m = inint();
q = inint();
for (int i = 0; i < m; i++) {
int u = inint();
int v = inint();
addedge(u, v);
addedge(v, u);
}
solve(n);
for (int i = 1; i <= scc; i++) dfs1(i);
while (q--) {
int i = Belong[inint()];
int j = Belong[inint()];
update(i, j);
}
ans = true;
for (int i = 1; i <= scc && ans; i++) dfs2(i);
puts(ans ? "Yes" : "No");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string s;
cin >> n >> s;
for (int i = 0; i < (int)s.size() - 1; i++) {
if (s[i] > s[i + 1]) {
cout << "YES\n";
cout << i + 1 << " " << i + 2;
return 0;
}
}
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100000;
int a[MaxN];
int color[MaxN];
bool f = true;
int n;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
while (n % k) {
a[n + 1] = a[n];
n++;
}
int ans = 0;
for (int i = 0; i < n / k; ++i) {
ans += (2 * (a[k * i + 1] - 1));
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 9, inf = 1e18, mod = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
int ans = n * 3;
ans += min(k - 1, n - k);
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long> s;
long long a[1003];
long long b[1003];
int main() {
long long mx = 0;
long long res = 0;
int n, k1, k2;
int k = 0;
cin >> n >> k1 >> k2;
k = k1 + k2;
long long x, y;
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = x;
}
for (int i = 0; i < n; i++) {
cin >> y;
b[i] = y;
s.insert(abs(a[i] - b[i]));
}
for (int i = 0; i < k; i++) {
multiset<long long>::iterator it = s.end();
it--;
mx = *it;
mx--;
s.erase(it);
s.insert(abs(mx));
}
multiset<long long>::iterator it = s.begin();
for (int j = 0; j < n; j++) {
res += (*it) * (*it);
it++;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void chmin(T &t, U f) {
if (t > f) t = f;
}
template <class T, class U>
inline void chmax(T &t, U f) {
if (t < f) t = f;
}
const long long mod = 1000000007;
long long N;
long long H[1000000];
long long f[1000000], g[1000000];
signed main() {
scanf("%lld", &N);
for (long long i = 0; i < (N); i++) scanf("%lld", &H[i]), H[i]--;
long long ans = 0;
for (long long i = 0; i < (N); i++) {
if (i) {
if (H[i - 1] >= H[i]) {
if (i + 1 == N || H[i + 1] >= H[i]) {
f[i] = 0;
g[i] = g[i - 1] * H[i] % mod;
} else {
f[i] = (H[i] - H[i + 1]) * g[i - 1] % mod;
g[i] = H[i + 1] * g[i - 1] % mod;
}
} else {
if (i + 1 == N || H[i + 1] >= H[i]) {
f[i] = 0;
g[i] = g[i - 1] * H[i - 1] % mod;
} else if (H[i - 1] <= H[i + 1]) {
f[i] = 0;
g[i] = g[i - 1] * H[i - 1] % mod;
} else {
f[i] = (H[i - 1] - H[i + 1]) * g[i - 1] % mod;
g[i] = H[i + 1] * g[i - 1] % mod;
}
}
}
if (i + 1 == N || H[i + 1] >= H[i]) {
g[i] = (g[i] + H[i]) % mod;
} else {
f[i] = (f[i] + (H[i] - H[i + 1])) % mod;
g[i] = (g[i] + H[i + 1]) % mod;
}
ans = (ans + f[i] + g[i]) % mod;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> a;
int main() {
int n, m;
cin >> n >> m;
if (m % 2 == 0) {
int s = m / 2 - 1;
int e = m / 2;
bool sOccupied = false;
for (int i = 0; i < n; i++) {
if (sOccupied) {
a[i] = e;
s--;
e++;
sOccupied = false;
} else {
a[i] = s;
sOccupied = true;
}
if (s < 0) {
s = m / 2 - 1;
e = m / 2;
}
}
} else {
int s = m / 2;
int e = m / 2;
bool sOccupied = false;
for (int i = 0; i < n; i++) {
if (s == e) {
a[i] = s;
s--;
e++;
} else {
if (sOccupied) {
a[i] = e;
s--;
e++;
sOccupied = false;
} else {
a[i] = s;
sOccupied = true;
}
}
if (s < 0) {
s = e = m / 2;
}
}
}
for (map<int, int>::iterator it = a.begin(); it != a.end(); it++) {
printf("%d\n", it->second + 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int begtime = clock();
void solve() {
int i, n, k, max(0), maxa;
cin >> n >> k;
vector<pair<int, int> > p(n);
for (i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
if (p[0].second <= k) {
max = p[0].first;
} else {
max = p[0].first - (p[0].second - k);
}
for (i = 0; i < n; i++) {
if (p[i].second <= k) {
if (max < p[i].first) {
max = p[i].first;
}
} else {
if (max < (p[i].first - (p[i].second - k))) {
max = p[i].first - (p[i].second - k);
}
}
}
cout << max;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
struct Push {
int vid;
vector<pair<int, int> > a;
int read() {
int cnt;
if (scanf("%d%d", &vid, &cnt) < 2) return 0;
--vid;
a.clear();
vector<int> cur;
for (int i = 0; i < cnt; ++i) {
int x;
assert(scanf("%d", &x) == 1);
if (x != -1) --x;
cur.push_back(x);
}
sort(cur.begin(), cur.end());
for (int i = 0; i < ((int)(cur).size());) {
int i0 = i;
while (i < ((int)(cur).size()) && cur[i] == cur[i0]) ++i;
a.push_back(make_pair(cur[i0], i - i0));
}
return 1;
}
};
const int maxn = (int)1e5 + 10;
Push pushes[maxn];
int cnt[maxn];
int st[maxn];
vector<vector<pair<int, int> > > back;
int dead[maxn];
vector<vector<int> > es, esrev;
int perm[maxn];
int used[maxn];
int pcnt;
void dfs1(int v) {
used[v] = 1;
for (int it = 0; it < ((int)(es[v]).size()); ++it) {
int u = es[v][it];
if (used[u]) continue;
dfs1(u);
}
perm[pcnt++] = v;
}
int myisinf[maxn];
void dfs2(int v, bool alone = 1) {
used[v] = 1;
for (int it = 0; it < ((int)(esrev[v]).size()); ++it) {
int u = esrev[v][it];
if (used[u]) {
if (u == v) alone = 0;
continue;
}
alone = 0;
dfs2(u, alone);
}
if (!alone) myisinf[v] = 1;
}
void dfs3(int v) {
used[v] = 1;
myisinf[v] = 1;
for (int it = 0; it < ((int)(esrev[v]).size()); ++it) {
int u = esrev[v][it];
if (used[u]) continue;
dfs3(u);
}
}
int myleft[maxn];
int d[maxn];
int mins[maxn];
int values[maxn];
bool solve() {
int m, n;
if (scanf("%d%d", &m, &n) < 2) return 0;
back = vector<vector<pair<int, int> > >(n);
for (int i = 0; i < m; ++i) {
assert(pushes[i].read());
for (int j = 0; j < ((int)(pushes[i].a).size()); ++j)
if (pushes[i].a[j].first != -1)
back[pushes[i].a[j].first].push_back(
make_pair(i, pushes[i].a[j].second));
}
for (int i = 0; i < m; ++i) cnt[i] = ((int)(pushes[i].a).size()) - 1;
for (int i = 0; i < n; ++i) dead[i] = 1;
int r = 0;
for (int i = 0; i < m; ++i) {
if (cnt[i] == 0) st[r++] = i;
}
for (int l = 0; l < r; ++l) {
int id = st[l];
int vid = pushes[id].vid;
if (!dead[vid]) continue;
dead[vid] = 0;
for (int it = 0; it < ((int)(back[vid]).size()); ++it) {
int curid = back[vid][it].first;
if (--cnt[curid] == 0) st[r++] = curid;
}
}
es = esrev = vector<vector<int> >(n);
for (int i = 0; i < m; ++i) {
if (cnt[i] > 0) continue;
for (int j = 0; j < ((int)(pushes[i].a).size()); ++j) {
int s = pushes[i].vid;
int t = pushes[i].a[j].first;
if (t == -1) continue;
es[s].push_back(t);
esrev[t].push_back(s);
}
}
for (int i = 0; i < n; ++i) used[i] = 0, myisinf[i] = 0;
pcnt = 0;
for (int i = 0; i < n; ++i) {
if (dead[i]) {
assert(!((int)(es[i]).size()));
continue;
}
if (!used[i]) dfs1(i);
}
for (int i = 0; i < n; ++i) used[i] = 0;
for (int i = pcnt - 1; i >= 0; --i) {
int v = perm[i];
if (!used[v]) dfs2(v);
}
for (int i = 0; i < n; ++i) used[i] = 0;
for (int i = 0; i < n; ++i)
if (myisinf[i] && !used[i]) dfs3(i);
vector<vector<int> > from(n);
for (int i = 0; i < m; ++i) {
if (cnt[i] > 0) continue;
from[pushes[i].vid].push_back(i);
}
for (int i = 0; i < n; ++i) d[i] = -1;
for (int i = 0; i < pcnt; ++i) {
int v = perm[i];
assert(!dead[v]);
if (myisinf[v]) continue;
long long res = 0;
for (int it = 0; it < ((int)(from[v]).size()); ++it) {
int id = from[v][it];
long long value = 0;
for (int j = 0; j < ((int)(pushes[id].a).size()); ++j) {
int who = pushes[id].a[j].first, times = pushes[id].a[j].second;
if (who == -1)
value += times;
else {
assert(d[who] != -1);
value += (long long)d[who] * times;
}
}
res = max(res, value);
}
assert(res != 0);
res = min(res, (long long)((int)314 * (int)1e6));
d[v] = (int)res;
}
priority_queue<pair<int, int> > tree;
for (int i = 0; i < n; ++i) {
if (dead[i]) continue;
mins[i] = ((int)314 * (int)1e6);
used[i] = 0;
}
r = 0;
for (int i = 0; i < m; ++i) {
if (cnt[i] > 0) continue;
myleft[i] = ((int)(pushes[i].a).size()) - 1;
values[i] = 0;
for (int j = 0; j < ((int)(pushes[i].a).size()); ++j)
if (pushes[i].a[j].first == -1) values[i] += pushes[i].a[j].second;
if (myleft[i] == 0)
mins[pushes[i].vid] = min(mins[pushes[i].vid], values[i]);
}
for (int i = 0; i < n; ++i)
if (!dead[i]) tree.push(make_pair(-mins[i], i));
while (!tree.empty()) {
pair<int, int> top = tree.top();
int v = top.second;
tree.pop();
if (-mins[v] != top.first) continue;
assert(!used[v]);
used[v] = 1;
for (int it = 0; it < ((int)(back[v]).size()); ++it) {
int id = back[v][it].first;
if (cnt[id] > 0) continue;
long long cur = values[id];
cur += (long long)back[v][it].second * mins[v];
cur = min(cur, (long long)((int)314 * (int)1e6));
values[id] = cur;
--myleft[id];
if (myleft[id] == 0) {
int nv = pushes[id].vid;
if (mins[nv] > values[id]) {
mins[nv] = values[id];
tree.push(make_pair(-mins[nv], nv));
}
}
}
}
for (int i = 0; i < n; ++i) {
if (dead[i]) {
printf("-1 -1\n");
continue;
}
assert(used[i]);
if (!myisinf[i]) assert(mins[i] <= d[i]);
printf("%d %d\n", mins[i], myisinf[i] ? -2 : d[i]);
}
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long base = 31, mod = 987654321;
long long n, m, ans, p[2005], f[2][2005][2005];
char s[2005], a[2][2005];
struct node {
long long h[2005];
inline void make(long long n, char *s) {
h[0] = 0;
for (long long i = 1; i <= n; i++)
h[i] = (h[i - 1] * base + s[i] - 'a') % mod;
}
inline long long find(long long l, long long r) {
return (h[r] - h[l - 1] * p[r - l + 1] % mod + mod) % mod;
}
} ss, pre[2], nxt[2];
inline void add(long long &a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
long long solve(long long flag) {
long long res = 0;
memset(f, 0, sizeof(f));
for (long long j = 1; j <= n; j++) {
f[0][j][0] = f[1][j][0] = 1;
for (long long i = 0; i < 2; i++)
for (long long k = 2; k <= min(j, m / 2); k++)
if (ss.find(1, k) == nxt[i ^ 1].find(n - j + 1, n - (j - k + 1) + 1) &&
ss.find(k + 1, 2 * k) == pre[i].find(j - k + 1, j))
if (2 * k != m || flag) add(f[i][j + 1][2 * k], 1);
for (long long i = 0; i < 2; i++)
for (long long k = 2; k <= min(m / 2, n - j + 1); k++)
if (ss.find(m - 2 * k + 1, m - k) == pre[i].find(j, j + k - 1) &&
ss.find(m - k + 1, m) ==
nxt[i ^ 1].find(n - (j + k - 1) + 1, n - j + 1))
if (2 * k != m || flag) add(res, f[i][j][m - 2 * k]);
for (long long i = 0; i < 2; i++)
for (long long k = 0; k < m; k++)
if (a[i][j] == s[k + 1]) {
add(f[i][j + 1][k + 1], f[i][j][k]);
if (k + 2 <= m && a[i ^ 1][j] == s[k + 2])
add(f[i ^ 1][j + 1][k + 2], f[i][j][k]);
}
for (long long i = 0; i < 2; i++) add(res, f[i][j + 1][m]);
}
return res;
}
signed main() {
p[0] = 1;
for (long long i = 1; i <= 2000; i++) p[i] = p[i - 1] * base % mod;
for (long long i = 0; i < 2; i++) {
cin >> a[i] + 1;
n = strlen(a[i] + 1);
pre[i].make(n, a[i]);
reverse(a[i] + 1, a[i] + n + 1);
nxt[i].make(n, a[i]);
reverse(a[i] + 1, a[i] + n + 1);
}
cin >> s + 1;
m = strlen(s + 1);
ss.make(m, s);
add(ans, solve(1));
if (m > 1) {
reverse(s + 1, s + m + 1);
ss.make(m, s);
add(ans, solve(0));
if (m == 2)
for (long long i = 0; i < 2; i++)
for (long long j = 1; j <= n; j++)
if (a[i][j] == s[1] && a[i ^ 1][j] == s[2]) add(ans, 1000000007 - 1);
}
printf("%lld", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, el;
cin >> n >> m;
int freq[105] = {};
long long int cursum = 0;
for (int i = 0; i < n; i++) {
cin >> el;
cursum += el;
if (cursum <= m) {
freq[el]++;
cout << "0 ";
continue;
}
long long int temp = cursum - el;
long long int free = m - temp;
long long int ef = el - free;
long long int ans = 0;
for (int j = 100; j >= 1; j--) {
if (j * freq[j] <= ef) {
ef -= j * freq[j];
ans += freq[j];
} else {
int tim = ceil(double(ef) / j);
ans += tim;
break;
}
}
cout << ans << " ";
freq[el]++;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
SegmentTree *left, *right;
int a, b;
long long sum;
bool lazy;
SegmentTree(int a, int b)
: left(NULL), right(NULL), a(a), b(b), sum(0), lazy(false) {}
};
void flip(SegmentTree *tree) {
if (tree == NULL) return;
tree->sum = tree->b - tree->a + 1 - tree->sum;
}
void push_lazy(SegmentTree *tree, SegmentTree *child) {
if (child == NULL) return;
if (!tree->lazy) return;
flip(child);
if (child->a != child->b) child->lazy = !child->lazy;
}
SegmentTree *build(int *arr, int a, int b) {
if (a > b) return NULL;
SegmentTree *result = new SegmentTree(a, b);
if (a == b) {
result->sum = arr[a];
} else {
int m = (a + b) / 2;
result->left = build(arr, a, m);
result->right = build(arr, m + 1, b);
result->sum = result->left->sum + result->right->sum;
}
return result;
}
long long query(SegmentTree *tree, int a, int b) {
if (tree == NULL) return 0;
if (tree->a > b) return 0;
if (tree->b < a) return 0;
if (tree->a >= a && tree->b <= b) return tree->sum;
push_lazy(tree, tree->left);
push_lazy(tree, tree->right);
tree->lazy = false;
return query(tree->left, a, b) + query(tree->right, a, b);
}
long long update(SegmentTree *tree, int a, int b) {
if (tree == NULL) return 0;
if (tree->a > b) return tree->sum;
if (tree->b < a) return tree->sum;
if (tree->a >= a && tree->b <= b) {
flip(tree);
if (tree->a != tree->b) {
tree->lazy = !tree->lazy;
}
} else {
push_lazy(tree, tree->left);
push_lazy(tree, tree->right);
tree->lazy = false;
tree->sum = update(tree->left, a, b) + update(tree->right, a, b);
}
return tree->sum;
}
void print_tree(SegmentTree *tree, int indent) {
if (tree == NULL) {
printf("%*sNULL\n", indent * 4, "");
} else {
printf("%*sNODE\n", indent * 4, "");
printf("%*s a, b = %d, %d\n", indent * 4, "", tree->a, tree->b);
printf("%*s sum = %d\n", indent * 4, "", tree->sum);
printf("%*s lazy = %d\n", indent * 4, "", tree->lazy);
printf("%*s LEFT:\n", indent * 4, "");
print_tree(tree->left, indent + 1);
printf("%*s RIGHT:\n", indent * 4, "");
print_tree(tree->right, indent + 1);
}
}
SegmentTree *trees[21];
int arr[100005];
int bit_arr[21][100005];
int N, M;
int main() {
cin >> N;
for (int n = 0; n < N; n++) {
cin >> arr[n];
for (int b = 0; b < 21; b++) {
bit_arr[b][n] = (arr[n] >> b) % 2;
}
}
for (int b = 0; b < 21; b++) {
trees[b] = build(bit_arr[b], 0, N - 1);
}
cin >> M;
int type, x, y, z;
for (int m = 0; m < M; m++) {
cin >> type;
if (type == 1) {
cin >> x >> y;
x--;
y--;
long long sum = 0, sum2 = 0;
for (int b = 0; b < 21; b++) {
sum += query(trees[b], x, y) << b;
}
cout << sum << endl;
} else if (type == 2) {
cin >> x >> y >> z;
x--;
y--;
for (int b = 0; b < 21; b++) {
if ((z >> b) % 2 == 1) {
update(trees[b], x, y);
}
}
} else {
cout << "bit 1" << endl;
print_tree(trees[1], 0);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int L = 20;
const int MD = 1000000007;
int n, k;
int v[N], c[N], st[N];
int mx[L][N], mn[L][N];
int getmx(int l, int r) {
int d = st[r - l + 1];
return max(mx[d][l], mx[d][r - (1 << d) + 1]);
}
int getmn(int l, int r) {
int d = st[r - l + 1];
return min(mn[d][l], mn[d][r - (1 << d) + 1]);
}
int f(int l, int r) { return min(100 * getmx(l, r), getmn(l, r)); }
double solve() {
long double arr[123] = {};
long double fact[123] = {};
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
for (int i = 1; i <= n; ++i) {
arr[i] = 0;
for (int j = i; j <= n; ++j) {
arr[i] = max(arr[i], (long double)f(i, j));
}
}
sort(arr + 1, arr + n + 1);
double ans = 0;
for (int i = 1; i + k - 1 <= n; ++i) {
ans += arr[i] * fact[n - i] / fact[k - 1] / fact[(n - i) - (k - 1)];
}
ans /= (fact[n] / fact[k] / fact[n - k]);
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> v[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) {
mx[0][i] = v[i];
mn[0][i] = c[i];
}
for (int i = 2; i < N; ++i) st[i] = st[i / 2] + 1;
for (int l = 1; l < 20; ++l)
for (int i = 1; i + (1 << l) - 1 <= n; ++i) {
mx[l][i] = max(mx[l - 1][i], mx[l - 1][i + (1 << (l - 1))]);
mn[l][i] = min(mn[l - 1][i], mn[l - 1][i + (1 << (l - 1))]);
}
vector<int> val;
for (int L = 1; L <= n; ++L) {
int l = L, r = n;
while (l < r - 5) {
int m = (l + r) / 2;
if (getmx(L, m) * 100 < getmn(L, m))
l = m;
else
r = m;
}
int cur = 0;
for (int i = l; i <= r; ++i) {
cur = max(cur, f(L, i));
}
val.push_back(cur);
}
sort(val.begin(), val.end());
long double mul = (long double)1.0 * k / n, ans = 0;
for (int i = 0; i + k - 1 < val.size(); ++i) {
ans += mul * val[i];
mul *= n - k - i;
mul /= n - 1 - i;
if (abs(mul) < 1e-30) {
break;
}
}
cout.precision(10);
cout << fixed << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long maxn = 9e18;
using namespace std;
const long long maxsize = 100000009;
void solve() {
string s;
int m, n;
cin >> n >> m >> s;
int cnt = 0;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == '.' && s[i + 1] == '.') cnt++;
}
for (int i = 0; i < m; ++i) {
int pos;
char c;
cin >> pos >> c;
pos--;
if (c == '.') {
if (s[pos] != '.') {
if (pos - 1 >= 0 && s[pos - 1] == '.') cnt++;
if (pos + 1 < n && s[pos + 1] == '.') cnt++;
s[pos] = c;
}
} else {
if (s[pos] == '.') {
if (pos - 1 >= 0 && s[pos - 1] == '.') cnt--;
if (pos + 1 < n && s[pos + 1] == '.') cnt--;
s[pos] = c;
}
}
cout << cnt << endl;
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(35);
int t;
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000 * 1000;
pair<int, int> a[MaxN];
int b[MaxN];
int t[(MaxN + 2) * 4];
int sum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return t[v];
int mid = (tl + tr) / 2;
return sum(v * 2, tl, mid, l, min(r, mid)) +
sum(v * 2 + 1, mid + 1, tr, max(l, mid + 1), r);
}
void add(int v, int tl, int tr, int pos, int val) {
if (tl == tr)
t[v] += val;
else {
int mid = (tl + tr) / 2;
if (pos <= mid)
add(v * 2, tl, mid, pos, val);
else
add(v * 2 + 1, mid + 1, tr, pos, val);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
for (int i = 0; i < n; i++) b[a[i].second] = i + 1;
long long res = 0;
for (int i = 0; i < n; i++) {
add(1, 0, n + 1, b[i], 1);
res += sum(1, 0, n + 1, b[i] + 1, n + 1) * 1ll *
(b[i] - 1 - sum(1, 0, n + 1, 0, b[i] - 1));
}
printf("%lld", res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename G>
struct triple {
G first, second, T;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<triple<long long> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
}
sort(v.begin(), v.end(), [](triple<long long> x, triple<long long> y) {
return x.first < y.first;
});
auto val = [&](long long x, bool final) {
vector<int> equal;
long long temp = 0;
for (int i = 0; i < n; i++) {
long long l = 1, r = v[i].first, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (v[i].first - 3 * mid * mid + 3 * mid - 1 >= x) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
v[i].T = ans;
temp += v[i].T;
if (final && v[i].first - 3 * ans * ans + 3 * ans - 1 == x)
equal.push_back(i);
}
if (final && temp > k) {
sort(equal.begin(), equal.end(), [&](int a, int b) {
return v[a].first - 3 * v[a].T * v[a].T + 3 * v[a].T - 1 >
v[b].first - 3 * v[b].T * v[b].T + 3 * v[b].T - 1;
});
while (!equal.empty() && temp > k) {
--temp;
--v[equal.back()].T;
equal.pop_back();
}
}
return temp;
};
long long mx = v.back().first;
long long l = -3.0 * mx * mx + 4 * mx - 1, r = mx - 1, ans = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (val(mid, false) >= k) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
val(ans, true);
sort(v.begin(), v.end(), [](triple<long long> x, triple<long long> y) {
return x.second < y.second;
});
for (int i = 0; i < n; i++) cout << v[i].T << " \n"[i == n - 1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 10;
void solve() {
int n;
cin >> n;
if (n < 4) {
cout << -1 << "\n";
return;
}
for (int i = n; i >= 1; i--) {
if (i & 1) {
cout << i << " ";
}
}
cout << 4 << " " << 2 << " ";
for (int i = 6; i <= n; i += 2) {
cout << i << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, K, Root;
int Par[1000000], Key[1000000], Left[1000000], Right[1000000];
long double Ans[1000000];
vector<int> treeKeys;
vector<pair<long long, long long> > searchKeys;
map<int, int> Bef, Aft;
vector<int> Stack;
int pos, cnt;
long long total;
void findTree(int key) {
while (Left[pos] != -1) {
if (key < Key[pos]) {
Stack.push_back(Key[pos]);
cnt++;
total += Aft[Key[pos]];
pos = Left[pos];
} else {
cnt++;
total += Bef[Key[pos]];
pos = Right[pos];
}
}
}
int main() {
int i, a;
scanf("%d", &N);
memset(Left, 255, sizeof(Left));
memset(Right, 255, sizeof(Right));
for (i = 0; i < (int)(N); i++) {
scanf("%d%d", &Par[i], &Key[i]);
if (Par[i] != -1) Par[i]--;
treeKeys.push_back(Key[i]);
}
sort(treeKeys.begin(), treeKeys.end());
for (i = 0; i < (int)(N); i++) {
if (Par[i] == -1)
Root = i;
else if (Key[Par[i]] > Key[i])
Left[Par[i]] = i;
else
Right[Par[i]] = i;
}
for (i = 0; i < (int)(((int)treeKeys.size())); i++) {
if (i < N - 1) Aft[treeKeys[i]] = treeKeys[i + 1];
if (i > 0) Bef[treeKeys[i]] = treeKeys[i - 1];
}
scanf("%d", &K);
for (i = 0; i < (int)(K); i++) {
scanf("%d", &a);
searchKeys.push_back(make_pair(a, i));
}
sort(searchKeys.begin(), searchKeys.end());
pos = Root;
cnt = 0;
total = 0;
findTree(searchKeys[0].first);
for (i = 0; i < (int)(((int)searchKeys.size())); i++) {
Ans[searchKeys[i].second] = total / (long double)cnt;
if (i == ((int)searchKeys.size()) - 1) break;
int now = searchKeys[i + 1].first;
while (((int)Stack.size()) && Stack.back() < now) {
pos = Par[pos];
if (Key[pos] == Stack.back()) {
cnt--;
total -= Aft[Key[pos]];
Stack.pop_back();
if (!((int)Stack.size()) || Stack.back() > now) break;
} else {
cnt--;
total -= Bef[Key[pos]];
}
}
findTree(now);
}
for (i = 0; i < (int)(K); i++) {
printf("%0.13lf\n", (double)Ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void file() {
freopen("read.in", "r", stdin);
freopen("write.out", "w", stdout);
}
const int N = 1e6 + 10, inf = 1e9;
inline int read() {
int sym = 0, res = 0;
char ch = getchar();
while (!isdigit(ch)) sym |= (ch == '-'), ch = getchar();
while (isdigit(ch)) res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar();
return sym ? -res : res;
}
struct node {
int dat, add, id;
bool operator<(const node a) const {
return dat == a.dat ? id < a.id : dat > a.dat;
}
} a[N];
int n, m;
bool cmp(node a, node b) { return a.dat > b.dat; }
void swap(node &a, node &b) {
node c = a;
a = b;
b = c;
}
int cal(node fa, node fb) {
int res = 0;
if (fb < fa) swap(fa, fb);
node sa = fa, sb = fb;
sa.dat += sa.add;
sb.dat += sb.add;
if (sb < sa) return 1;
if (fb < sa && sa < sb) return 2;
if (sb < fa && sa < sb) return 2;
return 0;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].dat = read();
a[i].add = read();
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans += cal(a[i], a[j]);
}
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
map<pair<long long, long long>, long long> kek;
vector<vector<long long> > g(3 * n);
vector<pair<long long, long long> > e(m);
for (long long i = 0; i < m; ++i) {
long long v, u;
cin >> v >> u;
--v;
--u;
g[v].push_back(u);
g[u].push_back(v);
e[i] = {min(v, u), max(v, u)};
kek[{min(v, u), max(v, u)}] = i + 1;
}
long long maxv = n - 1;
vector<long long> ans;
vector<long long> color(3 * n);
set<pair<long long, long long> > q;
for (long long i = 0; i < m; ++i) {
if (e[i].second <= maxv) q.insert(e[i]);
}
while (q.size()) {
long long v = q.begin()->first, u = q.begin()->second;
q.erase(q.begin());
if (color[v] == 0 && color[u] == 0) {
ans.push_back(kek[{v, u}]);
color[v] = 1;
color[u] = 1;
maxv += 2;
if (maxv < 3 * n)
for (long long j = 0; j < g[maxv].size(); ++j)
if (g[maxv][j] < maxv) q.insert({g[maxv][j], maxv});
if (maxv - 1 < 3 * n)
for (long long j = 0; j < g[maxv - 1].size(); ++j)
if (g[maxv - 1][j] < maxv) q.insert({g[maxv - 1][j], maxv - 1});
}
}
if (ans.size() >= n) {
cout << "Matching\n";
for (long long i = 0; i < n; ++i) cout << ans[i] << ' ';
cout << '\n';
return;
}
cout << "IndSet\n";
long long cnt = 0;
for (long long i = 0; i < 3 * n; ++i) {
if (cnt == n) break;
if (color[i] == 0) {
cout << i + 1 << ' ';
++cnt;
}
}
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t) {
--t;
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
bool all9(int n) {
while (n) {
if (n % 10 != 9) return false;
n /= 10;
}
return true;
}
int noDigit(int n) {
int ans = 0;
while (n) ++ans, n /= 10;
return ans;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
if (n < 5) {
cout << n * (n - 1) / 2 << '\n';
return 0;
}
int sum = n + (n - 1);
if (all9(sum)) {
cout << 1 << '\n';
return 0;
}
int ans = 0;
int p = noDigit(sum);
p--;
long long curr_sum = (int)pow(10, p) - 1;
while (curr_sum <= sum) {
if (curr_sum <= n)
ans += curr_sum / 2;
else
ans += n - curr_sum / 2;
curr_sum += (int)pow(10, p);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Num {
int x, y, no;
} num[25];
bool cmp1(Num x1, Num x2) { return x1.x < x2.x; }
bool cmp2(Num x1, Num x2) { return x1.no < x2.no; }
int main() {
bool flag = 0;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i].x);
num[i].no = i;
}
sort(num + 1, num + 1 + n, cmp1);
for (int i = 1; i < n; i++) num[i].y = num[i + 1].x;
num[n].y = num[1].x;
if (n > 1) {
for (int i = 1; i <= n; i++) {
if (num[i].x == num[i].y) flag = 1;
}
}
if (flag)
printf("-1\n");
else {
sort(num + 1, num + 1 + n, cmp2);
for (int i = 1; i < n; i++) printf("%d ", num[i].y);
printf("%d\n", num[n].y);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxinput = 305;
const long long mod = 1000000007;
int inf = 1e9 + 7;
int n, mat[maxinput][maxinput];
int dp[maxinput][maxinput][maxinput];
int maxpoint(int i1, int j1, int i2) {
int j2 = i1 + j1 - i2;
if (i1 >= n || j1 >= n || i2 >= n || j2 >= n) return (-inf);
if (dp[i1][j1][i2] != -1) return (dp[i1][j1][i2]);
int points = 0;
if (i1 == i2 && j1 == j2) {
points += mat[i1][j1];
if (i1 == n - 1 && j1 == n - 1) return (points);
} else
points += mat[i1][j1] + mat[i2][j2];
return (dp[i1][j1][i2] =
points +
max({maxpoint(i1 + 1, j1, i2), maxpoint(i1 + 1, j1, i2 + 1),
maxpoint(i1, j1 + 1, i2), maxpoint(i1, j1 + 1, i2 + 1)}));
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> mat[i][j];
cout << maxpoint(0, 0, 0) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
long long x1, y1, x2, y2, i, j, k, a, b, c;
cin >> x1 >> y1 >> x2 >> y2;
long long n;
cin >> n;
long long ct = 0;
while (n--) {
cin >> a >> b >> c;
long long dx = a * x1 + b * y1 + c;
long long dy = a * x2 + b * y2 + c;
if ((dx > 0 && dy < 0) || (dx < 0 && dy > 0)) ct++;
}
cout << ct << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v[100010];
int n, m;
vector<tuple<int, int, int> > vt;
int main() {
cin >> n >> m;
for (int i = 0, u, vv, w; i < m; i++) {
cin >> u >> vv >> w;
vt.emplace_back(u, vv, w);
}
for (int i = 0; i < m; i++) {
int vec[4];
tie(vec[0], vec[1], vec[2]) = vt[i];
bool col[4];
col[0] = col[1] = col[2] = col[3] = 0;
for (int i = 0; i < 3; i++) col[v[vec[i]]] = 1;
for (int j = 0; j < 3; j++) {
if (v[vec[j]] == 0) {
for (int k = 1; k <= 3; k++) {
if (!col[k]) {
col[k] = true, v[vec[j]] = k;
break;
}
}
}
}
}
for (int i = 1; i <= n; i++) cout << v[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long f(unsigned long long k) {
if (k == 0) return 0;
return k * (k - 1) / 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int m;
cin >> m;
map<int, vector<pair<int, string> > > mp;
for (int i = 0; i < n; ++i) {
string str;
cin >> str;
int reg;
cin >> reg;
int rate;
cin >> rate;
mp[reg].push_back(make_pair(rate, str));
}
for (int i = 1; i <= m; ++i) {
sort(mp[i].begin(), mp[i].end(),
[](const pair<int, string>& l, const pair<int, string>& r) -> bool {
return l.first > r.first;
});
if (mp[i].size() > 2 && mp[i][1].first == mp[i][2].first) {
cout << "?\n";
} else
cout << mp[i][0].second << " " << mp[i][1].second << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct item {
item *l, *r;
int key, prior, cnt;
long long sum;
item(int key) : key(key), cnt(1), sum(key), l(0), r(0), prior(rand()) {}
} * pitem;
void print(pitem t) {
if (!t) return;
print(t->l);
printf("%d ", t->key);
print(t->r);
}
int cnt(pitem t) { return t ? t->cnt : 0; }
long long sum(pitem t) { return t ? t->sum : 0; }
void upd(pitem t) {
if (!t) return;
t->cnt = cnt(t->l) + cnt(t->r) + 1;
t->sum = t->key + sum(t->l) + sum(t->r);
}
void merge(pitem &t, pitem l, pitem r) {
if (!l || !r) return (void)(t = l ? l : r);
if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upd(t);
}
void split(pitem t, pitem &l, pitem &r, int key) {
if (!t) return (void)(l = r = 0);
if (t->key > key)
split(t->l, l, t->l, key), r = t;
else
split(t->r, t->r, r, key), l = t;
upd(l);
upd(r);
}
void insert(pitem &t, int key) {
pitem l = 0;
split(t, l, t, key);
merge(l, l, new item(key));
merge(t, l, t);
}
void erase(pitem &t, int key) {
pitem l = 0, r = 0;
split(t, l, t, key - 1);
split(t, t, r, key);
merge(t, t->l, t->r);
merge(t, l, t);
merge(t, t, r);
}
long long getLastKSum(pitem t, int k) {
if (!t || !k) return 0;
if (cnt(t) <= k) return t->sum;
if (cnt(t->r) >= k) return getLastKSum(t->r, k);
return sum(t->r) + t->key + getLastKSum(t->l, k - cnt(t->r) - 1);
}
pitem positive, negative;
const int MAXN = 200000;
int n, k, len;
int a[MAXN];
long long res;
int main() {
scanf("%d%d", &n, &len);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
scanf("%d", &k);
for (int i = 0; i < len; ++i) {
if (a[i] < 0) insert(negative, -a[i]);
if (a[i] > 0) insert(positive, a[i]);
res += a[i];
}
for (int i = 0; i <= n - len; ++i) {
if (i != 0) {
if (a[i - 1] < 0) erase(negative, -a[i - 1]);
if (a[i - 1] > 0) erase(positive, a[i - 1]);
if (a[i + len - 1] < 0) insert(negative, -a[i + len - 1]);
if (a[i + len - 1] > 0) insert(positive, a[i + len - 1]);
}
long long s = sum(positive) - sum(negative);
res = max(res, max(abs(s - 2 * getLastKSum(positive, k)),
abs(s + 2 * getLastKSum(negative, k))));
}
printf("%I64d", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct fun {
int s, f, t;
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N, M, K, x;
cin >> N >> M >> K;
int a[N + 2];
for (int i = 1; i <= N; i++) {
cin >> a[i];
}
struct fun a1[M];
for (int i = 0; i < M; i++) {
cin >> a1[i].f >> a1[i].s >> a1[i].t;
}
for (int i = 0; i < K; i++) {
cin >> x;
for (int j = M - 1; j >= 0; j--) {
if (x >= a1[j].s && x <= a1[j].t) {
if (a1[j].f == 1) {
x -= 1;
if (x < a1[j].s) {
x = a1[j].t;
}
} else {
int t1 = x - a1[j].s;
x = a1[j].t - t1;
}
}
}
cout << a[x] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = (int)5e3;
const int inf = 0x3f3f3f3f;
string s;
bool check(int l, int r) {
while (l <= r && s[l] == s[r]) ++l, --r;
return l >= r;
}
void work() {
int n = s.size();
int l1 = 0, r1 = n - 1, l2, r2;
while (l1 <= r1 && s[l1] == s[r1]) ++l1, --r1;
if (l1 >= r1) {
cout << s << endl;
return;
}
for (l2 = l1; l2 <= r1; ++l2)
if (check(l2, r1)) break;
for (r2 = r1; r2 >= l1; --r2)
if (check(l1, r2)) break;
cout << s.substr(0, l1);
if (r1 - l2 > r2 - l1)
cout << s.substr(l2, r1 - l2 + 1);
else
cout << s.substr(l1, r2 - l1 + 1);
cout << s.substr(r1 + 1) << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
for (int ca = 1; ca <= T; ++ca) {
cin >> s;
work();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
long long power(long long x, long long y, long long mod) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, t, k, d;
cin >> n >> t >> k >> d;
long long x = (n + k - 1) / k;
x *= t;
long long temp = (d + t - 1) / t;
temp *= k;
long long lim = n - temp;
long long a = t * ((d + t - 1) / t), b = d;
long long y = a;
while (lim > 0) {
lim -= k;
b += t;
y = b;
if (lim > 0) {
lim -= k;
a += t;
y = a;
}
}
if (x <= y)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
const long long INF = 1e18 + 5;
pair<long long, long long> arr[MAXN];
long long dp[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
for (int i = 0; i < int(MAXN); i++) dp[i] = INF;
int n;
cin >> n;
for (int i = 0; i < int(n); i++) {
int t, c;
cin >> t >> c;
arr[i] = {t, c};
}
dp[0] = 0;
for (int i = 0; i < int(n); i++)
for (int j = int(n + 1) - 1; j >= 0; j--)
if (j - arr[i].first - 1 >= 0)
dp[j] = min(dp[j], dp[j - arr[i].first - 1] + arr[i].second);
else
dp[j] = min(dp[j], arr[i].second);
cout << dp[n];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> c(n + 1, 0);
for (int i = 0; i < m; i++) {
int id = -1, max = -1;
for (int j = 0; j < n; j++) {
int a;
cin >> a;
if (a > max) {
max = a;
id = j;
}
}
if (id != -1) c[id]++;
}
int id, max = 0;
for (int i = 0; i < n; i++) {
if (c[i] > max) {
id = i;
max = c[i];
}
}
cout << id + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<string> bg(n - 2);
for (int i = 0; i < n - 2; ++i) {
cin >> bg[i];
}
int idx = -1;
for (int i = 1; i < bg.size(); ++i) {
if (bg[i - 1][1] != bg[i][0]) {
idx = i;
break;
}
}
string res = "";
for (int i = 0; i < bg.size(); ++i) {
if (i == bg.size() - 1) {
res += bg[i];
} else {
res += bg[i][0];
}
}
if (idx == -1) {
res += 'a';
} else {
res.insert(idx, bg[idx - 1].substr(1, 1));
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
vector<pair<long long int, pair<long long int, long long int> > > vp;
map<long long int, long long int> mp, mpp;
vector<long long int> v, v1, v2;
long long int dp[N], visit[N], dpp[N];
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::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...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, val, k, d, mi = 1e9, mx(0);
long long int sum(0), ct(0), p(0), q(0);
string s;
cin >> n >> m >> k;
long long int a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
p = m;
while (p--) {
long long int l, r, z;
cin >> l >> r >> z;
vp.push_back({l, {r, z}});
}
while (k--) {
int x, y;
cin >> x >> y;
dp[x]++;
dp[y + 1]--;
}
for (int i = 1; i <= m; i++) {
dp[i] += dp[i - 1];
}
for (int i = 0; i < vp.size(); i++) {
long long int x = vp[i].first;
long long int y = vp[i].second.first;
long long int z = 1LL * vp[i].second.second * dp[i + 1];
dpp[x] += z;
dpp[y + 1] -= z;
}
for (int i = 1; i <= n; i++) {
dpp[i] += dpp[i - 1];
}
for (int i = 1; i <= n; i++) cout << dpp[i] + a[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[100006];
int dp[506][506];
int Rec_DP(int l, int r) {
if (dp[l][r]) return dp[l][r];
if (l == r) {
return dp[l][r] = 1;
}
if (l >= r) {
return dp[l][r] = 0;
}
if (r - l == 1 && x[l] == x[r]) {
return 1;
}
if (x[l] == x[l + 1]) {
dp[l][r] = min(1 + Rec_DP(l + 2, r), 1 + Rec_DP(l + 1, r));
} else {
dp[l][r] = 1 + Rec_DP(l + 1, r);
}
for (int i = l + 2; i <= r; i++) {
if (x[l] == x[i]) {
dp[l][r] = min(dp[l][r], Rec_DP(l + 1, i - 1) + Rec_DP(i + 1, r));
}
}
return dp[l][r];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
cout << Rec_DP(1, n);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, nega = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') nega = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum * nega;
}
int m, n, k;
double ans = 1;
int main() {
n = read(), m = read(), k = read();
if (k >= m) {
puts("1.0000");
return 0;
} else if (m > n + k) {
puts("0.0000");
return 0;
}
for (int i = 1; i <= k + 1; i++)
ans = ans * 1.0 / (n + i) * 1.0 * (m - k - 1 + i) * 1.0;
printf("%.12lf\n", 1 - ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long> p(n + 1, 1);
for (int i = 1; i <= n; ++i) p[i] = p[i - 1] * 7;
vector<long long> h(n + 1, 0);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
h[x] += p[y];
h[y] += p[x];
}
vector<long long> hh(n + 1, 0);
for (int i = 0; i <= n; ++i) {
hh[i] = h[i] + p[i];
}
sort(h.begin() + 1, h.end());
sort(hh.begin() + 1, hh.end());
long long res = 0;
for (int i = 1, cnt = 0; i <= n; ++i) {
if (h[i] == h[i - 1])
res += cnt++;
else
cnt = 1;
}
for (int i = 1, cnt = 0; i <= n; ++i) {
if (hh[i] == hh[i - 1])
res += cnt++;
else
cnt = 1;
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10001, oo = (1 << 29);
int n;
int arr[N];
int r = 5000, c = -1, mxUp = r, mxDown = r;
bool up = true;
char g[N][N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
for (int i = 0; i < n; ++i) {
int temp = arr[i];
if (up) {
if (temp == 1) {
g[r][++c] = '/';
} else {
g[r][++c] = '/';
while (temp > 1) {
g[--r][++c] = '/';
--temp;
}
}
mxUp = min(mxUp, r);
} else {
if (temp == 1) {
g[r][++c] = '\\';
} else {
g[r][++c] = '\\';
while (temp > 1) {
g[++r][++c] = '\\';
--temp;
}
}
mxDown = max(mxDown, r);
}
up = !up;
}
for (int i = mxUp; i <= mxDown; ++i) {
for (int j = 0; j <= c; ++j)
printf("%c", ((g[i][j] != '\\' && g[i][j] != '/') ? ' ' : g[i][j]));
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T a) {
return a * a;
}
const int MAX_N = 1e5 + 10;
const long long INF = 1e18;
int N;
long long A[MAX_N];
inline int prev(int k) { return k ? k - 1 : N - 1; }
bool Used[MAX_N];
int main() {
int X;
scanf("%d%d", &N, &X);
--X;
long long Min = INF;
for (int i = 0; i < (N); ++i) scanf("%I64d", &A[i]), Min = min(A[i], Min);
int ans = X, res = 0;
for (; A[ans] > Min; ans = prev(ans), ++res) A[ans] -= Min + 1, Used[ans] = 1;
int i = ans;
for (; !Used[i]; i = prev(i)) A[i] -= Min, Used[i] = 1;
A[ans] = N * Min + res;
for (int i = 0; i < (N); ++i) printf("%I64d ", A[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline", "no-stack-protector")
using namespace std;
long long read() {
long long x;
char c(getchar());
bool k;
while (!isdigit(c) && c ^ '-')
if ((c = getchar()) == EOF) exit(0);
if (c ^ '-')
k = 1, x = c & 15;
else
k = x = 0;
while (isdigit((c = getchar()))) x = (x << 1) + (x << 3) + (c & 15);
return k ? x : -x;
}
void wr(long long a) {
if (a < 0) putchar('-'), a = -a;
if (a <= 9)
putchar(a | '0');
else
wr(a / 10), putchar((a % 10) | '0');
}
signed const INF(0x3f3f3f3f), NINF(0xc3c3c3c3);
long long const LINF(0x3f3f3f3f3f3f3f3fLL), LNINF(0xc3c3c3c3c3c3c3c3LL);
long long n, m, a, ans, b[(200010)], pw;
long long fpw(long long a, long long b) {
a %= (998244353);
long long r(1);
while (b)
b& 1 ? r = r * a % (998244353) : 0, a = a * a % (998244353), b >>= 1;
return r;
}
signed main() {
(n = read()), (m = read()), a = read() % (998244353);
for (long long i(1); i <= (m); ++i) (b[i] = read());
ans = fpw(a, n - (b[m] << 1));
for (long long i(1); i <= (m); ++i) {
pw = fpw(a, b[i] - b[i - 1]);
ans = (pw & 1 ? ((pw + 1) >> 1) * pw : (pw >> 1) * (pw + 1)) % (998244353) *
ans % (998244353);
}
wr(ans), exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long Getint() {
char ch = getchar();
long long fh = 1, x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') (x *= 10) += ch ^ 48, ch = getchar();
return fh * x;
}
const int Mod = 998244353;
const long long inv2 = Mod + 1 >> 1;
int lst, n, m, rev[800005];
long long A[800005], B[800005], C[800005], wi[800005];
inline long long Fastpow(long long x, long long y) {
long long tmp = 1;
while (y) {
if (y & 1) tmp = tmp * x % Mod;
x = x * x % Mod;
y >>= 1;
}
return tmp;
}
inline int Make(int len) { return 1 << int(ceil(log2(len))); }
inline int Trans(int len) {
int l = ceil(log2(len));
len = 1 << l;
for (int i = 1; i < len; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << l - 1);
return lst = len;
}
inline void NTT(long long F[], int len, int f) {
if (lst != len) Trans(len);
for (int i = 1; i < len; i++)
if (rev[i] < i) swap(F[rev[i]], F[i]);
for (int i = 1; i < len; i <<= 1) {
long long wn = Fastpow(3, f * (Mod - 1) / (i << 1) + Mod - 1);
wi[0] = 1;
for (int j = 1; j < i; j++) wi[j] = wi[j - 1] * wn % Mod;
for (int j = 0; j < len; j += i << 1) {
for (int k = 0; k < i; k++) {
long long x = F[j + k], y = F[i + j + k] * wi[k] % Mod;
F[j + k] = (x + y) % Mod;
F[i + j + k] = (x - y + Mod) % Mod;
}
}
}
if (f == 1) return;
long long wn = Fastpow(len, Mod - 2);
for (int i = 0; i < len; i++) F[i] = F[i] * wn % Mod;
}
long long Pinv[800005];
inline void Inverse(long long F[], long long G[], int len) {
if (len == 1) {
F[0] = Fastpow(G[0], Mod - 2);
return;
}
Inverse(F, G, len >> 1);
int l = len << 1;
for (int i = 0; i < len; i++) Pinv[i] = G[i];
for (int i = len; i < l; i++) Pinv[i] = 0;
for (int i = len >> 1; i < l; i++) F[i] = 0;
NTT(Pinv, l, 1);
NTT(F, l, 1);
for (int i = 0; i < l; i++)
F[i] = F[i] * (2 - Pinv[i] * F[i] % Mod + Mod) % Mod;
NTT(F, l, -1);
for (int i = len; i < l; i++) F[i] = 0;
}
long long Psq1[800005], Psq2[800005];
inline void Sqrt(long long F[], long long G[], int len) {
if (len == 1) {
F[0] = sqrt(G[0]);
return;
}
Sqrt(F, G, len >> 1);
int l = len << 1;
for (int i = len >> 1; i < len; i++) F[i] = 0;
Inverse(Psq1, F, len);
for (int i = 0; i < len; i++) Psq2[i] = G[i];
for (int i = len; i < l; i++) Psq1[i] = Psq2[i] = F[i] = 0;
NTT(Psq1, l, 1);
NTT(Psq2, l, 1);
NTT(F, l, 1);
for (int i = 0; i < l; i++)
F[i] = (F[i] * F[i] % Mod + Psq2[i]) % Mod * inv2 % Mod * Psq1[i] % Mod;
NTT(F, l, -1);
for (int i = len; i < l; i++) F[i] = 0;
}
int main() {
int x, y, z;
m = Getint();
n = Getint();
for (int i = 1; i <= m; i++)
if ((x = Getint()) <= n) C[x] = 1;
for (int i = 0; i <= n; i++) A[i] = (Mod - 4 * C[i] % Mod) % Mod;
int len = Make(n + 1 << 1);
(++A[0]) %= Mod;
for (int i = n; i >= 0; i--)
if (C[i]) x = i;
for (int i = 0; i <= n; i++) C[i] = C[i + x];
Sqrt(B, A, len);
Inverse(A, C, len);
for (int i = 0; i < len; i++) B[i] = (Mod - B[i]) % Mod;
(++B[0]) %= Mod;
int l = len << 1;
for (int i = len; i < l; i++) A[i] = B[i] = 0;
NTT(B, l, 1);
NTT(A, l, 1);
for (int i = 0; i < l; i++) A[i] = A[i] * B[i] % Mod;
NTT(A, l, -1);
for (int i = x; i < l; i++) A[i - x] = A[i];
for (int i = 1; i <= n; i++) cout << inv2 * A[i] % Mod << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 1e5 + 2;
const int M = 1 << 19;
const int inf = 2e9;
const long long linf = 1e18;
long long n, m, k;
int ok(long long mid) {
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += min(m, mid / i);
}
return ans >= k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
long long l = 1, r = n * m, ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
if (ok(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct Fraction {
int a, b;
Fraction(int a, int b) {
if (b < 0) {
a = -a;
b = -b;
}
}
Fraction() {
a = 0;
b = 1;
}
bool operator<(const Fraction x) const { return a * x.b < b * x.a; }
};
struct Line {
int a, b;
int eval(int x) { return a * x + b; }
};
const int MAX_N = 80;
const int INF = MAX_N * MAX_N;
int dp[2][1 + MAX_N + 1][1 + MAX_N * MAX_N];
int pos[1 + MAX_N + 1];
bool take_out(Line a, Line b, Line c) {
return Fraction(b.a - c.a, c.b - b.b) < Fraction(a.a - b.a, b.b - a.b);
}
struct Cht {
std::deque<Line> lines;
void push_line(Line x) {
if (lines.size() <= 1)
lines.push_back(x);
else {
while (lines.size() >= 2 &&
take_out(lines[lines.size() - 2], lines[lines.size() - 1], x))
lines.pop_back();
lines.push_back(x);
}
}
int query(int x) {
while (lines.size() >= 2 && lines[1].eval(x) <= lines[0].eval(x))
lines.pop_front();
if (lines.size() == 0) return INF;
return lines[0].eval(x);
}
};
int main() {
int n, k = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (x == 1) pos[++k] = i;
}
pos[++k] = n + 1;
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= n * (n - 1) / 2; ++j) dp[0][i][j] = INF;
dp[0][0][0] = 0;
for (int ik = 1; ik <= k; ++ik) {
int p = ik % 2;
for (int moves = 0; moves <= n * (n - 1) / 2; ++moves) {
Cht cht;
for (int t = 0; t <= n + 1; ++t) {
dp[p][t][moves] = INF;
int delta = abs(t - pos[ik]);
if (moves >= delta) {
for (int t2 = 0; t2 < t; ++t2)
dp[p][t][moves] =
std::min(dp[p][t][moves], dp[1 - p][t2][moves - delta] +
(t - t2) * (t - t2 - 1) / 2);
}
}
}
}
for (int i = 0; i <= n * (n - 1) / 2; ++i) {
if (i > 0)
dp[k % 2][n + 1][i] =
std::min(dp[k % 2][n + 1][i], dp[k % 2][n + 1][i - 1]);
printf("%d ", (n + 1 - k) * (n + 2 - k) / 2 - dp[k % 2][n + 1][i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
if (360 / (180 - arr[i]) * arr[i] == 180 * (360 / (180 - arr[i]) - 2)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.