solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m;
vector<int> adj[10000];
unordered_map<string, int> um;
unordered_map<int, int> common[10000];
string names[10000];
struct Solution {
vector<int> solve() {
vector<int> res(n);
for (int(i) = (0); (i) < (n); ++(i)) {
int count[10000] = {0};
count[i] = -1;
for (int j : adj[i]) count[j] = -1;
for (int j : adj[i]) {
for (int k : adj[j]) {
if (k != i && count[k] != -1) count[k]++;
}
}
int best = 0;
for (int(j) = (0); (j) < (n); ++(j)) {
int c = count[j];
if (c > best) best = c, res[i] = 0;
if (c == best) res[i]++;
}
}
return res;
}
};
void print(vector<int>& nums) {
for (auto num : nums) cout << num << " ";
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> m;
string s, t;
for (int(i) = (0); (i) < (m); ++(i)) {
cin >> s >> t;
if (!um.count(s)) um[s] = n++;
if (!um.count(t)) um[t] = n++;
int a = um[s], b = um[t];
names[a] = s, names[b] = t;
adj[a].push_back(b), adj[b].push_back(a);
}
Solution test;
auto res = test.solve();
cout << res.size() << endl;
for (int(i) = (0); (i) < (n); ++(i))
cout << names[i] << " " << res[i] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
if ((a[i] == 3 && a[i - 1] == 2) || (a[i] == 2 && a[i - 1] == 3) ||
(a[i] == a[i - 1])) {
cout << "Infinite";
return 0;
}
}
cout << "Finite\n";
int cnt = 0;
for (int i = 0; i < n; i++) {
if (i == 0) continue;
if (a[i] == 1 && a[i - 1] == 2) {
cnt += 3;
} else if (a[i] == 1 && a[i - 1] == 3) {
cnt += 4;
} else if (a[i] == 2 && a[i - 1] == 1) {
cnt += 3;
} else if (a[i] == 3 && a[i - 1] == 1) {
cnt += 4;
}
}
for (int i = 0; i + 2 < n; i++) {
if (a[i] == 3 && a[i + 1] == 1 && a[i + 2] == 2) cnt--;
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 5;
int a[MAX_N], cnt[MAX_N];
int main() {
int n, s;
scanf("%d%d", &n, &s);
s--;
int ans = 0;
int curMax = 0;
for (int i = 0; (i) < (n); ++i) {
scanf("%d", &a[i]);
if (i == s && a[i] != 0) a[i] = 0, ans++;
cnt[a[i]]++, curMax = max(curMax, a[i]);
}
int bad = 0;
for (int i = 0; (i) < (n); ++i)
if (i != s && a[i] == 0) bad++;
int curCnt = 0;
int zero = 0, dubls = 0, bestAns = 1e9;
for (int h = (0); (h) < (n + 1); ++h) {
curCnt += cnt[h];
dubls += max(0, cnt[h] - 1);
zero += (cnt[h] == 0);
int liars = n - curCnt;
if (bad + liars + dubls >= zero) {
bestAns = min(bestAns, ans + bad + liars + max(zero - bad - liars, 0));
}
}
printf("%d\n", bestAns);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535;
const double eps = 1e-6;
string kong = "";
int f[100000][2], win[100000], suan[100000];
void update(int &a, int &b, int &c, int A, int B, int C) {
if (A > a || A == a && B > b || A == a && B == b && C < c) {
a = A, b = B, c = C;
}
}
vector<string> rec;
int index(string a) {
return lower_bound(rec.begin(), rec.end(), a) - rec.begin();
}
void dfs(int a) {
if (win[a] != -1) return;
int won = 0, fir = 0, sec = 0;
for (char c = 'a'; c <= 'z'; c++) {
int nu = index(kong + rec[a] + c);
if (rec[nu] == kong + rec[a] + c) {
dfs(nu);
update(won, fir, sec, win[nu] ^ 1, f[nu][1] + suan[nu], f[nu][0]);
}
nu = index(kong + c + rec[a]);
if (rec[nu] == kong + c + rec[a]) {
dfs(nu);
update(won, fir, sec, win[nu] ^ 1, f[nu][1] + suan[nu], f[nu][0]);
}
}
f[a][0] = fir, f[a][1] = sec, win[a] = won;
}
int n;
string s, whi[100], S;
int main() {
cin >> n;
rec.push_back("");
rec.push_back("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
for (int i = 0; i < n; i++) {
cin >> s;
whi[i] = s;
for (int j = 0; j < s.size(); j++) {
S = "";
for (int k = j; k < s.size(); k++) {
S += s[k];
rec.push_back(S);
}
}
}
memset(win, -1, sizeof(win));
sort(rec.begin(), rec.end());
rec.erase(unique(rec.begin(), rec.end()), rec.end());
for (int i = 0; i < rec.size(); i++) {
int ap = 0;
for (int j = 0; j < n; j++)
if (whi[j].find(rec[i]) != -1) ap++;
int su = 0, ma = 0;
for (int j = 0; j < rec[i].size(); j++) {
su += rec[i][j] - 'a' + 1;
ma = max(ma, rec[i][j] - 'a' + 1);
}
suan[i] = ma * su + ap;
}
dfs(index(""));
if (win[index("")])
puts("First");
else
puts("Second");
printf("%d %d\n", f[index("")][0], f[index("")][1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long flow[300005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
for (int i = 1; i < m + 1; i++) {
long long x, y, w;
cin >> x >> y >> w;
flow[x] += w;
flow[y] -= w;
}
vector<long long> vx, vy, vw, ansx, ansy;
for (int i = 1; i < n + 1; i++) {
if (flow[i] > 0) {
vx.push_back(i);
} else if (flow[i] < 0) {
vy.push_back(i);
}
}
int i = 0, j = 0;
while (i < vx.size() && j < vy.size()) {
long long x = flow[vx[i]];
long long y = flow[vy[j]];
if (x >= -y) {
ansx.push_back(vx[i]);
ansy.push_back(vy[j]);
flow[vx[i]] += y;
flow[vy[j]] = 0;
vw.push_back(-y);
} else {
ansx.push_back(vx[i]);
ansy.push_back(vy[j]);
flow[vx[i]] = 0;
flow[vy[j]] += x;
vw.push_back(x);
}
if (flow[vx[i]] == 0) i++;
if (flow[vy[j]] == 0) j++;
}
cout << ansx.size() << '\n';
for (int i = 0; i < ansx.size(); i++) {
cout << ansx[i] << " " << ansy[i] << " " << vw[i] << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, n, a[100005], m, cnt = 0;
int main() {
cin >> n;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
i = 1;
while (i < n) {
int pos = upper_bound(a + i + 1, a + n + 1, a[i]) - a, t = a[i], c, j, cc;
c = pos - i >> 1;
cc = c;
j = pos;
while (cc) {
cc--;
j--;
a[j] = t + 1;
}
i = j;
while (c) {
c--;
j--;
a[j] = -1;
}
}
for (i = 1; i <= n; i++)
if (a[i] != -1) cnt++;
cout << a[n] - cnt + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool graf[100][100];
int n, m;
bool visited[100];
bool spoken[100];
int stupid;
int tab[100];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 0) stupid++;
for (int j = 0; j < x; j++) {
cin >> tab[j];
tab[j]--;
spoken[tab[j]] = true;
}
for (int j = 0; j < x; j++) {
for (int q = j + 1; q < x; q++) {
graf[tab[j]][tab[q]] = true;
graf[tab[q]][tab[j]] = true;
}
}
}
queue<int> q;
int add = 0;
for (int i = 0; i < m; i++) {
if (!spoken[i] || visited[i]) continue;
q.push(i);
visited[i] = true;
add++;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int j = 0; j < m; j++) {
if (graf[v][j] && !visited[j]) {
visited[j] = true;
q.push(j);
}
}
}
}
if (add > 0) add--;
stupid += add;
cout << stupid << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t, n, a, b, c, d;
cin >> t;
while (t--) {
cin >> n;
vector<int> v(n), w(n);
d = 0;
int e = 0, j = 0;
for (int i = 0; i < n; i++) cin >> v[i];
a = v[0], b = v[1];
for (int i = 2; i < n; i++) {
c = v[i];
if ((b > a and v[i] > b) or (a > b and b > v[i]))
b = v[i];
else {
w[j++] = a, a = b, b = c;
}
}
w[j++] = a;
w[j++] = b;
cout << j << endl;
for (int i = 0; i < j; i++) cout << w[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct dot {
int x, y;
} e[2005 * 2005];
struct ttt {
int x, y;
char c;
} ur[2005];
int T, n, i, j, k, ans, las, a[2005], cnt, f0, f1, dp[2005][2005], tot, x[2005],
y[2005], g[2005], f[2005][2005], pm[2005][2005];
char s[2005][2005];
inline bool cmp(int xx, int yy) {
int i1 = x[xx], j1 = y[xx], i2 = x[yy], j2 = y[yy];
while (i1 + j1 <= n + n) {
if (s[i1][j1] != s[i2][j2]) return s[i1][j1] < s[i2][j2];
if (f[i1][j1])
++j1;
else
++i1;
if (f[i2][j2])
++j2;
else
++i2;
}
return 0;
}
inline bool CC(dot aa, dot bb) { return aa.x + aa.y < bb.x + bb.y; }
inline bool ccmp(ttt aa, ttt bb) {
return aa.c == bb.c ? (min(pm[aa.x + 1][aa.y], pm[aa.x][aa.y + 1]) <
min(pm[bb.x + 1][bb.y], pm[bb.x][bb.y + 1]))
: aa.c < bb.c;
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) e[++tot].x = i, e[tot].y = j;
sort(e + 1, e + tot + 1, CC);
pm[n][n] = 0;
for (i = 1; i <= n + 1; ++i) pm[i][n + 1] = pm[n + 1][i] = 1e9;
for (i = tot - 1; i; --i) {
if (e[i].x + e[i].y != e[i + 1].x + e[i + 1].y) {
for (f0 = 0, j = i + 1; j <= las; ++j) {
++f0;
ur[f0].c = s[e[j].x][e[j].y];
ur[f0].x = e[j].x;
ur[f0].y = e[j].y;
}
sort(ur + 1, ur + f0 + 1, ccmp);
f1 = 0;
for (j = 2; j <= f0; ++j) {
if (ur[j].c != ur[j - 1].c ||
(min(pm[ur[j].x + 1][ur[j].y], pm[ur[j].x][ur[j].y + 1]) !=
min(pm[ur[j - 1].x + 1][ur[j - 1].y],
pm[ur[j - 1].x][ur[j - 1].y + 1])))
++f1;
pm[ur[j].x][ur[j].y] = f1;
}
las = i;
}
}
for (i = 1; i < n; ++i) f[i][n] = 0, f[n][i] = 1;
for (i = 1; i < n; ++i) {
for (j = 1; j < n; ++j) {
if (s[i + 1][j] > s[i][j + 1])
f[i][j] = 1;
else if (s[i + 1][j] < s[i][j + 1])
f[i][j] = 0;
else {
if (pm[i + 1][j] > pm[i][j + 1])
f[i][j] = 1;
else
f[i][j] = 0;
}
}
}
for (i = 1; i <= n; ++i) dp[1][i] = dp[1][i - 1] + (s[1][i] == 'a');
for (i = 2; i <= n; ++i) {
dp[i][1] = dp[i - 1][1] + (s[i][1] == 'a');
for (j = 2; j <= n; ++j) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + (s[i][j] == 'a');
}
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (i + j - 1 - dp[i][j] <= k) ans = max(ans, i + j);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j)
if (i + j > ans && i - 2 + j - max(dp[i - 1][j], dp[i][j - 1]) == k)
x[++cnt] = i, y[cnt] = j, g[cnt] = cnt;
}
sort(g + 1, g + cnt + 1, cmp);
for (i = 1; i < ans; ++i) cout << "a";
i = x[g[1]];
j = y[g[1]];
if (i + j > ans) {
while (i + j <= n + n) {
cout << s[i][j];
if (f[i][j])
++j;
else
++i;
}
}
}
| 5 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7ffffffffffffff;
const double eps = 1e-8;
unsigned int seed = 19260817;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
__inline__ __attribute__((always_inline)) bool _cmp(const double &a,
const double &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool ismax(_Tp &a, const _Tp &b) {
return a >= b ? 1 : a = b, 0;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool ismin(_Tp &a, const _Tp &b) {
return a <= b ? 1 : a = b, 0;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch < 65 || ch > 122 || (ch > 90 && ch < 97)) ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005, mod = 1000000007;
__inline__ __attribute__((always_inline)) void add(int &a, const int &b) {
(a += b) >= mod && (a -= mod);
}
const int size = 101;
struct matrix {
int a[103][103];
__inline__ __attribute__((always_inline)) matrix() {
memset(a, 0, sizeof(a));
}
matrix operator*(const matrix &b) const {
matrix c;
for (int i = 1; i <= size; ++i) {
for (int k = 1; k <= size; ++k) {
for (int j = 1; j <= size; ++j) {
add(c.a[i][j], 1ll * a[i][k] * b.a[k][j] % mod);
}
}
}
return c;
}
};
matrix ksm(matrix a, int b) {
matrix res;
for (int i = 1; i <= size; ++i) res.a[i][i] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a, b >>= 1;
}
return res;
}
int main() {
matrix cs, f;
int n, X, x;
read(n, X);
for (int i = 1; i <= n; ++i) {
read(x);
++f.a[x][1];
++f.a[x][101];
}
++f.a[101][101];
for (int i = 2; i <= 100; ++i) {
f.a[i - 1][i] = 1;
}
cs.a[1][1] = 1;
cs.a[1][101] = 1;
matrix ans = cs * ksm(f, X);
printf("%d\n", ans.a[1][101]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'r') {
printf("%d\n", i + 1);
} else {
v.push_back(i + 1);
}
}
while (v.size()) {
printf("%d\n", v[v.size() - 1]);
v.pop_back();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 20;
const long long inf = 1e10;
int d[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
d[u]++;
d[v]++;
}
bool ok = true;
int cntl = 0;
for (int i = 1; i <= n; i++)
if (d[i] == 2) ok = false;
if (ok)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
int a[MAXN];
int dp[MAXN][2005];
bool check(int n, int len) {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= len; ++j) {
if (i == 0)
dp[i][j] = 1;
else
dp[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= len; ++j) {
if (dp[i - 1][j]) {
if (j + a[i] <= len) dp[i][j + a[i]] = 1;
if (j - a[i] >= 0) dp[i][j - a[i]] = 1;
}
}
}
for (int j = 0; j <= len; ++j)
if (dp[n][j]) return true;
return false;
}
int main() {
int n, t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int l = 0, r = 2000;
while (l < r) {
int mid = (l + r) >> 1;
if (check(n, mid))
r = mid;
else
l = mid + 1;
}
cout << r << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pli = pair<ll, int>;
using pii = pair<int, int>;
constexpr ll mod = 1e9 + 7;
constexpr int N = 5010;
int a[N], b[N], c[N];
int n, m, k;
int f[N][N];
int last[N];
vector<int> g[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T = 1;
while (T--) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
while (m--) {
int u, v;
cin >> u >> v;
last[v] = max(last[v], u);
}
for (int i = 1; i <= n; i++) {
last[i] = max(last[i], i);
g[last[i]].push_back(i);
}
memset(f, -0x3f, sizeof f);
f[0][k] = 0;
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j + b[i] <= 5000; j++)
f[i][j + b[i]] = max(f[i][j + b[i]], f[i - 1][j]);
for (auto t : g[i])
for (int j = 0; j <= 4999; j++)
f[i][j] = max(f[i][j], f[i][j + 1] + c[t]);
}
int res = -1;
for (int i = 0; i <= 5000; i++) res = max(res, f[n][i]);
cout << res << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, op, x, y, xty[500025], ytx[500025];
set<int> s;
struct seg {
int mx[4000005], dp[500025];
void pushup(int x) { mx[x] = max(mx[x * 2], mx[x * 2 + 1]); }
void update(int x, int tl, int tr, int y, int c) {
if (tl > y || tr < y) return;
if (tl == tr) {
mx[x] = c;
return;
}
update(x * 2, tl, (tl + tr) / 2, y, c);
update(x * 2 + 1, (tl + tr) / 2 + 1, tr, y, c);
pushup(x);
}
int query(int x, int tl, int tr, int ql, int qr) {
if (tl > qr || tr < ql) return 0;
if (tl >= ql && tr <= qr) return mx[x];
return max(query(x * 2, tl, (tl + tr) / 2, ql, qr),
query(x * 2 + 1, (tl + tr) / 2 + 1, tr, ql, qr));
}
void upd(int x) {
update(1, 1, 500005, x, dp[x] = (query(1, 1, 500005, 1, x - 1) + 1));
}
} t1, t2;
int main() {
scanf("%d%d", &n, &m);
for ((j) = 1; (j) <= (m); (j)++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
x = n - x + 1;
y = 15 - y + j;
ytx[y] = x;
xty[x] = y;
for (i = y + 1; i <= y + 10; i++)
if (ytx[i]) {
t1.update(1, 1, 500005, i, 0);
t2.update(1, 1, 500005, ytx[i], 0);
}
for (i = y; i <= y + 10; i++)
if (ytx[i]) {
t2.upd(ytx[i]);
t1.dp[i] = t2.dp[ytx[i]];
t1.update(1, 1, 500005, i, t1.dp[i]);
}
s.insert(x);
} else {
scanf("%d", &x);
set<int>::iterator it;
int cnt;
for (cnt = 1, it = --s.end(); cnt <= x; cnt++) {
if (cnt != 1) it--;
t2.update(1, 1, 500005, *it, 0);
t1.update(1, 1, 500005, xty[*it], 0);
}
x = *it;
for (it++; it != s.end(); it++) {
t1.upd(xty[*it]);
t2.dp[*it] = t1.dp[xty[*it]];
t2.update(1, 1, 500005, *it, t2.dp[*it]);
}
ytx[xty[x]] = 0;
xty[x] = 0;
s.erase(x);
}
printf("%d\n", t2.query(1, 1, 500005, 1, 500005));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma GCC optimize("Ofast")
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
void amax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void amin(T& x, T y) {
x = min(x, y);
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-12;
const int maxn = (int)1e6 + 12;
const long long llinf = 2e18 + 5;
const double PI = acos(-1.0);
const int mod = 1e9 + 7;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % mod;
} else {
return (1LL * binpow(n, second - 1) * n) % mod;
}
}
int bal[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> p(n), q(n);
vector<int> ps(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
ps[p[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> q[i];
q[i]--;
}
for (int i = 0; i + 1 < n; i++) {
int a = q[i], b = q[i + 1];
a = ps[a], b = ps[b];
if (a > b) {
bal[a] += 1;
bal[b] -= 1;
}
}
string ans;
ans.resize(n);
ans[p[0]] = 'a';
int sum = 0;
char c = 'a';
for (int i = 0; i + 1 < n; i++) {
sum += bal[i];
if (sum == 0) {
c++;
c = min(c, 'z');
}
ans[p[i + 1]] = c;
}
if (c - 'a' + 1 < k) {
cout << "NO";
} else {
cout << "YES\n" << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int binarySearch(long long int arr[], long long int l, long long int r,
long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int ans = 0;
if (binarySearch(a, 0, n - 1, x) != -1) {
ans = 1;
} else {
if (x % a[n - 1] == 0) {
ans = x / a[n - 1];
} else {
if (x / a[n - 1] == 0) {
ans++;
}
ans += x / a[n - 1] + 1;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, bytes = 0, members = 0, aux, tam, numb;
string code;
cin >> code;
while (!cin.eof()) {
if (code[0] == '+') {
members++;
} else if (code[0] == '-') {
members--;
} else {
for (i = 0; code[i] != ':'; i++) {
}
aux = i;
numb = code.size() - 1;
for (i = aux; i < numb; i++) {
bytes += members;
}
}
getline(cin, code);
}
cout << bytes;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t[300006], tf[300006], tr[300006], x[300006];
set<int> s;
int n, m;
int qf, qr, to, ans, seq[300006], res[300006];
int a[300006 * 4], tag[300006 * 4];
void build(int f, int r, int at) {
a[at] = (1e9) + 1;
if (f == r) return;
int mid = (f + r) >> 1;
build(f, mid, at * 2);
build(mid + 1, r, at * 2 + 1);
}
void query(int f, int r, int at) {
ans = min(ans, a[at]);
if (qf == f && f == r) return;
int mid = (f + r) >> 1;
if (qf <= mid)
query(f, mid, at * 2);
else
query(mid + 1, r, at * 2 + 1);
}
void change(int f, int r, int at) {
if (qf <= f && r <= qr) {
a[at] = min(to, a[at]);
return;
}
int mid = (f + r) >> 1;
if (qf <= mid) change(f, mid, at * 2);
if (qr > mid) change(mid + 1, r, at * 2 + 1);
}
void build2(int f, int r, int at) {
if (f == r) {
a[at] = res[f];
return;
}
int mid = (f + r) >> 1;
build2(f, mid, at * 2);
build2(mid + 1, r, at * 2 + 1);
a[at] = max(a[at * 2 + 1], a[at * 2]);
}
void change2(int f, int r, int at) {
if (qf == f && f == r) {
a[at] = to;
return;
}
int mid = (f + r) >> 1;
if (qf <= mid)
change2(f, mid, at * 2);
else
change2(mid + 1, r, at * 2 + 1);
a[at] = max(a[at * 2], a[at * 2 + 1]);
}
void query2(int f, int r, int at) {
if (qf <= f && r <= qr) {
ans = max(ans, a[at]);
return;
}
int mid = (f + r) >> 1;
if (qf <= mid) query2(f, mid, at * 2);
if (qr > mid) query2(mid + 1, r, at * 2 + 1);
}
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
build(1, n, 1);
for (i = 1; i <= n; i++) res[i] = (int)(1e9) + 2;
for (i = 1; i <= m; i++) {
scanf("%d", t + i);
if (t[i] == 1) {
scanf("%d%d%d", tf + i, tr + i, x + i);
qf = tf[i];
qr = tr[i];
to = x[i];
change(1, n, 1);
} else {
scanf("%d%d", tf + i, x + i);
if (res[tf[i]] == (1e9) + 2) {
qf = tf[i];
ans = (1e9) + 2;
query(1, n, 1);
res[tf[i]] = ans;
}
}
}
for (i = 1; i <= n; i++)
if (res[i] == (1e9) + 2) {
ans = (1e9) + 2;
qf = i;
query(1, n, 1);
res[i] = ans;
}
build2(1, n, 1);
for (i = 1; i <= m; i++) {
if (t[i] == 1) {
ans = 0;
qf = tf[i];
qr = tr[i];
query2(1, n, 1);
if (ans != x[i]) {
printf("NO");
return 0;
}
} else {
qf = tf[i];
to = x[i];
change2(1, n, 1);
}
}
int tmp, good = 0;
for (i = 1; i <= n; i++) {
if (res[i] == (1e9) + 1) continue;
if (!s.count(res[i])) {
s.insert(res[i]);
good |= res[i];
seq[i] = res[i];
} else {
tmp = 1 << 30;
while (!(res[i] & tmp) && tmp) tmp >>= 1;
seq[i] = max(0, tmp - 1);
good |= seq[i];
}
}
int cur;
for (i = 1; i <= n; i++)
if (res[i] == (1e9) + 1) {
tmp = 1 << 30;
cur = 0;
while (tmp) {
if ((tmp & good) == 0 && (tmp | cur) <= 1e9) cur |= tmp;
tmp >>= 1;
}
seq[i] = cur;
good |= cur;
}
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d ", seq[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string s;
int d[100009], c[100009];
cin >> s;
int n = s.size();
if (n == 1) {
cout << 1;
return 0;
}
d[0] = 1;
for (int i = 1; i <= n - 1; i++) {
if (s[i] != s[i - 1])
d[i] = d[i - 1] + 1;
else
d[i] = 1;
}
c[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (s[i] != s[i + 1])
c[i] = c[i + 1] + 1;
else
c[i] = 1;
}
int res = 0;
for (int i = 1; i <= n - 1; i++) {
res = max(res, d[i]);
}
int ok = 0;
for (int i = 0; i <= n - 2; i++)
if (s[i] == s[i + 1]) {
ok = 1;
break;
}
if (ok == 1 & s[0] != s[n - 1]) res = max(res, d[n - 1] + c[0]);
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-14;
int a[2010], b[2010], c[2010];
struct point {
long double x, y;
bool operator<(point a) const {
return x + eps < a.x || (fabs(x - a.x) <= eps && y + eps < a.y);
}
} d[2010], f[2010];
bool cmp(point a, point b) { return a.x * b.y + eps < a.y * b.x; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
for (int i = 1; i <= n; i++) {
double t = -(long double)(c[i]) / (a[i] * a[i] + b[i] * b[i]);
d[i].x = t * a[i];
d[i].y = t * b[i];
}
sort(d + 1, d + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = i + 1; j <= n; j++)
if (fabs(d[i].x - d[j].x) < eps && fabs(d[i].y - d[j].y) < eps)
ans += (n - j);
else {
f[++cnt].x = d[j].x - d[i].x;
f[cnt].y = d[j].y - d[i].y;
}
sort(f + 1, f + cnt + 1, cmp);
int j = 1;
while (j <= cnt) {
int k = j;
while (k <= cnt && fabs(f[k].x * f[j].y - f[j].x * f[k].y) < eps) k++;
ans = ans + (k - j) * (k - j - 1) / 2;
j = k;
}
}
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;
const ld EPS = 1E-9;
struct pt {
ld x, y;
};
struct seg {
pt p, q;
int id;
ld get_y(ld x) const {
if (abs(p.x - q.x) < EPS) return p.y;
return p.y + (q.y - p.y) * (x - p.x) / (q.x - p.x);
}
};
inline bool intersect1d(ld l1, ld r1, ld l2, ld r2) {
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
return max(l1, l2) <= min(r1, r2) + EPS;
}
inline int vec(const pt& a, const pt& b, const pt& c) {
ld s = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
return abs(s) < EPS ? 0 : s > 0 ? +1 : -1;
}
bool intersect(const seg& a, const seg& b) {
return intersect1d(a.p.x, a.q.x, b.p.x, b.q.x) &&
intersect1d(a.p.y, a.q.y, b.p.y, b.q.y) &&
vec(a.p, a.q, b.p) * vec(a.p, a.q, b.q) <= 0 &&
vec(b.p, b.q, a.p) * vec(b.p, b.q, a.q) <= 0;
}
bool operator<(const seg& a, const seg& b) {
ld x = max(min(a.p.x, a.q.x), min(b.p.x, b.q.x));
return a.get_y(x) < b.get_y(x) - EPS;
}
struct event {
ld x;
int tp, id;
event() {}
event(ld x, int tp, int id) : x(x), tp(tp), id(id) {}
bool operator<(const event& e) const {
if (abs(x - e.x) > EPS) return x < e.x;
return tp > e.tp;
}
};
set<seg> s;
vector<set<seg>::iterator> where;
inline set<seg>::iterator prev(set<seg>::iterator it) {
return it == s.begin() ? s.end() : --it;
}
inline set<seg>::iterator next(set<seg>::iterator it) { return ++it; }
pair<int, int> solve(const vector<seg>& a) {
int n = (int)a.size();
vector<event> e;
for (int i = 0; i < n; ++i) {
e.push_back(event(min(a[i].p.x, a[i].q.x), +1, i));
e.push_back(event(max(a[i].p.x, a[i].q.x), -1, i));
}
sort(e.begin(), e.end());
s.clear();
where.resize(a.size());
for (size_t i = 0; i < e.size(); ++i) {
int id = e[i].id;
if (e[i].tp == +1) {
set<seg>::iterator nxt = s.lower_bound(a[id]), prv = prev(nxt);
if (nxt != s.end() && intersect(*nxt, a[id]))
return make_pair(nxt->id, id);
if (prv != s.end() && intersect(*prv, a[id]))
return make_pair(prv->id, id);
where[id] = s.insert(nxt, a[id]);
} else {
set<seg>::iterator nxt = next(where[id]), prv = prev(where[id]);
if (nxt != s.end() && prv != s.end() && intersect(*nxt, *prv))
return make_pair(prv->id, nxt->id);
s.erase(where[id]);
}
}
return make_pair(-1, -1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<pt> S(n), V(n);
vi U(n);
for (int i = 0; i < n; i++) {
cin >> S[i].x >> S[i].y >> V[i].x >> V[i].y >> U[i];
ld len = sqrt(V[i].x * V[i].x + V[i].y * V[i].y);
V[i].x /= len;
V[i].y /= len;
V[i].x *= U[i];
V[i].y *= U[i];
}
ld lf = 0, rg = 1e12;
{
ld md = rg;
vector<seg> a(n);
for (int i = 0; i < n; i++) {
a[i].id = i;
a[i].p = S[i];
ld X = S[i].x + V[i].x * md;
ld Y = S[i].y + V[i].y * md;
a[i].q = {X, Y};
}
if (solve(a) == make_pair(-1, -1)) {
cout << "No show :(";
return 0;
}
}
const ld _eps = 1e-8;
while ((rg - lf) > _eps) {
ld md = (lf + rg) / 2;
vector<seg> a(n);
for (int i = 0; i < n; i++) {
a[i].id = i;
a[i].p = S[i];
ld X = S[i].x + V[i].x * md;
ld Y = S[i].y + V[i].y * md;
a[i].q = {X, Y};
}
if (solve(a) != make_pair(-1, -1)) {
rg = md;
} else {
lf = md;
}
}
cout.precision(10);
cout << fixed << (lf + rg) / 2;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char s[50010];
int n, m;
char t[10][50010];
int tn[10], tl[10], tr[10];
int p[50010];
int ps[50010], pt[10][50010];
int rs[50010], rt[10][50010];
int lb;
int *pw;
int *rw;
int hhx(int l, int r) { return ps[r] - ps[l] * p[r - l]; }
int hhy(int l, int r) { return pw[r] - pw[l] * p[r - l]; }
int lcps(int x, int y) {
int l = 1, r = min(n - x, n - y);
while (l <= r) {
int mid = (l + r) / 2;
if (hhx(x, x + mid) == hhx(y, y + mid))
l = mid + 1;
else
r = mid - 1;
}
return r;
}
int lcpt(int x, int y) {
int l = 1, r = min(tn[lb] - x, tn[lb] - y);
while (l <= r) {
int mid = (l + r) / 2;
if (hhy(x, x + mid) == hhy(y, y + mid))
l = mid + 1;
else
r = mid - 1;
}
return r;
}
bool cmps(int x, int y) {
int c = lcps(x, y);
return s[x + c] < s[y + c];
}
bool cmpt(int x, int y) {
int c = lcpt(x, y);
return t[lb][x + c] < t[lb][y + c];
}
int lcpst(int x, int y, int z) {
int l = 1, r = min(y - x, tn[lb] - z);
while (l <= r) {
int mid = (l + r) / 2;
if (hhx(x, x + mid) == hhy(z, z + mid))
l = mid + 1;
else
r = mid - 1;
}
return r;
}
int getl(int l, int r, int b) {
lb = b;
pw = pt[lb];
rw = rt[lb];
int le1 = 0, ri1 = tn[lb] - 1;
while (le1 <= ri1) {
int mid = (le1 + ri1) / 2;
int c = lcpst(l, r, rw[mid]);
if (r == l + c)
ri1 = mid - 1;
else if (s[l + c] < t[lb][rw[mid] + c])
ri1 = mid - 1;
else
le1 = mid + 1;
}
int le2 = 0, ri2 = tn[lb] - 1;
while (le2 <= ri2) {
int mid = (le2 + ri2) / 2;
int c = lcpst(l, r, rw[mid]);
if (r == l + c)
le2 = mid + 1;
else if (s[l + c] > t[lb][rw[mid] + c])
le2 = mid + 1;
else
ri2 = mid - 1;
}
return ri2 - le1 + 1;
}
bool F;
bool cmp1(int x, int y) {
bool F0 = 0, F1 = 0;
for (int i = 0; i < m; i++) {
int l = getl(x, y, i);
if (l < tl[i]) F0 = 1;
if (l > tr[i]) F1 = 1;
if (F0 && F1) {
F = 1;
return 0;
}
}
if (!F1) return 1;
return 0;
}
bool cmp2(int x, int y) {
bool F0 = 0, F1 = 0;
for (int i = 0; i < m; i++) {
int l = getl(x, y, i);
if (l < tl[i]) F0 = 1;
if (l > tr[i]) F1 = 1;
if (F0 && F1) {
F = 1;
return 0;
}
}
if (!F0) return 1;
return 0;
}
int main() {
scanf("%s", s);
n = strlen(s);
scanf("%d", &m);
for (int i = 0; i < m; i++)
scanf("%s%d%d", t[i], tl + i, tr + i), tn[i] = strlen(t[i]);
p[0] = 1;
for (int i = 1; i < 50010; i++) p[i] = p[i - 1] * 1000000007;
ps[0] = 0;
for (int i = 0; i < n; i++) ps[i + 1] = ps[i] * 1000000007 + s[i];
for (int i = 0; i < m; i++) {
int *pw = pt[i];
char *st = t[i];
pw[0] = 0;
for (int j = 0; j < tn[i]; j++) pw[j + 1] = pw[j] * 1000000007 + st[j];
}
for (int i = 0; i < n; i++) rs[i] = i;
sort(rs, rs + n, cmps);
for (int i = 0; i < m; i++) {
int *rw = rt[i];
for (int j = 0; j < tn[i]; j++) rw[j] = j;
pw = pt[i];
lb = i;
sort(rw, rw + tn[i], cmpt);
}
int S = 0;
for (int i = 0; i < n; i++) {
int le = 0;
if (i > 0) le = lcps(rs[i], rs[i - 1]);
int ri = n - rs[i];
F = 0;
int le1 = le + 1, ri1 = ri;
while (le1 <= ri1) {
int mid = (le1 + ri1) / 2;
if (cmp1(rs[i], rs[i] + mid))
ri1 = mid - 1;
else
le1 = mid + 1;
if (F) break;
}
if (F) continue;
int le2 = le + 1, ri2 = ri;
while (le2 <= ri2) {
int mid = (le2 + ri2) / 2;
if (cmp2(rs[i], rs[i] + mid))
le2 = mid + 1;
else
ri2 = mid - 1;
if (F) break;
}
if (F) continue;
S += max(0, ri2 - le1 + 1);
}
printf("%d\n", S);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int hh, mm;
cin >> hh >> mm;
int h, d, c, n;
cin >> h >> d >> c >> n;
double cost = 0.0;
int t_buns;
if (hh >= 20) {
t_buns = ceil((double)h / (double)n);
cost = t_buns * c;
double dis = cost * 0.2;
cost = cost - dis;
} else {
t_buns = ceil((double)h / (double)n);
cost = t_buns * c;
int minutes = (hh * 60) + mm;
minutes = 1200 - minutes;
h = h + (minutes * d);
int t_buns1 = ceil((double)h / (double)n);
double cost1 = t_buns1 * c;
double dis = cost1 * 0.2;
cost1 = cost1 - dis;
if (cost1 < cost) {
cost = cost1;
}
}
printf("%.3f", cost);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long g, s;
struct xx {
int u, v;
long long a, b;
} input[50004], sta[50004];
int fa[205];
bool cmp(xx a, xx b) {
if (a.a == b.a) return a.b < b.b;
return a.a < b.a;
}
void init() {
for (int i = 0; i <= n; i++) fa[i] = i;
}
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
int main() {
long long ans = 0x3f3f3f3f3f3f3f3f;
cin >> n >> m;
cin >> g >> s;
for (int i = 0; i < m; i++) {
cin >> input[i].u >> input[i].v >> input[i].a >> input[i].b;
}
sort(input, input + m, cmp);
int top = 0;
for (int i = 0; i < m; i++) {
init();
sta[top++] = input[i];
for (int j = top - 1; j > 0; j--)
if (sta[j].b < sta[j - 1].b) swap(sta[j], sta[j - 1]);
int cnt = 0;
for (int j = 0; j < top; j++) {
int fx = Find(sta[j].u);
int fy = Find(sta[j].v);
if (fx != fy) {
sta[cnt++] = sta[j];
fa[fx] = fy;
if (cnt == n) break;
}
}
top = cnt;
if (cnt == n - 1) {
ans = min(ans, input[i].a * g + sta[n - 2].b * s);
}
}
if (ans == 0x3f3f3f3f3f3f3f3f)
cout << "-1\n";
else
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
int n, m, i, j, w, ans, tmp;
int s[101][10001];
char ch[101][10001];
int abs(int x) {
if (x < 0) return (-x);
return x;
}
int min(int a, int b) {
if (a < b) return a;
return b;
}
int main() {
scanf("%d%d\n", &n, &m);
for (i = 1; i <= n; i++) scanf("%s", &ch[i]);
ans = 10000000;
for (i = 1; i <= n; i++) {
w = 0;
for (j = 0; j <= m - 1; j++) s[i][j] = 10000000;
for (j = 0; j <= m - 1; j++)
if (ch[i][j] == '1') w++;
if (w != 0) {
for (j = 0; j <= m - 1; j++)
if (ch[i][j] == '1') break;
w = j;
for (j = m - 1; j >= 0; j--) {
w++;
if (ch[i][j] == '1') w = 0;
s[i][j] = min(s[i][j], w);
}
for (j = m - 1; j >= 0; j--)
if (ch[i][j] == '1') break;
w = m - 1 - j;
for (j = 0; j <= m - 1; j++) {
w++;
if (ch[i][j] == '1') w = 0;
s[i][j] = min(s[i][j], w);
}
}
}
for (i = 0; i <= m - 1; i++) {
tmp = 0;
for (j = 1; j <= n; j++) tmp = tmp + s[j][i];
if (tmp < ans) ans = tmp;
}
if (ans != 10000000)
printf("%d\n", ans);
else
printf("-1\n");
scanf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 72;
struct qu {
int p1, p2, p3;
qu(int a = 0, int b = 0, int c = 0) { p1 = a, p2 = b, p3 = c; }
};
bool operator!=(const qu a, const qu b) {
if (!(a.p1 == b.p1 && a.p2 == b.p2 && a.p3 == b.p3)) return 1;
return 0;
}
int n, edge[maxn][maxn], p1, p2, p3, dis[maxn][maxn][maxn], koft = INT_MAX;
pair<int, int> par[maxn][maxn][maxn];
char c;
qu x, chk;
void print(qu a) {
if (a != chk) {
pair<int, int> tmp = par[a.p1][a.p2][a.p3];
if (tmp.first == 1) {
print(qu(tmp.second, a.p2, a.p3));
cout << tmp.second << " " << a.p1 << endl;
} else if (tmp.first == 2) {
print(qu(a.p1, tmp.second, a.p3));
cout << tmp.second << " " << a.p2 << endl;
} else {
print(qu(a.p1, a.p2, tmp.second));
cout << tmp.second << " " << a.p3 << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> p1 >> p2 >> p3;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> c;
if (c == '*')
edge[i][j] = -1;
else
edge[i][j] = c - 'a';
}
chk.p1 = p1, chk.p2 = p2, chk.p3 = p3;
queue<qu> q;
q.push(chk);
while (q.size()) {
x = q.front();
q.pop();
for (int i = 1; i <= n; i++)
if (i != x.p1 && i != x.p2 && i != x.p3 &&
edge[x.p1][i] == edge[x.p2][x.p3] && qu(i, x.p2, x.p3) != chk &&
!dis[i][x.p2][x.p3])
dis[i][x.p2][x.p3] = dis[x.p1][x.p2][x.p3] + 1,
q.push(qu(i, x.p2, x.p3)), par[i][x.p2][x.p3] = {1, x.p1};
for (int i = 1; i <= n; i++)
if (i != x.p1 && i != x.p2 && i != x.p3 &&
edge[x.p2][i] == edge[x.p1][x.p3] && qu(x.p1, i, x.p3) != chk &&
!dis[x.p1][i][x.p3])
dis[x.p1][i][x.p3] = dis[x.p1][x.p2][x.p3] + 1,
q.push(qu(x.p1, i, x.p3)), par[x.p1][i][x.p3] = {2, x.p2};
for (int i = 1; i <= n; i++)
if (i != x.p1 && i != x.p2 && i != x.p3 &&
edge[x.p3][i] == edge[x.p2][x.p1] && qu(x.p1, x.p2, i) != chk &&
!dis[x.p1][x.p2][i])
dis[x.p1][x.p2][i] = dis[x.p1][x.p2][x.p3] + 1,
q.push(qu(x.p1, x.p2, i)), par[x.p1][x.p2][i] = {3, x.p3};
}
if (p1 + p2 + p3 == 6) return cout << 0 << endl, 0;
bool ans = 0;
qu mn;
vector<int> ch;
ch.push_back(1), ch.push_back(2), ch.push_back(3);
do {
if (dis[ch[0]][ch[1]][ch[2]] != 0) {
ans = 1;
if (koft > dis[ch[0]][ch[1]][ch[2]]) {
koft = dis[ch[0]][ch[1]][ch[2]];
mn.p1 = ch[0], mn.p2 = ch[1], mn.p3 = ch[2];
}
}
} while (next_permutation(ch.begin(), ch.end()));
if (!ans) return cout << -1 << endl, 0;
cout << koft << endl;
print(mn);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void cmax(T &a, T b) {
a = (a > b ? a : b);
}
template <class T>
void cmin(T &a, T b) {
a = (a > b ? b : a);
}
const long long maxn = 271000;
long long tag[maxn << 1], tr[maxn << 1], n, m, p;
struct item {
long long a, p;
bool operator<(item b) const { return a < b.a || a == b.a && p < b.p; }
bool operator==(item b) const { return a == b.a; }
item() { a = p = 0; }
item(long long A, long long B) {
a = A;
p = B;
}
} a[maxn], b[maxn];
struct mon {
long long a, b, p;
bool operator<(mon p) const { return a < p.a || a == p.a && b < p.b; }
} c[maxn];
void pd(long long now) {
tr[now << 1] += tag[now];
tr[now << 1 | 1] += tag[now];
tag[now << 1] += tag[now];
tag[now << 1 | 1] += tag[now];
tag[now] = 0;
}
void add(long long l, long long r, long long now, long long x, long long y,
long long v) {
if (x > y) return;
if (x <= l && r <= y) {
tr[now] += v;
tag[now] += v;
return;
}
if (tag[now]) pd(now);
if (((l + r) >> 1) >= x) add(l, ((l + r) >> 1), now << 1, x, y, v);
if (((l + r) >> 1) < y) add(((l + r) >> 1) + 1, r, now << 1 | 1, x, y, v);
tr[now] = (tr[now << 1] > tr[now << 1 | 1] ? tr[now << 1] : tr[now << 1 | 1]);
}
int main() {
scanf("%lld%lld%lld", &n, &m, &p);
for (long long i = (1); i <= (n); ++i) scanf("%lld%lld", &a[i].a, &a[i].p);
for (long long i = (1); i <= (m); ++i) scanf("%lld%lld", &b[i].a, &b[i].p);
for (long long i = (1); i <= (p); ++i)
scanf("%lld%lld%lld", &c[i].a, &c[i].b, &c[i].p);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
sort(c + 1, c + p + 1);
n = unique(a + 1, a + n + 1) - a - 1;
m = unique(b + 1, b + m + 1) - b - 1;
for (long long i = (1); i <= (m); ++i) add(1, m, 1, i, i, -b[i].p);
long long ans = LLONG_MIN >> 1;
long long j = 0;
for (long long i = (1); i <= (n); ++i) {
while (j < p && c[j + 1].a < a[i].a) {
long long temp =
upper_bound(b + 1, b + m + 1, item(c[j + 1].b, LLONG_MAX >> 1)) - b;
add(1, m, 1,
upper_bound(b + 1, b + m + 1, item(c[j + 1].b, LLONG_MAX >> 1)) - b,
m, c[j + 1].p);
++j;
}
cmax(ans, tr[1] - a[i].p);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 998244353, N = 1e5 + 10, INF = 0x3f3f3f3f;
const double eps = 1e-9, alpha = 0.7;
template<typename T>inline T read() { T x = 0; bool f = 0; char ch = getchar(); while (!isdigit(ch)) { f = ch == '-'; ch = getchar(); } while (isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); } return f ? -x : x; }
template<typename T>inline T max(const T &x, const T &y) { return x > y ? x : y; }
template<typename T>inline T min(const T &x, const T &y) { return x < y ? x : y; }
template<typename T>inline T abs(const T &x) { return x > 0 ? x : -x; }
inline int Mod(int x) { if (x >= mod) { return x - mod; } else if (x < 0) { return x + mod; } else { return x; } }
template<typename T1, typename T2>
struct pair {
T1 first;
T2 second;
pair(const T1 &x = 0, const T2 &y = 0) { first = x; second = y; }
friend pair operator + (const pair<T1, T2> &x, const pair<T1, T2> &y) { return pair(x.first + y.first, x.second + y.second); }
friend pair operator - (const pair<T1, T2> &x, const pair<T1, T2> &y) { return pair(x.first - y.first, x.second - y.second); }
friend bool operator < (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first < y.first || (x.first == y.first && x.second < y.second); }
friend bool operator <= (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first < y.first || (x.first == y.first && x.second <= y.second); }
friend bool operator > (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first > y.first || (x.first == y.first && x.second > y.second); }
friend bool operator >= (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first > y.first || (x.first == y.first && x.second >= y.second); }
friend bool operator == (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first == y.first && x.second == y.second; }
friend bool operator != (const pair<T1, T2> &x, const pair<T1, T2> &y) { return x.first != y.first || x.second != y.second; }
};
template<typename T1, typename T2>
inline pair<T1, T2> make_pair(const T1 &x, const T2 &y) { return pair<T1, T2>(x, y); }
template<typename T>
struct stack { int top; T vals[N]; bool empty() { return !top; } void push(T x) { vals[++top] = x; } void pop() { if (top > 0) { --top; } return; } void clear() { top = 0; } T TOP() { return top ? vals[top] : T(-1); } };
inline int ksm(int x, int y) { int ret = 1; for ( ; y; y /= 2, x = 1LL * x * x % mod) { if (y & 1) { ret = 1LL * ret * x % mod; } } return ret; }
inline int ksc(int x, int y) { int ret = 0; for ( ; y; y /= 2, x = Mod(x + x)) { if (y & 1) { ret = Mod(ret + x); } } return ret; }
struct graph { int cnt, h[N]; pair<int, int> edge[N * 2]; void add_edge(int x, int y) { edge[cnt].first = y; edge[cnt].second = h[x]; h[x] = cnt++; } void clear() { memset(h, -1, sizeof h); cnt = 0; } };
inline int ls(int k) { return k << 1; }
inline int rs(int k) { return k << 1 | 1; }
inline int sign(double x) { if (abs(x) < eps) { return 0; } else if (x < 0) { return -1; } else { return 1; } }
template<typename T>
struct BIT { int limit; T vals[N]; void resize(int n) { limit = n; } void add(int x, T y) { for ( ; x <= limit; x += x & -x) { vals[x] += y; } } T sum(int x) { T ret = 0; for ( ; x; x -= x & -x) { ret = ret + vals[x]; } return ret; } };
inline void flush() { std::cout << std::endl; }
template<typename T>
inline void readin(T *elem, int size) { for (int i = 1; i <= size; ++i) { std::cin >> elem[i]; } }
using std::set;
using std::map;
using std::vector;
using std::ios;
using std::cin;
using std::cout;
using std::endl;
using std::queue;
using std::cerr;
#define orz_1
#define orz_2
#define enter '\n'
#define space ' '
int n, d[N];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> d[i];
}
long long ans = 0, s = 0;
std::sort(d + 1, d + 1 + n);
for (int i = 1; i <= n; ++i) {
ans += s - (i - 1LL) * d[i];
s += d[i];
if (d[i] <= 0) {
ans += d[i];
}
else {
ans += d[i] - d[i - 1];
}
}
cout << ans << '\n';
}
int main() {
#ifndef siriehn_nx
// freopen("1.in", "r", stdin);
ios::sync_with_stdio(0);
cin.tie(0);
cout << std::fixed << std::setprecision(10);
#endif
int T;
cin >> T;
while (T--) {
solve();
}
#ifdef siriehn_nx
cerr << "The time of this EXE is " << (((double) clock()) / CLOCKS_PER_SEC) << "s\n";
#endif
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, m, k, A[10][MAX], tree[10][4 * MAX], S[10];
void build(int l, int x, int start, int end) {
if (start == end) {
tree[l][x] = A[l][start];
return;
}
int mid = (start + end) / 2;
build(l, 2 * x, start, mid);
build(l, 2 * x + 1, mid + 1, end);
tree[l][x] = max(tree[l][2 * x], tree[l][2 * x + 1]);
}
int query(int l, int x, int start, int end, int a, int b) {
if (start > b || end < a) return -1e9;
if (start >= a && end <= b) return tree[l][x];
int mid = (start + end) / 2;
int left = query(l, 2 * x, start, mid, a, b);
int right = query(l, 2 * x + 1, mid + 1, end, a, b);
return max(left, right);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &A[j][i]);
for (int i = 1; i <= m; i++) build(i, 1, 1, n);
int last = 1, sol = 0;
for (int i = 1; i <= n; i++) {
int s = 0;
for (int j = 1; j <= m; j++) s += query(j, 1, 1, n, last, i);
while (s > k && last <= i) {
last++;
s = 0;
for (int j = 1; j <= m; j++) s += query(j, 1, 1, n, last, i);
}
if (s <= k && i - last + 1 > sol) {
sol = i - last + 1;
for (int j = 1; j <= m; j++) S[j] = query(j, 1, 1, n, last, i);
}
}
for (int i = 1; i < m; i++) printf("%d ", S[i]);
printf("%d\n", S[m]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using pli = pair<long long, int>;
using ll = long long;
const int N = 2e3 + 7, Max = 5e3 + 7;
const ll mod = 1e9 + 7;
ll n, A, B;
ll a[N], cnt[Max], suff[Max];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc = 1;
while (tc--) {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int j = 1; j < i; ++j) ++cnt[abs(a[i] - a[j])];
}
for (int i = 5000; i > 0; --i) suff[i] = suff[i + 1] + cnt[i];
A = n * (n - 1) / 2;
A = A * A * A;
for (int i = 1; i < 5000; ++i)
for (int j = 1; i + j < 5000; ++j) B += cnt[i] * cnt[j] * suff[i + j + 1];
cout << (double)B / A;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
inline int add(int a, int b) { return (a += b) >= MOD ? a - MOD : a; }
inline int sub(int a, int b) { return (a -= b) < 0 ? a + MOD : a; }
inline int mul(int a, int b) { return 1ll * a * b % MOD; }
inline int qpow(int a, int p) {
int ret = 1;
for (p += (p < 0) * (MOD - 1); p; p >>= 1, a = mul(a, a))
if (p & 1) ret = mul(ret, a);
return ret;
}
const int MAXN = 5010;
int Strb[MAXN][MAXN];
int fac[MAXN];
int inv[MAXN];
int n, k;
int main() {
std::cin >> n >> k;
if (n <= k) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
inv[n] = qpow(fac[n], MOD - 2);
for (int i = n; i >= 1; --i) inv[i - 1] = mul(inv[i], i);
int ans = 0;
for (int i = 1; i <= k; ++i) {
ans = add(ans, mul(mul(fac[n], mul(inv[i], inv[n - i])), qpow(i, k)));
}
printf("%d\n", ans);
return 0;
}
Strb[0][0] = 1;
for (int i = 1; i <= k; ++i)
for (int j = 1; j <= i; ++j)
Strb[i][j] = add(Strb[i - 1][j - 1], mul(j, Strb[i - 1][j]));
int ans = 0, p = n;
for (int i = 1; i <= k; p = mul(p, n - i), ++i) {
ans = add(ans, mul(Strb[k][i], mul(p, qpow(2, n - i))));
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int sum;
vector<pair<int, int> > ans, v;
int k, n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
v.push_back({l, -1});
v.push_back({r, 1});
}
sort(v.begin(), v.end());
int st, dr;
for (int i = 0; i < v.size(); i++) {
if (v[i].second == 1) {
if (sum == k) ans.push_back({st, v[i].first});
sum--;
} else {
sum++;
if (sum == k) st = v[i].first;
}
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bitset<500> d[62][2][500], cur, nxt;
int main() {
int n, m;
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, t;
cin >> u >> v >> t;
d[0][t][u - 1][v - 1] = 1;
}
for (int l = 1; l < 62; l++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int t = 0; t < 2; t++)
if (d[l - 1][t][i][j]) d[l][t][i] |= d[l - 1][1 - t][j];
long long ans = 0;
cur.set(0);
int t = 0;
for (int l = 61; l >= 0; l--) {
nxt.reset();
for (int i = 0; i < n; i++)
if (cur[i]) {
nxt |= d[l][t][i];
}
if (nxt.any()) {
t = 1 - t;
ans += 1LL << l;
cur = nxt;
}
}
cout << (ans > 1e18 ? -1 : ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(int a, int b) {
vector<int> h1(10, 0), h2(10, 0);
while (a) {
++h1[a % 10];
a /= 10;
}
while (b) {
++h2[b % 10];
b /= 10;
}
for (int(i) = (int)(0); (i) < (int)(10); ++(i))
if (h1[i] != 0 && h2[i] != 0) return true;
return false;
}
int main() {
int x;
cin >> x;
int ans = 0;
for (int d = 1; d * d <= x; ++d)
if (x % d == 0) {
int a = x / d;
ans += check(x, d);
if (d != a) ans += check(x, a);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long b, long long p) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % p;
b >>= 1;
a = a * a % p;
}
return res;
}
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int phi(int n) {
int ans = n;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans /= i;
ans = ans * (i - 1);
while (n % i == 0) n /= i;
}
}
if (n > 1) {
ans /= n;
ans *= (n - 1);
}
return ans;
}
const int maxn = 200000 + 50;
vector<int> num[maxn];
int dp[maxn];
int pre[maxn];
vector<int> ans;
int n, m;
int vis[maxn];
vector<int> Div;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
vis[k] = 1;
}
int euler = phi(m);
for (int i = 0; i < m; i++) {
if (vis[i] == 0) {
num[gcd(m, i)].push_back(i);
}
}
for (int i = 1; i <= m; i++) {
if (m % i == 0) {
Div.push_back(i);
dp[i] = -1;
pre[i] = -1;
}
}
for (int i = 1; i <= m; i++) {
if (dp[i] != -1) continue;
for (int j = 0; j < Div.size(); j++) {
if (Div[j] >= i) break;
if (i % Div[j] == 0) {
if (dp[Div[j]] + (int)num[i].size() > dp[i]) {
dp[i] = dp[Div[j]] + num[i].size();
pre[i] = Div[j];
}
}
}
if (dp[i] == -1) {
dp[i] = num[i].size();
pre[i] = -1;
}
}
int res = m;
while (res != -1) {
for (int i = num[res].size() - 1; i >= 0; i--) {
ans.push_back(num[res][i]);
}
res = pre[res];
}
cout << dp[m] << endl;
reverse(ans.begin(), ans.end());
cout << ans[0] << " ";
for (int i = 1; i < ans.size(); i++) {
int a = ans[i];
int g = gcd(ans[i - 1], m);
a /= g;
int j = (int)qpow((long long)ans[i - 1] / g, (long long)(euler - 1),
(long long)m / g);
long long d = (long long)a * j % m;
cout << d << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int l, w, h;
int wn[maxn], ln[maxn], top[maxn][maxn];
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin >> l >> w >> h;
for (int i = 0; i < w; i++) cin >> wn[i];
for (int i = 0; i < l; i++) cin >> ln[i];
for (int i = 0; i < l; i++)
for (int j = 0; j < w; j++) cin >> top[i][j];
for (int i = 0; i < l; i++) {
for (int j = 0; j < w; j++) {
if (top[i][j] != 0) {
top[i][j] = min(ln[i], wn[j]);
}
cout << top[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
int c[N + N], pos[N], val[N + N];
bool have[N];
inline int lowbit(int x) { return x & (-x); }
int sum(int n) {
int ret = 0;
while (n > 0) {
ret += c[n];
n = n - lowbit(n);
}
return ret;
}
void update(int x, int v) {
while (x < N + N) {
c[x] += v;
x += lowbit(x);
}
}
int get_kth(int k, int l, int r) {
int mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (sum(mid) >= k)
r = mid;
else
l = mid;
}
return r;
}
int main() {
int n, m, x, y, score = 0;
cin >> n >> m;
bool f = true;
for (int i = 1; i <= n; i++) update(m + i, 1);
for (int t = 0; t < m; t++) {
scanf("%d %d", &x, &y);
if (f == false) {
continue;
}
if (have[x] == false) {
have[x] = true;
int already = sum(m);
if (y <= already) {
f = false;
continue;
}
int pre = get_kth(y, m, n + m);
val[pre] = 0;
update(pre, -1);
update(m - t, 1);
val[m - t] = x;
pos[pre - m] = x;
} else {
int already = sum(m);
if (y > already) {
f = false;
continue;
}
int pre = get_kth(y, 0, m);
if (val[pre] != x) {
f = false;
continue;
}
val[pre] = 0;
update(pre, -1);
update(m - t, 1);
val[m - t] = x;
}
}
if (f == false) {
puts("-1");
return 0;
}
int now = 1;
for (int i = 1; i <= n; i++) {
if (pos[i] == 0) {
while (have[now] == true) now++;
printf("%d ", now);
now++;
} else
printf("%d ", pos[i]);
}
}
| 7 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int inf = 1000000009;
const long long int INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.0000000001;
using namespace std;
int T[100005], F[2000000], U[2000000];
int suma = 1;
void lazy(int u) {
if (2 * u + 1 > suma) return;
if (U[u]) {
U[2 * u] = U[u];
F[2 * u] = 0;
U[2 * u + 1] = U[u];
F[2 * u + 1] = 0;
}
if (F[u]) {
if (U[2 * u]) {
if (U[2 * u] == 1)
U[2 * u] = 2;
else
U[2 * u] = 1;
} else
F[2 * u] = (F[2 * u] + F[u]) % 2;
if (U[2 * u + 1]) {
if (U[2 * u + 1] == 1)
U[2 * u + 1] = 2;
else
U[2 * u + 1] = 1;
} else
F[2 * u + 1] = (F[2 * u + 1] + F[u]) % 2;
}
F[u] = 0;
U[u] = 0;
}
int getwart(int a, int b, int lo, int hi, int u) {
if (b <= a) return -1;
lazy(u);
if (a == lo && b == hi) {
if (F[u]) return 3;
return U[u];
}
int mid = (lo + hi) / 2;
int L = getwart(a, min(b, mid), lo, mid, 2 * u);
int P = getwart(max(a, mid), b, mid, hi, 2 * u + 1);
return max(L, P);
}
void ustaw(int a, int b, int lo, int hi, int u, int r) {
if (b <= a) return;
lazy(u);
if (a == lo && b == hi) {
if (r == 3) {
if (U[u]) {
if (U[u] == 1)
U[u] = 2;
else
U[u] = 1;
} else {
F[u]++;
F[u] %= 2;
}
} else
U[u] = r, F[u] = 0;
return;
}
int mid = (lo + hi) / 2;
ustaw(a, min(b, mid), lo, mid, 2 * u, r);
ustaw(max(a, mid), b, mid, hi, 2 * u + 1, r);
}
int maks = 100001;
int main() {
int n, q;
cin >> n >> q;
while (suma < maks) suma *= 2;
suma *= 2;
suma--;
for (int i = 1; i <= n; i++) cin >> T[i];
for (int i = 1; i <= q; i++) {
char c;
int x;
cin >> c >> x;
if (c == '>') {
ustaw(1, -x + 1, 1, suma / 2 + 2, 1, 3);
int l;
if (x < 0)
l = -x + 1;
else
l = x + 2;
ustaw(l, maks + 1, 1, suma / 2 + 2, 1, 1);
} else {
ustaw(1, x + 1, 1, suma / 2 + 2, 1, 3);
int l;
if (x < 0)
l = -x + 2;
else
l = x + 1;
ustaw(l, maks + 1, 1, suma / 2 + 2, 1, 2);
}
}
for (int i = 1; i <= n; i++) {
int a = abs(T[i]);
int x = getwart(a + 1, a + 2, 1, suma / 2 + 2, 1);
if (x == 0) cout << T[i];
if (x == 1) cout << -(abs(T[i]));
if (x == 2) cout << abs(T[i]);
if (x == 3) cout << -T[i];
cout << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int Ans[MAXN * 2], L, R, n;
struct XY {
int sz = 0, totid = 0, Ret, ll, rr;
int las[MAXN * 10], top[MAXN], en[MAXN], pos[MAXN], siz[MAXN], dep[MAXN],
fa[MAXN], deleted[MAXN * 3];
struct Edge {
int to, pre;
} e[MAXN * 35];
void add(int a, int b) {
e[++sz].to = b;
e[sz].pre = las[a];
las[a] = sz;
}
void dfs1(int u, int father, int depth) {
dep[u] = depth;
fa[u] = father;
siz[u] = 1;
for (int i = las[u]; i; i = e[i].pre) {
dfs1(e[i].to, u, depth + 1);
siz[u] += siz[e[i].to];
}
}
void dfs2(int u, int tp) {
pos[u] = ++totid;
top[u] = tp;
int v = 0, maxisz = 0;
for (int i = las[u]; i; i = e[i].pre)
if (siz[e[i].to] > maxisz) v = e[i].to, maxisz = siz[e[i].to];
if (v) dfs2(v, tp);
for (int i = las[u]; i; i = e[i].pre)
if (e[i].to != v) dfs2(e[i].to, e[i].to);
}
void link(int rt, int l, int r) {
if (ll <= l && r <= rr) {
add(rt, Ret);
return;
}
int mid = (l + r) >> 1;
if (ll <= mid) link(rt << 1, l, mid);
if (rr > mid) link(rt << 1 | 1, mid + 1, r);
}
void insert(int x, int y, int id) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
ll = pos[top[x]];
rr = pos[x];
Ret = id;
link(1, 1, n);
x = fa[top[x]];
}
if (dep[x] < dep[y]) swap(x, y);
ll = pos[y] + 1;
rr = pos[x];
Ret = id;
if (ll <= rr) link(1, 1, n);
}
void query(int rt, int l, int r) {
for (int i = las[rt]; i; i = e[i].pre)
if (!deleted[e[i].to]) Ans[++R] = e[i].to, deleted[e[i].to] = 1;
las[rt] = 0;
int mid = (l + r) >> 1;
if (l == r) return;
if (ll <= mid)
query(rt << 1, l, mid);
else
query(rt << 1 | 1, mid + 1, r);
}
void doit(int t) {
ll = pos[t + 1];
query(1, 1, n);
}
void work(int l, int r) {
sort(Ans + l, Ans + r + 1);
for (int i = l; i <= r; ++i) printf("%d ", Ans[i]);
puts("");
for (int i = l; i <= r; ++i) doit(Ans[i]);
L = r;
}
void read() {
for (int i = 2; i <= n; ++i) scanf("%d", &fa[i]), add(fa[i], i);
dfs1(1, -1, 1);
dfs2(1, 1);
for (int i = 0; i <= n + 9; ++i) las[i] = 0;
sz = 0;
}
} Tree[2];
int main() {
scanf("%d", &n);
Tree[0].read();
Tree[1].read();
for (int i = 2; i <= n; ++i) Tree[1].insert(Tree[0].fa[i], i, i - 1);
for (int i = 2; i <= n; ++i) Tree[0].insert(Tree[1].fa[i], i, i - 1);
scanf("%d", &Ans[++R]);
Tree[1].deleted[Ans[R]] = 1;
while (L < R) {
if (L < R) puts("Blue"), Tree[0].work(L + 1, R);
if (L < R) puts("Red"), Tree[1].work(L + 1, R);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int fcin() {
register int c = getchar();
int x = 0;
for (; (c < 48 || c > 57); c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
return x;
}
using namespace std;
long long power(long long a, long long b) {
long long ans = 1LL;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return ans;
}
vector<int> adj[27];
int indeg[27], vis[27], st[27];
int anss = 1;
vector<int> ans;
int timers;
void dfs(int node) {
if (vis[node]) return;
st[node] == ++timers;
ans.push_back(node);
vis[node] = 1;
int i;
for (i = 0; i < adj[node].size(); i++) {
if (st[adj[node][i]] < st[node]) anss = 0;
dfs(adj[node][i]);
}
return;
}
string s[108];
int main() {
int t, m, n, i, j, k, l;
scanf("%d", &n);
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i <= 26; i++) adj[i].clear();
timers = 0;
anss = 1;
memset(indeg, 0, sizeof(indeg));
for (i = 0; i < n - 1; i++) {
int fg;
for (k = i + 1; k < n; k++) {
fg = 0;
for (j = 0; j < min(s[i].length(), s[k].length()); j++) {
if (s[i][j] != s[k][j]) {
fg = 1;
break;
}
}
if (!fg) {
if (s[i].length() > s[k].length()) anss = 0;
} else {
adj[s[i][j] - 'a'].push_back(s[k][j] - 'a');
indeg[s[k][j] - 'a']++;
}
}
}
memset(vis, 0, sizeof(vis));
ans.clear();
memset(st, 0, sizeof(st));
queue<int> q;
for (i = 0; i < 26; i++) {
if (!indeg[i]) q.push(i);
}
while (q.size()) {
int x = q.front();
ans.push_back(x);
vis[x] = 1;
q.pop();
for (i = 0; i < adj[x].size(); i++) {
indeg[adj[x][i]]--;
if (indeg[adj[x][i]] == 0 && !vis[adj[x][i]]) q.push(adj[x][i]);
}
}
for (i = 0; i < 26; i++)
if (!vis[i]) anss = 0;
if (!anss) {
cout << "Impossible\n";
return 0;
}
for (i = 0; i < 26; i++) cout << char('a' + ans[i]);
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100010];
int b[100010];
int ok[100010];
int ok2[100010];
long long int cnt;
long long int minn1 = 1000000001, minn2 = 1000000001;
vector<int> rr;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
cnt = b[0];
for (int i = 0; i < n; i++) {
cnt -= a[i];
minn1 = ((minn1) < (cnt) ? (minn1) : (cnt));
cnt += b[(i + 1) % n];
}
cnt = b[0];
for (int i = 0; i < n; i++) {
cnt -= a[i];
if (cnt == minn1) {
ok[(i + 1) % n] = 1;
}
cnt += b[(i + 1) % n];
}
cnt = b[0];
for (int i = n - 1; i >= 0; i--) {
cnt -= a[i];
minn2 = ((minn2) < (cnt) ? (minn2) : (cnt));
cnt += b[i];
}
cnt = b[0];
for (int i = n - 1; i >= 0; i--) {
cnt -= a[i];
if (cnt == minn2) {
ok2[i] = 1;
}
cnt += b[i];
}
int res = 0;
for (int i = 0; i < n; i++)
if (ok[i] || ok2[i]) res++;
printf("%d\n", res);
for (int i = 0; i < n; i++) {
if (ok[i] && i <= n - 1)
rr.push_back(i + 1);
else if (ok2[i])
rr.push_back(i + 1);
}
sort(rr.begin(), rr.end());
for (int i = 0; i < rr.size(); i++) printf("%d ", rr[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7e5 + 100;
const double Pi = acos(-1.0);
struct CP {
double x, y;
CP(double _x = 0.0, double _y = 0.0) : x(_x), y(_y) {}
friend CP operator+(CP A, CP B) { return CP(A.x + B.x, A.y + B.y); }
friend CP operator-(CP A, CP B) { return CP(A.x - B.x, A.y - B.y); }
friend CP operator*(CP A, CP B) {
return CP(A.x * B.x - A.y * B.y, A.x * B.y + B.x * A.y);
}
} F[N], G[N];
struct BIT {
int T[N];
inline int lowbit(int x) { return x & (-x); }
inline void Clr() { memset(T, 0, sizeof(T)); }
inline void Update(int x, int v) {
while (x < N) {
T[x] += v;
x += lowbit(x);
}
}
inline int Query(int x) {
int ret = 0;
while (x) {
ret += T[x];
x -= lowbit(x);
}
return ret;
}
} Tree;
int R[N];
int Lim = 1;
int L = 0;
void DFT(CP *A, int flag) {
for (int i = 0; i < Lim; ++i)
if (i < R[i]) swap(A[i], A[R[i]]);
for (int i = 1; i < Lim; i = (i << 1)) {
CP T = CP(cos(Pi / i), flag * sin(Pi / i));
for (int j = 0; j < Lim; j += (i << 1)) {
CP t = CP(1, 0);
for (int l = 0; l < i; ++l, t = t * T) {
CP Nx = A[j + l];
CP Ny = t * A[i + j + l];
A[j + l] = Nx + Ny;
A[i + j + l] = Nx - Ny;
}
}
}
}
char S[N];
int A[N];
int B[N];
int n, m, k;
inline void Blood(int col) {
Tree.Clr();
for (int i = 0; i < n; ++i) {
if (A[i] == col)
Tree.Update(1 + max(0, i - k), 1), Tree.Update(1 + min(n, i + k + 1), -1);
}
}
int Ans[N];
inline void Calc() {
for (int i = 1; i <= 4; ++i) {
Blood(i);
memset(F, 0, sizeof(F));
memset(G, 0, sizeof(G));
for (int j = 0; j < n; ++j)
if (Tree.Query(j + 1) > 0) G[n - j - 1].x = 1;
for (int j = 0; j < m; ++j)
if (B[j] == i) F[j].x = 1;
DFT(F, 1);
DFT(G, 1);
for (int i = 0; i < Lim; ++i) F[i] = F[i] * G[i];
DFT(F, -1);
for (int i = 0; i < Lim; ++i) Ans[i] += (int)(F[i].x / Lim + 0.5);
}
int tot = 0;
for (int i = m - 1; i < n; ++i) {
if (Ans[i] == m) ++tot;
}
cout << tot;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%s", S);
for (int i = 0; i < n; ++i) {
if (S[i] == 'A') A[i] = 1;
if (S[i] == 'G') A[i] = 2;
if (S[i] == 'T') A[i] = 3;
if (S[i] == 'C') A[i] = 4;
}
scanf("%s", S);
for (int i = 0; i < m; ++i) {
if (S[i] == 'A') B[i] = 1;
if (S[i] == 'G') B[i] = 2;
if (S[i] == 'T') B[i] = 3;
if (S[i] == 'C') B[i] = 4;
}
for (; Lim < 2 * n; Lim = Lim << 1, ++L)
;
for (int i = 0; i < Lim; ++i) R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
Calc();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, i, j, n, x;
cin >> t;
while (t--) {
cin >> n;
long long int a[n];
long long int m[10] = {0};
map<long long int, long long int> f;
for (i = 0; i < n; i++) {
cin >> a[i];
f[a[i]]++;
m[a[i] / 1000] = 1;
}
long long int k = 0;
long long int c = 0;
for (i = 1; i < n; i++) {
if (f[a[i]] > 1) {
for (j = 0; j < 10; j++) {
if (m[j] == 0) {
f[a[i]]--;
a[i] = j * 1000 + a[i] % 1000;
m[j] = 1;
c++;
break;
}
}
}
}
cout << c << endl;
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) {
long long int x = a[i] / pow(10, (3 - j));
cout << x;
a[i] %= (long long int)pow(10, (3 - j));
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 300005;
int n, m, v[MAXN], ls[MAXN], b[MAXN], mx;
pair<int, int> bit[MAXN][2], event[MAXN << 1];
set<int> cur;
vector<pair<int, int> > ans;
map<pair<int, int>, int> len;
inline int Lowbit(int x) { return x & -x; }
inline void Modify(int x, int v, int t) {
for (; x <= n; x += Lowbit(x))
if (bit[x][0].second == t)
bit[x][0].first = max(bit[x][0].first, v);
else if (bit[x][1].first < v) {
bit[x][1] = make_pair(v, t);
if (bit[x][0] < bit[x][1]) swap(bit[x][0], bit[x][1]);
}
}
inline int Query(int x, int t) {
int ret = 0;
for (; x; x -= Lowbit(x))
if (bit[x][0].second == t)
ret = max(ret, bit[x][1].first);
else
ret = max(ret, bit[x][0].first);
return ret;
}
int main() {
n = Read(), m = Read();
event[0] = make_pair(0, 0);
event[1] = make_pair(2000000000, 0);
for (int i = 1; i <= n; i++) {
int l = Read(), r = Read();
v[i] = ls[i] = Read();
event[i << 1] = make_pair(l, i);
event[i << 1 | 1] = make_pair(r, i);
}
sort(ls + 1, ls + n + 1);
sort(event, event + (n + 1 << 1));
if (event[0].second) cur.insert(event[0].second);
for (int i = 1; i < n + 1 << 1; i++) {
int t = event[i].first - event[i - 1].first;
if (t && cur.size() <= 2) {
int p = 0, q = 0;
if (cur.size() > 0) p = *cur.rbegin();
if (cur.size() > 1) q = *cur.begin();
int now = -1;
if (!p)
now = mx;
else {
if (!q) {
if (v[p] <= m) {
now = max(
b[p],
Query(upper_bound(ls + 1, ls + n + 1, m - v[p]) - ls - 1, p));
Modify(lower_bound(ls + 1, ls + n + 1, v[p]) - ls,
len[make_pair(p, 0)] + t, p);
}
} else if (v[p] + v[q] <= m) {
now = len[make_pair(p, 0)] + len[make_pair(q, 0)];
b[p] = max(b[p], len[make_pair(q, 0)] + len[make_pair(p, q)] + t);
b[q] = max(b[q], len[make_pair(p, 0)] + len[make_pair(p, q)] + t);
}
if (~now) now += len[make_pair(p, q)] + len[make_pair(0, 0)];
}
if (~now && now + t > mx)
mx = now + t, ans.push_back(make_pair(mx, event[i].first));
len[make_pair(p, q)] += t;
}
if (event[i].second)
if (cur.find(event[i].second) == cur.end())
cur.insert(event[i].second);
else
cur.erase(event[i].second);
}
for (int Q = Read(), x; Q; Q--) {
auto it = lower_bound(ans.begin(), ans.end(), make_pair(x = Read(), 0));
printf("%d\n", it->second - (it->first - x));
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[10], d;
for (int i = 0; i < 3; ++i) cin >> arr[i];
cin >> d;
sort(arr, arr + 3);
int ans = 0;
if (arr[1] - arr[0] < d) ans += d - arr[1] + arr[0];
if (arr[2] - arr[1] < d) ans += d - arr[2] + arr[1];
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 500;
const int maxm = 500000 + 10;
struct Edge {
int next, v;
Edge() {}
Edge(int next, int v) : next(next), v(v) {}
} e[maxm << 1];
int n, m, len, timer, num;
int head[maxm], cnt;
int low[maxn], dfn[maxn], belo[maxn];
bool inst[maxn], used[maxn];
int st[maxm], top, q[maxm], front, tail;
char org[27], s[maxn], ans[maxn], res[maxn];
int val[128];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
inline void AddEdge(int u, int v) {
e[++cnt] = Edge(head[u], v);
head[u] = cnt;
}
void tarjan(int u) {
low[u] = dfn[u] = ++timer;
st[++top] = u;
inst[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (inst[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
num++;
int j;
do {
j = st[top--];
belo[j] = num;
inst[j] = 0;
} while (j != u);
}
}
inline bool judge(int n) {
for (int i = 2; i <= (n << 1 | 1); i++)
if (!dfn[i]) tarjan(i);
for (int i = 2; i <= (n << 1); i += 2)
if (belo[i] == belo[i + 1]) return 0;
return 1;
}
inline char find(int pos, char c) {
for (int i = pos + 1; i < len; i++)
if (org[i] == c) return 'a' + i;
return -1;
}
int main() {
scanf("%s", org);
len = strlen(org);
for (int i = 0; i < len; i++) val[i + 'a'] = org[i] == 'V' ? 0 : 1;
n = read(), m = read();
char op1[10], op2[10];
int a, b;
while (m--) {
a = read(), scanf("%s", op1);
b = read(), scanf("%s", op2);
a = a << 1 | (op1[0] != 'V');
b = b << 1 | (op2[0] != 'V');
AddEdge(a, b);
AddEdge(b ^ 1, a ^ 1);
}
scanf("%s", s + 1);
if (!judge(n)) {
puts("-1");
return 0;
}
bool exis = 0;
res[1] = -1;
for (int pos = n + 1; pos >= 1; pos--) {
for (int a = pos << 1; a <= (pos << 1 | 1); a++) {
strcpy(ans + 1, s + 1);
if (pos <= n) {
char tp = find(s[pos] - 'a', a & 1 ? 'V' : 'C');
if (tp == -1) continue;
ans[pos] = tp;
}
for (int i = pos + 1; i <= n; i++) ans[i] = 'a';
bool flag = 1;
memset(used, 0, sizeof(used));
for (int i = 1, x; i <= n && flag; i++) {
x = i << 1 | val[ans[i]];
if (used[x]) continue;
used[x] = 1;
front = tail = 0;
q[++tail] = x;
while (front != tail) {
x = q[++front];
if (used[x ^ 1]) {
flag = 0;
break;
}
if ((x >> 1) <= pos && val[ans[x >> 1]] != (x & 1)) {
flag = 0;
break;
}
if ((x >> 1) > pos) {
char tp = find(-1, x & 1 ? 'C' : 'V');
if (tp == -1) {
flag = 0;
break;
}
ans[x >> 1] = tp;
}
for (int j = head[x]; j; j = e[j].next) {
int v = e[j].v;
if (!used[v]) {
used[v] = 1;
q[++tail] = v;
}
}
}
}
if (!flag) continue;
exis = 1;
if (res[1] == -1)
strcpy(res + 1, ans + 1);
else if (strcmp(res + 1, ans + 1) > 0)
strcpy(res + 1, ans + 1);
}
if (exis) break;
}
if (exis)
puts(res + 1);
else
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 1e5 + 9;
double dist(long long int x, long long int y, long long int xx,
long long int yy) {
return sqrt((x - xx) * (x - xx) + (y - yy) * (y - yy));
}
int vis[MAXN][2][2];
long double dp[MAXN][2][2];
long double a[MAXN][3];
int n;
long double solve(int i, bool A, bool B) {
if (i == n) {
if (A or B) return 0;
return 1e10;
}
long double& ret = dp[i][A][B];
if (vis[i][A][B]) return ret;
vis[i][A][B] = true;
ret = 1e18;
if (A == 0) ret = min(ret, a[i][0] + solve(i + 1, true, B));
if (B == 0) ret = min(ret, a[i][1] + solve(i + 1, A, true));
return ret = min(ret, a[i][2] + solve(i + 1, A, B));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long int ax, ay, bx, by, tx, ty;
cin >> ax >> ay >> bx >> by >> tx >> ty;
cin >> n;
for (int i = 0; i < n; i++) {
long long int x, y;
cin >> x >> y;
a[i][0] = (dist(ax, ay, x, y) + dist(x, y, tx, ty));
a[i][1] = (dist(bx, by, x, y) + dist(x, y, tx, ty));
a[i][2] = 2.0 * dist(tx, ty, x, y);
}
cout << setprecision(20) << solve(0, false, false);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int main() {
cin >> s;
cin >> t;
int a = 0;
int b = 0;
int n = s.size();
for (int i = 0; i < n; i += 2) {
if (s[i] != t[i]) {
if ((s[i] == '[' && t[i] == '(') || (s[i] == '(' && t[i] == '8') ||
(s[i] == '8' && t[i] == '['))
a++;
else
b++;
}
}
if (a == b)
cout << "TIE";
else
cout << (a > b ? "TEAM 1 WINS" : "TEAM 2 WINS");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char ans[N];
int n;
int nodes;
int subtree[N];
set<int> gr[N];
void dfs(int ch, int par) {
subtree[ch] = 1;
nodes++;
for (auto i : gr[ch]) {
if (i == par) continue;
dfs(i, ch);
subtree[ch] += subtree[i];
}
}
int centroid(int ch, int par) {
for (auto i : gr[ch]) {
if (i == par) continue;
if (subtree[i] > nodes / 2) return centroid(i, ch);
}
return ch;
}
void decompose(int x, char ch) {
nodes = 0;
dfs(x, -1);
int cen = centroid(x, -1);
ans[cen] = ch;
for (auto i : gr[cen]) {
gr[i].erase(cen);
decompose(i, ch + 1);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
gr[x].insert(y);
gr[y].insert(x);
}
decompose(1, 'A');
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 6 |
#include <bits/stdc++.h>
int n, m;
bool vis[300010];
int main() {
scanf("%d", &n);
m = n;
printf("1");
for (int i = 0, p; i < n; i++) {
scanf("%d", &p);
vis[p] = 1;
while (m && vis[m]) m--;
printf(" %d", i + 1 - n + m + 1);
}
}
| 3 |
#include <bits/stdc++.h>
int f[26];
int main() {
int n, m = 0, res = 26;
scanf("%d", &n);
char c, h = 0, str[202020];
for (int i = 1; i <= n; ++i) {
c = getchar();
while (c != '!' && c != '.' && c != '?') c = getchar();
h = c;
c = getchar();
scanf("%s", str);
if (res == 1) {
if (h == '!' || h == '?') ++m;
} else {
if (h == '?') {
if (f[str[0] - 'a'] >= 0) --f[str[0] - 'a'], --res;
}
if (h == '!') {
for (int j = 0; j < strlen(str); ++j)
if (!f[str[j] - 'a']) f[str[j] - 'a'] = 1;
for (int j = 0; j < 26; ++j) {
--f[j];
if (f[j] == -1) --res;
}
}
if (h == '.') {
for (int j = 0; j < strlen(str); ++j)
if (f[str[j] - 'a'] >= 0) f[str[j] - 'a'] = -1, --res;
}
}
}
if (res == 1) --m;
printf("%d", m);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int bit[2][1020000], N = 1000002, arr[1020000], res[1020000];
void update(int idx, int val, int b) {
idx++;
while (idx <= N) bit[b][idx] ^= val, idx += idx & (-idx);
}
int xori(int idx, int b) {
idx++;
int res = 0;
while (idx > 0) res ^= bit[b][idx], idx -= idx & (-idx);
return res;
}
map<int, int> last;
vector<pair<int, int> > qs[1020000];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
int q, l, r;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d %d", &l, &r);
qs[r].emplace_back(l, i);
}
for (int i = 1; i <= n; i++) {
if (last[arr[i]] != 0) {
update(last[arr[i]], arr[i], 0);
}
update(i, arr[i], 1);
update(i, arr[i], 0);
last[arr[i]] = i;
for (pair<int, int> que : qs[i]) {
res[que.second] = xori(i, 1) ^ xori(que.first - 1, 1) ^ xori(i, 0) ^
xori(que.first - 1, 0);
}
}
for (int i = 0; i < q; i++) {
printf("%d\n", res[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> data;
long long a;
int main() {
cin >> n;
long long nn = 0;
for (int i = 0; i < n; i++) {
cin >> a;
data.push_back(a);
}
long long answer = -1;
long long now = 0;
long long mm = 0;
for (int i = 0; i < n - 1; i++) {
if (i % 2 == 0) {
now += abs(data[i] - data[i + 1]);
answer = max(answer, now + mm);
} else {
now -= abs(data[i] - data[i + 1]);
answer = max(answer, now + mm);
mm = max(mm + now, nn);
now = 0;
}
}
mm = 0;
now = 0;
for (int i = 1; i < n - 1; i++) {
if (i % 2 != 0) {
now += abs(data[i] - data[i + 1]);
answer = max(answer, now + mm);
} else {
now -= abs(data[i] - data[i + 1]);
answer = max(answer, now + mm);
mm = max(mm + now, nn);
now = 0;
}
}
cout << answer << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
void _fill_ll(signed long long* p, signed long long val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int N, K;
signed long long mo = 1000000007;
signed long long dpdp[205][205][16];
const int CN = 20;
signed long long C[CN][CN];
signed long long dodp(int level, int num, int mask) {
int ma, i, j, k[5], l;
if (num == 0) return 1;
if (num < 0 || mask == 0) return 0;
if (dpdp[level][num][mask] != -1) return dpdp[level][num][mask];
signed long long ret = 0;
for (ma = 0; ma < 16; ma++) {
if ((mask & ma) != ma) continue;
int bi = __builtin_popcount(ma);
k[0] = k[1] = k[2] = k[3] = k[4] = 0;
k[bi] = 1;
if (bi == 2 && (ma != 5) && (ma != 10)) k[1]++;
if (bi == 3) k[2] += 2;
if (bi == 4) k[2] += 2, k[3] += 4;
if (level > 0) {
int ma2 = mask ^ ma;
if (ma2 == 13 || ma2 == 11 || ma2 == 14) ma2 = 7;
if (ma2 == 9 || ma2 == 6 || ma2 == 12) ma2 = 3;
if (ma2 == 10) ma2 = 5;
if (ma2 == 2 || ma2 == 4 || ma2 == 8) ma2 = 1;
int x, y;
for (l = 0; l < 5; l++) {
if (k[l] == 0) continue;
if (num - l < 0) continue;
if (ma2 == 0)
x = 0, y = 0;
else if (ma2 == 1)
x = 3, y = 0;
else if (ma2 == 5)
x = 6, y = 0;
else if (ma2 == 3)
x = 6, y = 1;
else if (ma2 == 7)
x = 9, y = 2;
else if (ma2 == 15)
x = 12, y = 4;
for (i = 0; i < y + 1; i++)
for (j = 0; j < x - i * 2 + 1; j++)
ret += dodp(level - 1, num - l - (i + j), ma2) *
((k[l] * C[y][i] * C[x - i * 2][j]) % mo);
}
} else {
for (l = 0; l < 5; l++) ret += (num == l) * k[l];
}
}
return dpdp[level][num][mask] = (ret %= mo);
}
void solve() {
int f, i, j, k, l, x, y;
cin >> N >> K;
for (x = 0; x < CN; x++) C[x][0] = C[x][x] = 1;
for (i = 1; i < CN; i++)
for (j = 1; j < i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mo;
_fill_ll((signed long long*)dpdp, -1LL, sizeof(dpdp) / 8);
signed long long ret = dodp(N, K, 15);
for (i = 0; i < K; i++) ret = (ret * (i + 1)) % mo;
cout << ret << endl;
}
int main(int argc, char** argv) {
if (argc > 1) freopen(argv[1], "r", stdin);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 100000007;
long long int MX = 1000000000;
long long int n;
pair<long long int, long long int> a[200200];
map<long long int, long long int> sor;
map<long long int, long long int> val;
long long int tree[600005];
long long int lazy[600005];
long long int tree1[600005];
long long int lazy1[600005];
void construct(long long int low, long long int high, long long int pos) {
if (low == high) {
tree[pos] = 0;
return;
}
long long int mid = (low + high) / 2;
construct(low, mid, 2 * pos + 1);
construct(mid + 1, high, 2 * pos + 2);
tree[pos] = tree[2 * pos + 1] + tree[2 * pos + 2];
}
long long int MRQ(long long int ql, long long int qh, long long int low,
long long int high, long long int pos) {
if (lazy[pos] != 0) {
tree[pos] += lazy[pos] * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += lazy[pos];
lazy[2 * pos + 2] += lazy[pos];
}
lazy[pos] = 0;
}
if (low > qh || high < ql) return 0;
if (ql <= low && qh >= high) return tree[pos];
long long int mid = (low + high) / 2;
return MRQ(ql, qh, low, mid, 2 * pos + 1) +
MRQ(ql, qh, mid + 1, high, 2 * pos + 2);
}
void update(long long int ql, long long int qh, long long int val,
long long int low, long long int high, long long int pos) {
if (lazy[pos] != 0) {
tree[pos] += lazy[pos] * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += lazy[pos];
lazy[2 * pos + 2] += lazy[pos];
}
lazy[pos] = 0;
}
if (low > qh || high < ql) return;
if (ql <= low && qh >= high) {
tree[pos] += val * (high - low + 1);
if (low != high) {
lazy[2 * pos + 1] += val;
lazy[2 * pos + 2] += val;
}
return;
}
long long int mid = (low + high) / 2;
update(ql, qh, val, low, mid, 2 * pos + 1);
update(ql, qh, val, mid + 1, high, 2 * pos + 2);
tree[pos] = tree[2 * pos + 1] + tree[2 * pos + 2];
}
void construct1(long long int low, long long int high, long long int pos) {
if (low == high) {
tree1[pos] = 0;
return;
}
long long int mid = (low + high) / 2;
construct1(low, mid, 2 * pos + 1);
construct1(mid + 1, high, 2 * pos + 2);
tree1[pos] = tree1[2 * pos + 1] + tree1[2 * pos + 2];
}
long long int MRQ1(long long int ql, long long int qh, long long int low,
long long int high, long long int pos) {
if (lazy1[pos] != 0) {
tree1[pos] += lazy1[pos] * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += lazy1[pos];
lazy1[2 * pos + 2] += lazy1[pos];
}
lazy1[pos] = 0;
}
if (low > qh || high < ql) return 0;
if (ql <= low && qh >= high) return tree1[pos];
long long int mid = (low + high) / 2;
return MRQ1(ql, qh, low, mid, 2 * pos + 1) +
MRQ1(ql, qh, mid + 1, high, 2 * pos + 2);
}
void update1(long long int ql, long long int qh, long long int val,
long long int low, long long int high, long long int pos) {
if (lazy1[pos] != 0) {
tree1[pos] += lazy1[pos] * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += lazy1[pos];
lazy1[2 * pos + 2] += lazy1[pos];
}
lazy1[pos] = 0;
}
if (low > qh || high < ql) return;
if (ql <= low && qh >= high) {
tree1[pos] += val * (high - low + 1);
if (low != high) {
lazy1[2 * pos + 1] += val;
lazy1[2 * pos + 2] += val;
}
return;
}
long long int mid = (low + high) / 2;
update1(ql, qh, val, low, mid, 2 * pos + 1);
update1(ql, qh, val, mid + 1, high, 2 * pos + 2);
tree1[pos] = tree1[2 * pos + 1] + tree1[2 * pos + 2];
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first;
for (int i = 1; i <= n; i++) cin >> a[i].second;
for (int i = n; i >= 1; i--) {
sor[a[i].second]++;
}
map<long long int, long long int>::iterator itr;
int cnt = 0;
for (itr = sor.begin(); itr != sor.end(); itr++) {
cnt++;
val[itr->first] = cnt;
}
for (int i = 1; i <= n; i++) a[i].second = val[a[i].second];
sort(a + 1, a + n + 1);
construct(0, n, 0);
construct1(0, n, 0);
long long int res = 0;
for (int i = n; i >= 1; i--) {
res += MRQ(a[i].second, n, 0, n, 0) -
MRQ1(a[i].second, n, 0, n, 0) * a[i].first;
update1(a[i].second, a[i].second, 1, 0, n, 0);
update(a[i].second, a[i].second, a[i].first, 0, n, 0);
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000 + 10, maxl = 20;
int q, n = 4, a, b, k = 2, h[MAXN], par[MAXN][maxl + 5];
vector<int> adj[MAXN];
int get_par(int v, int d) {
for (int i = maxl; i >= 0; i--)
if ((d >> i) & 1 == 1) {
v = par[v][i];
}
return v;
}
int LCA(int x, int y) {
if (h[x] < h[y]) swap(x, y);
x = get_par(x, h[x] - h[y]);
if (x == y) return x;
for (int i = maxl; i >= 0; i--)
if (par[x][i] != par[y][i]) {
x = par[x][i];
y = par[y][i];
}
return par[x][0];
}
int main() {
a = 1;
b = 2;
for (int i = 1; i < 4; i++) {
h[i] = 1;
par[i][0] = 0;
}
for (int j = 0; j < maxl; j++)
for (int i = 0; i < n; i++) par[i][j] = par[par[i][j - 1]][j - 1];
cin >> q;
for (int i = 0, v; i < q; i++) {
scanf("%d", &v);
v--;
h[n] = h[v] + 1;
h[n + 1] = h[v] + 1;
par[n][0] = v;
par[n + 1][0] = v;
for (int j = 1; j < maxl; j++) {
par[n][j] = par[par[n][j - 1]][j - 1];
par[n + 1][j] = par[par[n + 1][j - 1]][j - 1];
}
int l1 = LCA(n, a);
int l2 = LCA(n, b);
int dis1 = h[n] + h[a] - 2 * h[l1];
int dis2 = h[n] + h[b] - 2 * h[l2];
if (dis1 >= dis2) {
if (dis1 > k) {
k++;
b = n;
}
} else {
if (dis2 > k) {
k++;
a = n;
}
}
n += 2;
printf("%d \n", k);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<int> candidates(n);
for (int i = 0; i < m; ++i) {
std::vector<int> xx(n);
for (int& x : xx) {
std::cin >> x;
}
++candidates[std::distance(xx.begin(),
std::max_element(xx.begin(), xx.end()))];
}
std::cout << (std::distance(
candidates.begin(),
std::max_element(candidates.begin(), candidates.end())) +
1)
<< std::endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30003;
int main() {
long long n, p, d, w;
cin >> n >> p >> w >> d;
for (int i = 0; i < min(n + 1, w); i++) {
long long remP = p - i * d;
if (remP < 0) break;
long long remMatches = n - i;
if (remP % w) continue;
if (remP / w <= remMatches)
return cout << remP / w << " " << i << " " << n - i - remP / w, 0;
}
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ret;
}
int n, m, ans;
char s[35][35];
int board[35][35], sel[35], samp[35];
int cov[35][35];
int sx[20], sy[20], bel[35][2];
int oc[20];
pair<int, int> ord[35];
int cut[35];
bool used[35][35];
void dfs(int x) {
int xx = sx[x], yy = sy[x];
if (x > 1) {
for (int(i) = (cut[x - 2] + 1); (i) <= (cut[x - 1]); (i)++) {
int id = ord[i].second;
int a = sel[bel[id][0]], b = sel[bel[id][1]];
if (used[a][b]) {
for (int(j) = (cut[x - 2] + 1); (j) <= (i - 1); (j)++) {
int id = ord[j].second;
int a = sel[bel[id][0]], b = sel[bel[id][1]];
used[a][b] = used[b][a] = 0;
}
return;
}
used[a][b] = used[b][a] = 1;
}
}
if (x == 15) {
ans++;
if (ans == 1)
for (int(i) = (1); (i) <= (14); (i)++) samp[i] = sel[i];
for (int(i) = (cut[x - 2] + 1); (i) <= (cut[x - 1]); (i)++) {
int id = ord[i].second;
int a = sel[bel[id][0]], b = sel[bel[id][1]];
used[a][b] = used[b][a] = 0;
}
return;
}
for (int(i) = (0); (i) <= (6); (i)++)
if (oc[i] < 2) {
oc[i]++;
sel[x] = i;
dfs(x + 1);
sel[x] = 0;
oc[i]--;
}
if (x > 1)
for (int(i) = (cut[x - 2] + 1); (i) <= (cut[x - 1]); (i)++) {
int id = ord[i].second;
int a = sel[bel[id][0]], b = sel[bel[id][1]];
used[a][b] = used[b][a] = 0;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%s", s[i] + 1);
int num = 0;
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (m); (j)++)
if (s[i][j] != '.' && !cov[i][j]) {
num++;
cov[i][j] = num;
cov[i][j + 1] = num;
cov[i + 1][j] = num;
cov[i + 1][j + 1] = num;
sx[num] = i;
sy[num] = j;
}
int cnt = 0;
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (m); (j)++)
if (s[i][j] != '.') {
if (i < n && s[i][j] == s[i + 1][j]) {
cnt++;
bel[cnt][0] = cov[i][j];
bel[cnt][1] = cov[i + 1][j];
ord[cnt] = make_pair(max(cov[i][j], cov[i + 1][j]), cnt);
}
if (j < m && s[i][j] == s[i][j + 1]) {
cnt++;
bel[cnt][0] = cov[i][j];
bel[cnt][1] = cov[i][j + 1];
ord[cnt] = make_pair(max(cov[i][j], cov[i][j + 1]), cnt);
}
}
sort(ord + 1, ord + cnt + 1);
for (int(i) = (1); (i) <= (cnt); (i)++) cut[ord[i].first] = i;
dfs(1);
printf("%d\n", ans);
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (m); (j)++) {
if (s[i][j] == '.')
putchar('.');
else
putchar(samp[cov[i][j]] + '0');
if (j == m) puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x[110], y[110];
int dis(int i, int j) { return abs(x[i] - x[j]) + abs(y[i] - y[j]); }
int main() {
int n, d;
scanf("%d%d", &n, &d);
int addt[110];
int cost[110][110];
addt[1] = 0;
addt[n] = 0;
for (int i = 2; i < n; i++) scanf("%d", &addt[i]);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cost[i][j] = dis(i, j) * d - addt[i];
if (i == j) cost[i][j] = 0;
}
for (int k = 2; k <= n; k++)
for (int i = 2; i <= n; i++)
for (int j = 2; j <= n; j++)
if (i != j)
if (cost[i][k] + cost[k][j] < cost[i][j])
cost[i][j] = cost[i][k] + cost[k][j];
int ans = 0x4f4f4f4f;
for (int i = 2; i <= n; i++) {
int temp = dis(1, i) * d;
if (cost[i][n] >= 0) temp += cost[i][n];
if (temp < ans) ans = temp;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
void solve() {
stringstream ss;
int n;
cin >> n;
ss << oct << n;
string s;
ss >> s;
int ctr = 0;
for (int i = 0; i < s.size(); i++) ctr += s[i] == '1';
cout << ctr;
}
int main() {
srand(1313);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18, MOD = 1e9 + 7;
const int N = 1e5 + 10, N2 = 26 * N + 10, INFI = 1e9 + 10, L = 19;
int n, a[N], dp[N];
priority_queue<pair<int, int> > q;
long long add(long long a, long long b) {
long long sum = a + b;
if (sum < 0) {
sum += MOD;
}
if (sum >= MOD) {
sum -= MOD;
}
return sum;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
q.push({a[i], i});
}
while (!q.empty()) {
int i = q.top().second;
for (int j = i + a[i]; j < n; j += a[i]) {
if (a[j] > a[i]) {
if (!dp[j]) {
dp[i] = 1;
break;
}
}
}
for (int j = i - a[i]; j >= 0; j -= a[i]) {
if (a[j] > a[i]) {
if (!dp[j]) {
dp[i] = 1;
break;
}
}
}
q.pop();
}
for (int i = 0; i < n; i++) {
cout << (dp[i] ? 'A' : 'B');
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
long long ans = 0, Min, Max;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i < n; i++) {
Min = min(a[i], a[i + 1]);
Max = max(a[i], a[i + 1]);
if (Min == Max)
continue;
else
ans += (n - Max + 1) * (Max - Min) + Min * (Max - Min);
}
ans += a[1] * (n - a[1] + 1) + a[n] * (n - a[n] + 1);
printf("%lld", ans / 2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char c;
int sum = 0;
if (n % 2 == 0) {
int f = 1;
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == '(')
sum++;
else
sum--;
if (sum < -1) break;
}
if (sum != 0) f = 0;
if (f)
cout << "Yes\n";
else
cout << "No\n";
} else
cout << "No\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void bolt() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long first[100001];
long long second[100001];
long long dp[100001][3];
int32_t main() {
bolt();
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> first[i];
}
for (long long i = 1; i <= n; i++) {
cin >> second[i];
}
for (long long i = 1; i <= n; i++) {
dp[i][0] = max({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]});
dp[i][1] = max(dp[i - 1][0] + first[i], dp[i - 1][2] + first[i]);
dp[i][2] = max(dp[i - 1][0] + second[i], dp[i - 1][1] + second[i]);
}
cout << max({dp[n][0], dp[n][1], dp[n][2]});
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using llint = long long;
const int N = 1e6 + 200;
int phi;
int n, m, a, q;
llint fac[N];
llint inv[N];
llint cm[N];
llint dd[N];
llint mul(llint a, llint b, llint m) {
a %= m, b %= m;
a = a * b % m;
if (a < 0) a += m;
return a;
}
llint mypw(llint a, llint b, llint phi) {
llint ret = 1;
while (b) {
if (b & 1) ret = ret * a % phi;
a = a * a % phi;
b >>= 1;
}
return ret;
}
void init() {
fac[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = fac[i - 1] * i % phi;
}
for (int i = 0; i < N; ++i) {
inv[i] = mypw(fac[i], phi - 2, phi);
}
}
llint C(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fac[a] * inv[b] % phi * inv[a - b] % phi;
}
llint add(llint a, llint b, int phi) {
a = (a + b) % phi;
if (a < 0) a += phi;
return a;
}
void run() {
scanf("%d%d%d%d", &n, &m, &a, &q);
llint p = 1;
phi = -1;
for (int i = 1;; ++i) {
p = mul(p, a, q);
if (p == 1) {
phi = i;
break;
}
}
init();
for (int i = 0; i <= m; ++i) {
cm[i] = C(m, i);
}
dd[0] = cm[0];
for (int i = 1; i <= m; ++i) {
dd[i] = add(dd[i - 1], cm[i], phi);
}
vector<int> coef(n, 0);
int k = 0;
for (int i = n - 1; i >= 0; --i) {
coef[i] = dd[k];
k++;
k = min(m, k);
}
for (int i = 0; i < n; ++i) {
printf("%lld%c", mypw(a, coef[i], q), " \n"[i == n - 1]);
}
}
int main() {
run();
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f;
const int _INF = 0x80000000;
long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
long long lcd(long long a, long long b) { return a * b / gcd(a, b); }
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
using namespace std;
int main() {
int n, m;
long long x;
int flag = 0;
long long minn = 1e18;
cin >> n >> m;
getchar();
long long a = read(), b = read();
long long gcdx = abs(a - b);
long long last = b;
minn = minn > a ? a : minn > b ? b : minn > a ? a : minn;
for (int i = 0; i < n - 2; i++) {
a = read();
minn = minn > a ? a : minn;
gcdx = gcd(abs(a - last), gcdx);
last = a;
}
x = gcdx;
for (int i = 0; i < m; i++) {
long long y;
y = read();
if (x % y == 0) flag = i + 1;
}
if (flag == 0)
printf("NO\n");
else {
printf("YES\n");
cout << minn << ' ' << flag << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
long k;
scanf("%ld", &k);
int d;
scanf("%d", &d);
long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
if (d == 1) {
cout << 1 << endl;
} else {
set<long> con;
unordered_map<long, int> cnt;
for (int i = 0; i < d; i++) {
con.insert(arr[i]);
cnt[arr[i]]++;
}
long ans = con.size();
long final = con.size();
if (final == 1) {
cout << 1 << endl;
} else {
for (int i = 0; i < n - d; i++) {
cnt[arr[i]]--;
if (cnt[arr[i]] == 0) {
ans--;
}
cnt[arr[i + d]]++;
if (cnt[arr[i + d]] == 1) {
ans++;
}
final = min(final, ans);
}
cout << final << endl;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
void Open() {}
const long long mod = int(1e9 + 7), N = 1e5 + 55, oo = int(1e9);
bitset<60> vis;
vector<vector<int>> adjList;
int tmp, cur = 0, cnt = 0;
void dfs(int node, int dis) {
if (vis[node]) return;
if (dis > cur) {
dis = cur;
tmp = node;
}
cnt++;
vis[node] = 1;
for (int child : adjList[node]) {
dfs(child, dis + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
Open();
int n, m;
cin >> n >> m;
adjList = vector<vector<int>>(n);
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
long long ans = 1;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
bitset<60> vis2 = vis;
cur = 0;
cnt = 0;
dfs(i, 0);
dfs(tmp, 0);
ans <<= cnt - 1;
vis = vis2;
dfs(i, 0);
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const int M = 4000;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long llINF = 0x3f3f3f3f3f3f3f3f;
long long make_compiler_happy() { return INF & maxn & mod & llINF; }
long long fpow(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long inv(long long x) { return fpow(x, mod - 2); }
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
vector<int> g[maxn];
int n, m;
int dp[2][2][M * 2 + 1];
bool vis[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> len;
for (int v : g[0]) {
if (vis[v]) continue;
int u = 0, l = 1;
while (v) {
vis[v] = 1;
l++;
int tmp = v;
v = u ^ g[v][0] ^ g[v][1];
u = tmp;
}
len.push_back(l);
}
int cur = 0;
dp[0][0][M] = 1;
for (int l : len) {
cur ^= 1;
memset(dp[cur], 0, sizeof(dp[cur][0]) * (2));
for (int t = 0; t < (2); t++) {
for (int i = 0; i < (2 * M + 1); i++) {
int v = dp[!cur][t][i];
if (v) {
add(dp[cur][t][i], v);
add(dp[cur][t][i - l], v);
add(dp[cur][t][i + l], v);
}
}
}
for (int i = (1); i <= (2 * M); i++)
add(dp[!cur][0][i], dp[!cur][0][i - 1]);
for (int i = 0; i < (2 * M + 1); i++) {
add(dp[cur][1][i], dp[!cur][0][min(2 * M, i + l - 2)] * 2 % mod);
if (i - l + 2 > 0)
add(dp[cur][1][i], (mod - dp[!cur][0][i - l + 1]) * 2 % mod);
}
}
int ans = dp[cur][1][M];
cur = 0;
memset(dp[0], 0, sizeof(dp[0][0]) * (2));
dp[0][0][M] = 1;
for (int l : len) {
cur ^= 1;
memset(dp[cur], 0, sizeof(dp[cur][0]) * (2));
for (int t = 0; t < (2); t++) {
for (int i = 0; i < (2 * M + 1); i++) {
int v = dp[!cur][t][i];
if (v) {
add(dp[cur][t][i - l], v);
add(dp[cur][t][i + l], v);
}
}
}
for (int i = 0; i < (2 * M + 1); i++) {
int v = dp[!cur][0][i];
if (v) {
add(dp[cur][1][i - l + 1], 2 * v % mod);
add(dp[cur][1][i + l - 1], 2 * v % mod);
}
}
}
add(ans, dp[cur][1][M]);
add(ans, dp[cur][0][M]);
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, l, k = 0, p = 0, t = 1, x, y, z, r, c;
long long a[100005] = {0};
long long b[100005];
string s;
x = 0, y = 20000;
cin >> n;
for (i = 0; i < n; i++) {
cin >> m >> s;
if (s == "South" && (y - m) < 0) {
t = 0;
cout << "NO";
break;
} else if (s == "North" && (x - m) < 0) {
t = 0;
cout << "NO";
break;
} else if (s == "East" && (y == 0 || x == 0)) {
t = 0;
cout << "NO";
break;
} else if (s == "West" && (y == 0 || x == 0)) {
t = 0;
cout << "NO";
break;
} else if (s == "North") {
x -= m;
y += m;
} else if (s == "South") {
x += m;
y -= m;
}
}
if (i == n && x == 0 && y == 20000)
cout << "YES";
else if (t == 1)
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, nr = 0, s = 0, t;
cin >> n >> k;
t = 240 - k;
for (int i = 1; i <= n; i++) {
s = s + 5 * i;
if (s <= t) nr++;
}
cout << nr;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6 + 5;
long long a[maxn], n, m, t, ans, k;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> m;
a[m] = i;
if (k < m) k = m;
}
t = maxn;
for (long long i = 0; i <= k; i++) {
if (a[i] < t && a[i]) t = a[i], ans = i;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int ans = 0;
int n = s.size();
for (int i = 0; i < n; i++) {
int a = 0, b = 0;
for (int j = i; j < n; j++) {
if (s[j] == '(') a++, b++;
if (s[j] == ')') a--, b--;
if (s[j] == '?') a++, b--;
if (a < 0) break;
if (b < 0) b = 0;
if ((j - i + 1) % 2 == 0 && b == 0) ans++;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q, v[1 << 19];
int main() {
scanf(" %d", &q);
while (q--) {
char c;
char number[20];
int mask = 0;
scanf(" %c %s", &c, number);
if (c == '+') {
int p = strlen(number);
for (int k = 0; k < 18 && p - k > 0; k++) {
if ((number[p - k - 1] - '0') % 2) mask += (1 << k);
}
v[mask]++;
} else if (c == '-') {
int p = strlen(number);
for (int k = 0; k < 18 && p - k > 0; k++) {
if ((number[p - k - 1] - '0') % 2) mask += (1 << k);
}
v[mask]--;
} else {
int p = strlen(number);
for (int k = 0; k < 18 && p - k > 0; k++) {
if (number[p - k - 1] == '1') mask += (1 << k);
}
printf("%d\n", v[mask]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long exp, long long m) {
long long ans = 1;
b %= m;
while (exp) {
if (exp & 1) ans = (ans * b) % m;
exp >>= 1;
b = (b * b) % m;
}
return ans;
}
double ttm;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, x = 0, r, c;
cin >> n >> m;
char a[200][200];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'B') {
if (x == 0) {
r = i, c = j;
}
x++;
}
}
}
long long second = sqrt(x);
second /= 2;
cout << r + second << " " << c + second << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 101234, MM = 20123;
int a[MN], b[MM], dp[10 * MN], gp[10 * MN], l[MN], r[MN];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) cin >> b[i];
sort(b, b + m);
for (int i = 1; i < n; i++)
if (a[i - 1] + 1 == a[i])
l[i] = l[i - 1];
else
l[i] = i;
r[n - 1] = n - 1;
for (int i = n - 2; i >= 0; i--)
if (a[i + 1] - 1 == a[i])
r[i] = r[i + 1];
else
r[i] = i;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++)
if (b[j] <= a[i]) cnt++;
if (i == l[i])
dp[i] = (i ? gp[i - 1] : 0);
else
dp[i] = dp[i - 1];
for (int j = 0; j < cnt; j++)
if (i - (a[i] - b[j]) >= 0) {
if (!l[i - (a[i] - b[j])])
dp[i] = max(dp[i], cnt - j);
else
dp[i] = max(dp[i], gp[l[i - (a[i] - b[j])] - 1] + cnt - j);
}
if (i) gp[i] = max(gp[i], gp[i - 1]);
gp[i] = max(gp[i], dp[i]);
for (int j = cnt; j < m; j++)
if (i + (b[j] - a[i]) < n)
gp[i + (b[j] - a[i])] = max(gp[i + (b[j] - a[i])], dp[i] + j - cnt + 1);
}
cout << gp[n - 1] << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXK = 9;
const int MAXLEN = 19;
const int MAXS = 9 * MAXLEN / 2;
const int XLEN = 5;
int xoff[10];
long long xmask[10];
vector<long long> opt[MAXK + 1][MAXLEN + 1];
vector<long long> ways[MAXK + 1][MAXLEN + 1][10];
long long wayspar[2][MAXLEN + 1];
bitset<MAXS + 1> can[10];
void dfscan(int d, int cnt, int sum, long long x) {
if (d > 9) {
int mx = sum / 2;
while (!can[d - 1].test(mx)) --mx;
int k = sum - 2 * mx;
assert(k <= MAXK);
if (k >= 2) opt[k][0].push_back(x);
} else {
can[d] = can[d - 1];
while (true) {
dfscan(d + 1, cnt, sum, x);
if (cnt >= MAXLEN) break;
++cnt;
sum += d;
x += 1LL << xoff[d];
can[d] |= can[d] << d;
}
}
}
void precalc() {
wayspar[0][0] = 1;
for (int i = (0); i < (MAXLEN); ++i)
wayspar[0][i + 1] = wayspar[0][i] * 5 + wayspar[1][i] * 5,
wayspar[1][i + 1] = wayspar[0][i] * 5 + wayspar[1][i] * 5;
xoff[1] = 0;
for (int i = (2); i <= (9); ++i) xoff[i] = xoff[i - 1] + XLEN;
for (int i = (1); i <= (9); ++i)
xmask[i] = ((long long)((1 << XLEN) - 1)) << xoff[i];
can[0].set(0);
dfscan(1, 0, 0, 0);
for (int k = (2); k <= (MAXK); ++k) {
sort(opt[k][0].begin(), opt[k][0].end());
opt[k][0].erase(unique(opt[k][0].begin(), opt[k][0].end()),
opt[k][0].end());
for (int d = (0); d < (10); ++d)
ways[k][0][d] = vector<long long>(((int)(opt[k][0]).size()), 1);
for (int i = (0); i < (MAXLEN); ++i) {
for (int x = (0); x < (((int)(opt[k][i]).size())); ++x) {
int sum = 0;
for (int d = (1); d <= (9); ++d)
if ((opt[k][i][x] & xmask[d]) != 0)
opt[k][i + 1].push_back(opt[k][i][x] - (1LL << xoff[d])),
sum += (opt[k][i][x] & xmask[d]) >> xoff[d];
if (sum < MAXLEN) opt[k][i + 1].push_back(opt[k][i][x]);
}
sort(opt[k][i + 1].begin(), opt[k][i + 1].end());
opt[k][i + 1].erase(unique(opt[k][i + 1].begin(), opt[k][i + 1].end()),
opt[k][i + 1].end());
for (int d = (0); d < (10); ++d)
ways[k][i + 1][d] = vector<long long>(((int)(opt[k][i + 1]).size()), 0);
for (int x = (0); x < (((int)(opt[k][i]).size())); ++x) {
int sum = 0;
for (int d = (1); d <= (9); ++d)
if ((opt[k][i][x] & xmask[d]) != 0) {
int nx = lower_bound(opt[k][i + 1].begin(), opt[k][i + 1].end(),
opt[k][i][x] - (1LL << xoff[d])) -
opt[k][i + 1].begin();
assert(0 <= nx && nx < ((int)(opt[k][i + 1]).size()) &&
opt[k][i + 1][nx] == opt[k][i][x] - (1LL << xoff[d]));
ways[k][i + 1][d][nx] += ways[k][i][9][x];
sum += (opt[k][i][x] & xmask[d]) >> xoff[d];
}
if (sum < MAXLEN) {
int nx = lower_bound(opt[k][i + 1].begin(), opt[k][i + 1].end(),
opt[k][i][x]) -
opt[k][i + 1].begin();
assert(0 <= nx && nx < ((int)(opt[k][i + 1]).size()) &&
opt[k][i + 1][nx] == opt[k][i][x]);
ways[k][i + 1][0][nx] += ways[k][i][9][x];
}
}
for (int d = (1); d <= (9); ++d)
for (int x = (0); x < (((int)(opt[k][i + 1]).size())); ++x)
ways[k][i + 1][d][x] += ways[k][i + 1][d - 1][x];
}
}
}
char s[MAXLEN + 1];
long long calc(long long lim, int k) {
sprintf(s, "%lld", lim);
int slen = strlen(s);
long long ret = 0, x = 0;
for (int i = (0); i < (slen); ++i) {
int d = s[i] - '0';
if (d == 0) continue;
int idx = lower_bound(opt[k][slen - i].begin(), opt[k][slen - i].end(), x) -
opt[k][slen - i].begin();
if (idx != ((int)(opt[k][slen - i]).size()) && opt[k][slen - i][idx] == x) {
ret += ways[k][slen - i][d - 1][idx];
}
x += 1LL << xoff[d];
}
return ret;
}
long long calcodd(long long lim) {
sprintf(s, "%lld", lim);
int slen = strlen(s);
long long ret = 0;
int par = 0;
for (int i = (0); i < (slen); ++i) {
int d = s[i] - '0';
if (d == 0) continue;
int oddhere = d / 2, evnhere = (d + 1) / 2;
ret += wayspar[par][slen - i - 1] * oddhere +
wayspar[1 - par][slen - i - 1] * evnhere;
if (d % 2 == 1) par ^= 1;
}
return ret;
}
long long solve(long long l, long long r, int kmx) {
long long ret = r - l + 1;
if (kmx == 0) {
ret -= calcodd(r + 1) - calcodd(l);
for (int k = 2; k <= MAXK; k += 2) ret -= calc(r + 1, k) - calc(l, k);
} else {
for (int k = (kmx + 1); k <= (MAXK); ++k)
ret -= calc(r + 1, k) - calc(l, k);
}
return ret;
}
void run() {
int nq;
scanf("%d", &nq);
for (int qi = (0); qi < (nq); ++qi) {
long long l, r;
int k;
scanf("%lld%lld%d", &l, &r, &k);
printf("%lld\n", solve(l, r, k));
}
}
int main() {
precalc();
run();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
long long n;
cin >> n;
long long res = 0;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
string s;
cin >> s;
long long a = 0, max1 = 0, max2 = 0, save1 = -1, save2 = n;
for (long long i = 0; i < n; i++) {
if (s[i] == 'A')
a += arr[i];
else
a -= arr[i];
if (a > max1) {
max1 = a;
save1 = i;
}
}
a = 0;
for (long long i = n - 1; i >= 0; i--) {
if (s[i] == 'A')
a += arr[i];
else
a -= arr[i];
if (a > max2) {
max2 = a;
save2 = i;
}
}
if (max1 > max2) {
for (long long j = 0; j < n; j++) {
if (j <= save1) {
if (s[j] == 'A') res += arr[j];
} else if (s[j] == 'B')
res += arr[j];
}
} else {
for (long long j = n - 1; j >= 0; j--) {
if (j >= save2) {
if (s[j] == 'A') res += arr[j];
} else if (s[j] == 'B')
res += arr[j];
}
}
cout << res << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int ddx[8] = {1, 1, 0, -1, -1, -1, 0, 1}, ddy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void mad(long long &a, long long b) {
a = (a + b) % 998244353;
if (a < 0) a += 998244353;
}
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
long long powmod(long long a, long long po) {
if (po == 0) return 1;
if (po == 1) return a;
long long int p1 = powmod(a, po / 2ll);
long long int p2 = p1 * p1;
long long p3 = powmod(a, po % 2ll);
return ((p2 % 998244353) * (p3 % 998244353)) % 998244353;
}
void solve() {
long long n;
cin >> n;
long long ans = 0;
long long p[n];
for (int i = 0; i < n; i++) cin >> p[i];
long long cur = 1;
for (int i = n - 1; i >= 0; i--) {
cur = (cur * 100 % 998244353 * powmod(p[i], 998244353 - 2)) % 998244353;
mad(ans, cur);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int di[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dj[] = {1, -1, 0, 0, -1, 1, 1, -1};
const int N = 3e5 + 5;
int n;
vector<int> adj[N];
long long ans[N];
vector<pair<int, int> > info[N];
struct fenwick {
vector<long long> bit;
fenwick(int n) : bit(n + 2) {}
void upd(int p, int v) {
for (int i = ++p; i < bit.size(); i += i & -i) bit[i] += v;
}
long long get(int p) {
long long sum = 0;
for (int i = ++p; i; i -= i & -i) sum += bit[i];
return sum;
}
long long query(int l, int r) { return get(r) - get(l - 1); }
} tree(N);
void dfs(int node, int par, int dep) {
for (auto &q : info[node]) tree.upd(min(n - 1, dep + q.first), q.second);
ans[node] = tree.query(dep, n - 1);
for (int child : adj[node]) {
if (child == par) continue;
dfs(child, node, dep + 1);
}
for (auto &q : info[node]) tree.upd(min(n - 1, dep + q.first), -q.second);
}
int main() {
scanf("%d", &n);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int q, v, d, second;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &v, &d, &second);
info[v].push_back({min(d, n - 1), second});
}
dfs(1, 1, 0);
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, c[6], ans;
void solve() {
cin >> x >> y;
ans = 0;
for (int i = 0; i < 6; i++) cin >> c[i];
for (int i = 0; i < 100; i++) {
c[0] = min(c[0], c[1] + c[5]);
c[1] = min(c[1], c[0] + c[2]);
c[2] = min(c[2], c[3] + c[1]);
c[3] = min(c[3], c[4] + c[2]);
c[4] = min(c[4], c[3] + c[5]);
c[5] = min(c[5], c[0] + c[4]);
}
if (x * y <= 0) {
if (x > 0)
ans += c[5] * x;
else
ans += c[2] * llabs(x);
if (y > 0)
ans += c[1] * y;
else
ans += c[4] * llabs(y);
} else if (x < 0) {
ans += llabs(max(x, y)) * c[3];
if (x < y)
ans += (y - x) * c[2];
else
ans += (x - y) * c[4];
} else {
ans += min(x, y) * c[0];
if (x < y)
ans += (y - x) * c[1];
else
ans += (x - y) * c[5];
}
cout << ans << '\n';
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v;
for (int(i) = 0; (i) < (n); (i)++) {
long long k;
cin >> k;
v.push_back(k);
}
long long m;
cin >> m;
long long maxi = -1;
for (int(u) = 0; (u) < (m); (u)++) {
long long w, h;
cin >> w >> h;
maxi = max(maxi, v[w - 1]);
cout << maxi << endl;
maxi += h;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x != 1 && x != 2 && x != 4 && x != 5 && x != 8 && x != 11)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 107;
const int oo = 0x3f3f3f3f;
const long long loo = 4223372036854775807ll;
const long long mod = 1e9 + 7;
set<long long> se;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long b;
while (cin >> b) {
se.clear();
long long q, l, m;
cin >> q >> l >> m;
for (long long i = 0; i < m; i++) {
long long t;
cin >> t;
se.insert(t);
}
long long k = 0;
int fuck = 0;
while (b <= l && -b <= l) {
fuck++;
if (se.count(b) == 0) {
k++;
}
b = b * q;
if (fuck > 10000) {
fuck = 0x3f3f3f3f;
break;
}
}
if (k < 1000)
cout << k << endl;
else
cout << "inf" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int const N = 2 * 1e5 + 5, M = 205;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, cnt = 0, cnt1 = 0;
cin >> n >> m;
for (int i = 0, x; i < n; i++) cin >> x, cnt += (x & 1);
for (int i = 0, x; i < m; i++) cin >> x, cnt1 += (x & 1);
cout << min(cnt, (m - cnt1)) + min(cnt1, (n - cnt));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
int n, middle, ret;
bool* matrix;
int* value;
int i, j;
int main(int argc, char* argv[]) {
cin >> n;
matrix = new bool[n * n];
value = new int[n * n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> value[i * n + j];
matrix[i * n + j] = false;
}
}
middle = (n - 1) / 2;
for (i = 0; i < n; i++) {
matrix[i * n + i] = matrix[(n - i - 1) * n + i] = matrix[middle * n + i] =
matrix[i * n + middle] = true;
}
ret = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (matrix[i * n + j]) {
ret += value[i * n + j];
}
}
}
cout << ret;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int n, m, h;
int g[maxn][maxn][maxn];
int d[3][4] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
bool judge(int a, int b, int c) {
if (!g[a][b][c]) return false;
for (int i = 0; i < 3; i++)
if (g[a - d[i][0]][b - d[i][1]][c - d[i][2]]) {
for (int j = 0; j < 3; j++)
if (g[a + d[j][0]][b + d[j][1]][c + d[j][2]]) {
if (i == j)
return true;
else if (!g[a - d[i][0] + d[j][0]][b - d[i][1] + d[j][1]]
[c - d[i][2] + d[j][2]])
return true;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 1; k <= h; k++) scanf("%1d", &g[i][j][k]);
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 1; k <= h; k++)
if (judge(i, j, k)) ans++;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
int n, m;
int h, w;
pair<int, int> mas[N];
long long fac[300000], rfac[300000];
long long mod = 1e9 + 7;
inline long long BiPow(long long base, int deg) {
long long res = 1;
while (deg) {
if (deg & 1) res = (res * base) % mod;
base = (base * base) % mod;
deg >>= 1;
}
return res;
}
long long ans[N];
inline int mul(int x, int y) { return (x * (long long)y) % mod; }
inline int c(int x, int y) { return mul(mul(fac[y], rfac[x]), rfac[y - x]); }
void solve() {
cin >> h >> w >> n;
fac[0] = 1;
rfac[0] = 1;
for (int i = 1; i <= h + w; ++i) {
fac[i] = mul(fac[i - 1], i);
rfac[i] = BiPow(fac[i], mod - 2);
}
for (int i = 0; i < n; ++i) {
cin >> mas[i].first >> mas[i].second;
}
sort(mas, mas + n);
mas[n++] = pair<int, int>(h, w);
for (int i = 0; i < n; ++i) {
ans[i] = c(mas[i].first - 1, mas[i].first + mas[i].second - 2);
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (mas[j].first < mas[i].first || mas[j].second < mas[i].second)
continue;
int x = mas[j].first - mas[i].first, y = mas[j].second - mas[i].second;
ans[j] -= mul(ans[i], c(x, x + y));
ans[j] = (ans[j] + mod) % mod;
}
}
cout << ans[n - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double result = 0;
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
if (v > 0) result += ((double)v / 100.0);
}
printf("%0.12f\n", (((double)result / (double)n)) * 100.00000000000);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
double n;
cin >> n;
double r = 1 / (2 * tan((360 / (4 * n)) * (3.1415926535 / 180)));
cout << setprecision(15) << 2 * r << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int data[m];
for (int i = 0; i < m; ++i) cin >> data[i];
sort(data, data + m);
bool ok = m == 0 || data[0] > 1 && data[m - 1] < n;
for (int i = 2; ok && i < m; ++i) {
if (data[i] - data[i - 2] == 2) ok = false;
}
cout << (ok ? "YES\n" : "NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[] = {1, 0, 1, 2, 9};
long long Cnk(long long n, long long k) {
long long res = 1;
if (k < 4) k = n - k;
for (long long i = n; i > k; i--) res *= (i);
for (long long i = 1; i <= n - k; i++) res /= i;
return res;
}
int main() {
long long n, k;
cin >> n >> k;
long long ans = 0;
for (long long i = n - k; i <= n; i++) {
ans += dp[n - i] * Cnk(n, i);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int inf = 1 << 30;
const long long linf = 1LL << 62;
const int MAX = 1020000;
long long dy[8] = {0, -1, 0, 1, 1, -1, 1, -1};
long long dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T>
inline void print(T &a) {
for (long long i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << "\n";
}
template <typename T1, typename T2>
inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
long long pcount(long long x) { return __builtin_popcountll(x); }
const int mod = 998244353;
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
int sz, height;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(int n, const F f, const G g, const H h, const Monoid &M1,
const OperatorMonoid OM0)
: f(f), g(g), h(h), M1(M1), OM0(OM0) {
sz = 1;
height = 0;
while (sz < n) sz <<= 1, height++;
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void set(int k, const Monoid &x) { data[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
inline void propagate(int k) {
if (lazy[k] != OM0) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = reflect(k);
lazy[k] = OM0;
}
}
inline Monoid reflect(int k) {
return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
}
inline void recalc(int k) {
while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
}
inline void thrust(int k) {
for (int i = height; i > 0; i--) propagate(k >> i);
}
void update(int a, int b, const OperatorMonoid &x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) lazy[l] = h(lazy[l], x), ++l;
if (r & 1) --r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
Monoid query(int a, int b) {
thrust(a += sz);
thrust(b += sz - 1);
Monoid L = M1, R = M1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) L = f(L, reflect(l++));
if (r & 1) R = f(reflect(--r), R);
}
return f(L, R);
}
Monoid operator[](const int &k) { return query(k, k + 1); }
template <typename C>
int find_subtree(int a, const C &check, Monoid &M, bool type) {
while (a < sz) {
propagate(a);
Monoid nxt =
type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C>
int find_first(int a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, reflect(1)))) return find_subtree(1, check, L, false);
return -1;
}
thrust(a + sz);
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, reflect(a));
if (check(nxt)) return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C>
int find_last(int b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(reflect(1), R))) return find_subtree(1, check, R, true);
return -1;
}
thrust(b + sz - 1);
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(reflect(--b), R);
if (check(nxt)) return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
struct T {
long long val, sz;
};
T f(T a, T b) { return T{a.val + b.val, a.sz + b.sz}; }
T g(T a, long long b) {
if (b == linf) return a;
a.val = b * a.sz;
return a;
}
long long h(long long a, long long b) {
if (b == linf)
return a;
else
return b;
}
void solve() {
int n, q;
cin >> n >> q;
vector<long long> a(n);
for (long long i = 0; i < (n); i++) cin >> a[i];
LazySegmentTree<T, long long> seg(n, f, g, h, T{0, 0}, linf);
for (long long i = 0; i < (n); i++) {
seg.set(i, T{a[i], 1});
}
seg.build();
for (long long z = 0; z < (q); z++) {
int t, x, y;
cin >> t >> x >> y;
x--;
if (t == 1) {
int l = -1, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (seg.query(mid, mid + 1).val > y)
l = mid;
else
r = mid;
}
if (l + 1 <= x) seg.update(l + 1, x + 1, y);
} else {
int ans = 0;
while (x < n) {
int val = seg.query(x, x + 1).val;
if (val > y) {
int l = x, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (seg.query(mid, mid + 1).val > y)
l = mid;
else
r = mid;
}
x = l + 1;
} else if (val >= y / 2) {
y -= val;
ans++;
x++;
} else {
auto check = [&](T a) { return a.val > y; };
int R = seg.find_first(x, check);
if (R == -1) R = n + 1;
R--;
ans += R - x;
y -= seg.query(x, R).val;
x = R;
}
}
cout << ans << "\n";
}
}
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 4;
const int maxlog = 20;
const long long inf = 1e18;
const int mod = 1e9 + 7;
const long long base = 307;
int buy[maxn][maxn], sell[maxn][maxn], cap[maxn][maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, c;
cin >> n >> m >> c;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int k = 0; k < m; k++) cin >> buy[i][k] >> sell[i][k] >> cap[i][k];
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
vector<pair<int, int> > v;
for (int k = 0; k < m; k++)
v.push_back(make_pair(sell[j][k] - buy[i][k], cap[i][k]));
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int res = 0, c2 = c;
for (int k = 0; k < m; k++) {
if (v[k].first <= 0) break;
res = res + min(v[k].second, c2) * v[k].first;
c2 -= min(v[k].second, c2);
}
ans = max(ans, res);
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 605;
int n, fa[N], dep[N], vis[N], col[N];
vector<int> a[N], prt[2];
map<vector<int>, int> mp;
int qry(vector<int> a) {
if (a.size() <= 1) return 0;
sort(a.begin(), a.end());
if (mp.count(a)) return mp[a];
printf("? %d\n", a.size());
for (int i = 0; i < a.size(); i++) printf("%d ", a[i]);
cout << endl;
int ans;
scanf("%d", &ans);
return mp[a] = ans;
}
int qry(vector<int> a, vector<int> b) {
vector<int> t;
for (int i = 0; i < a.size(); i++) t.push_back(a[i]);
for (int i = 0; i < b.size(); i++) t.push_back(b[i]);
return qry(t) - qry(a) - qry(b);
}
void dfs(int x) {
vis[x] = 1;
prt[col[x]].push_back(x);
for (int i = 0; i < a[x].size(); i++)
if (!vis[a[x][i]]) {
int v = a[x][i];
fa[v] = x;
dep[v] = dep[x] + 1;
col[v] = col[x] ^ 1;
dfs(v);
}
}
void gtans(int x, int y) {
vector<int> a, b;
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) {
a.push_back(x);
x = fa[x];
}
while (x != y) {
a.push_back(x);
x = fa[x];
b.push_back(y);
y = fa[y];
}
a.push_back(x);
while (!b.empty()) {
a.push_back(b.back());
b.pop_back();
}
printf("N %d\n", a.size());
for (int i = 0; i < a.size(); i++) printf("%d ", a[i]);
cout << endl;
exit(0);
}
void wrk(vector<int> a) {
if (a.size() == 2) gtans(a[0], a[1]);
while (true) {
random_shuffle(a.begin(), a.end());
vector<int> b, c;
for (int i = 0; i < a.size(); i++)
if (i & 1)
b.push_back(a[i]);
else
c.push_back(a[i]);
if (qry(b)) wrk(b);
if (qry(c)) wrk(c);
}
}
int main() {
scanf("%d", &n);
vector<int> v1, v2;
v1.push_back(1);
for (int i = 2; i <= n; i++) v2.push_back(i);
while (v2.size()) {
vector<int> r = v2, p1, p2;
while (r.size() > 1) {
int mid = r.size() / 2;
p1.clear();
p2.clear();
for (int j = 0; j < r.size(); j++)
if (j < mid)
p1.push_back(r[j]);
else
p2.push_back(r[j]);
if (qry(v1, p1))
r = p1;
else
r = p2;
}
vector<int> bck = r;
int p = r.back();
r = v1;
while (r.size() > 1) {
int mid = r.size() / 2;
p1.clear();
p2.clear();
for (int j = 0; j < r.size(); j++)
if (j < mid)
p1.push_back(r[j]);
else
p2.push_back(r[j]);
if (qry(p1, bck))
r = p1;
else
r = p2;
}
int d = r.back();
a[p].push_back(d);
a[d].push_back(p);
v1.push_back(p);
for (int j = 0; j < v2.size(); j++)
if (v2[j] == p) {
v2.erase(v2.begin() + j);
break;
}
}
dfs(1);
if (qry(prt[0]) + qry(prt[1]) == 0) {
printf("Y %d\n", prt[0].size());
for (int i = 0; i < prt[0].size(); i++) printf("%d ", prt[0][i]);
cout << endl;
return 0;
}
if (qry(prt[0]))
wrk(prt[0]);
else
wrk(prt[1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v1, v2, v3, vm;
cin >> v1 >> v2 >> v3 >> vm;
for (int i = 1; i <= 200; i++) {
for (int j = i + 1; j <= 200; j++) {
for (int k = j + 1; k <= 200; k++) {
if ((v1 <= k) && (v2 <= j) && (v3 <= i) && (vm <= k) && (vm <= j) &&
(vm <= i) && (2 * v1 >= k) && (2 * v2 >= j) && (2 * v3 >= i) &&
(2 * vm >= i) && (2 * vm < j) && (2 * vm < k)) {
cout << k << "\n" << j << "\n" << i << "\n";
return 0;
}
}
}
}
cout << -1 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, x, size;
int freq[100001] = {};
cin >> s >> n;
size = s.length() - 1;
for (int i = 0; i < n; i++) {
cin >> x;
freq[x - 1]++;
}
for (int i = 0; i <= size / 2; i++) {
if (i) freq[i] += freq[i - 1];
}
for (int i = 0; i <= size / 2; i++) {
if (freq[i] % 2 != 0) {
char temp = s[i];
s[i] = s[size - i];
s[size - i] = temp;
}
}
cout << s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
void printDouble(double x, int n) {
cout << fixed << setprecision(n);
cout << x << endl;
}
const int MAXN = 5e6 + 5;
const int mod = 1e9 + 7;
long long product() { return 1; }
long long sum() { return 0; }
template <typename T, typename... Args>
T product(T a, Args... args) {
return (a * product(args...)) % mod;
}
template <typename T, typename... Args>
T sum(T a, Args... args) {
return (a + sum(args...)) % mod;
}
long long e2(long long x) {
if (x == 0) return 1;
if (x == 1) return 2;
if (x % 2 == 0) {
long long y = e2(x / 2);
return (y * y);
}
return 2 * (e2(x - 1));
}
int main() {
std::ios::sync_with_stdio(false);
int x, n, m;
cin >> n >> m;
vector<vector<int> > numRow(2, vector<int>(n + 1, 0)),
numCol(2, vector<int>(m + 1, 0));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> x;
numRow[x][i]++;
numCol[x][j]++;
}
long long res = 0;
for (int i = 0; i <= 1; i++)
for (int j = 1; j <= n; j++) res += e2(numRow[i][j]);
for (int i = 0; i <= 1; i++)
for (int j = 1; j <= m; j++) res += e2(numCol[i][j]);
cout << res - 2 * n - 2 * m - n * m << endl;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.