solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long power(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 min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<long long> div(long long n) {
vector<long long> v;
for (int i = 1; i * i <= n; i++) {
if ((n % i) == 0) {
if (i == n / i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
return v;
}
long long isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void solve() {
long long n;
cin >> n;
vector<long long> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
map<int, int> m;
long long ans = 1;
for (int i = 0; i < n; i++) {
vector<long long> v = div(A[i]);
for (int i = 0; i < v.size(); i++) {
if (v[i] > 1) m[v[i]]++;
}
}
for (auto it : m) ans = max(ans, (it).second);
cout << ans << "\n";
}
int main() {
int T;
T = 1;
while (T--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, -1, 0};
int dy[4] = {1, 0, 0, -1};
void a() {
long long n;
cin >> n;
vector<long long> v(2 * n + 1);
vector<long long> odd, even;
for (long long i = 1; i <= 2 * n; i++) {
cin >> v[i];
if (v[i] % 2) {
odd.emplace_back(i);
} else {
even.emplace_back(i);
}
}
n = n - 1;
for (long long i = 0; i + 1 < odd.size(); i += 2) {
if (n <= 0) break;
cout << odd[i] << " " << odd[i + 1];
n--;
cout << '\n';
}
if (n > 0) {
for (long long i = 0; i + 1 < even.size(); i += 2) {
if (n <= 0) break;
cout << even[i] << " " << even[i + 1];
n--;
cout << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
a();
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long l, r;
long long cal(long long n) {
long long t = n, x = 1;
while (t != 0) x *= 10, t /= 10;
x--;
return n * (x - n);
}
int main() {
cin >> l >> r;
long long res = 0, k = 5;
res = max(cal(l), cal(r));
for (int i = 0; i <= 9; i++) {
if (k >= l && k <= r) res = max(res, cal(k));
k *= 10;
}
cout << res;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
vector<int> nei[501];
int ideg[501];
bool outcyc[501];
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
nei[x].push_back(y);
}
for (i = 1; i <= n; i++) {
int j, k, outcycno = 0;
fill(ideg + 1, ideg + n + 1, 0);
for (j = 1; j <= n; j++)
for (k = 0; k < nei[j].size(); k++) ideg[nei[j][k]]++;
fill(outcyc + 1, outcyc + n + 1, false);
while (true) {
bool changed = false;
for (j = 1; j <= n; j++)
if (ideg[j] == 0 || j == i && ideg[j] == 1) {
if (outcyc[j]) continue;
outcycno++;
outcyc[j] = changed = true;
for (k = 0; k < nei[j].size(); k++) ideg[nei[j][k]]--;
}
if (!changed) break;
}
if (outcycno == n) return !printf("YES");
}
printf("NO");
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<char> calced(n);
vector<string> a(n);
set<string> have;
int res = 0;
for (string& pin : a) {
cin >> pin;
have.insert(pin);
}
for (int i = 0; i < n; i++) {
if (calced[i]) {
continue;
}
vector<int> sameIds;
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j]) {
sameIds.push_back(j);
calced[j] = 1;
res++;
for (int k = 0; k < 4 && a[i] == a[j]; k++) {
for (char c = '0'; c <= '9'; c++) {
string t = a[j];
t[k] = c;
if (!have.count(t)) {
have.insert(t);
a[j] = t;
break;
}
}
}
}
}
}
cout << res << "\n";
for (string& s : a) {
cout << s << "\n";
}
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
struct SGT {
int minn[1200000], maxn[1200000];
inline void pushup(int o) {
minn[o] = min(minn[o * 2], minn[o * 2 + 1]);
maxn[o] = max(maxn[o * 2], maxn[o * 2 + 1]);
}
void build(int l, int r, int o, int *fir1, int *fir2) {
if (l == r) {
minn[o] = fir1[l];
maxn[o] = fir2[l];
} else {
int m = ((l + r) >> 1);
build(l, m, o * 2, fir1, fir2);
build(m + 1, r, o * 2 + 1, fir1, fir2);
pushup(o);
}
}
pair<int, int> query(int l, int r, int o, int lx, int rx) {
if (l >= lx && r <= rx)
return pair<int, int>(minn[o], maxn[o]);
else {
int m = ((l + r) >> 1);
if (m >= rx) return query(l, m, o * 2, lx, rx);
if (m < lx) return query(m + 1, r, o * 2 + 1, lx, rx);
pair<int, int> a = query(l, m, o * 2, lx, rx),
b = query(m + 1, r, o * 2 + 1, lx, rx);
return pair<int, int>(min(a.first, b.first), max(a.second, b.second));
}
}
} tr[20];
int l[20][300005], r[20][300005];
int num[300005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
num[2 * n + i] = num[n + i] = num[i];
}
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= 3 * n; i++) {
l[0][i] = max(1, i - num[i]);
r[0][i] = min(3 * n, i + num[i]);
}
tr[0].build(1, 3 * n, 1, l[0], r[0]);
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= 3 * n; j++) {
pair<int, int> t = tr[i - 1].query(1, 3 * n, 1, l[i - 1][j], r[i - 1][j]);
l[i][j] = t.first;
r[i][j] = t.second;
}
tr[i].build(1, 3 * n, 1, l[i], r[i]);
}
for (int i = 1; i <= n; i++) {
int nl = n + i, nr = n + i, ans = 0;
for (int j = 19; j >= 0; j--) {
pair<int, int> t = tr[j].query(1, 3 * n, 1, nl, nr);
if (t.second - t.first + 1 < n) {
ans += (1 << j);
nl = t.first;
nr = t.second;
}
}
printf("%d ", ans + 1);
}
printf("\n");
return 0;
}
| 21
|
#include <bits/stdc++.h>
const int inf = 0xfffffff;
const long long INF = 1ll << 61;
using namespace std;
int n, m;
int nnum[100005 + 55];
int fa[100005 + 55];
int sum[100005 + 55];
typedef struct Node {
int fro, to, nex;
int val;
Node(int a = 0, int b = 0, int c = 0) : fro(a), to(b), val(c) {}
};
Node edge[100005 + 55];
void init() {
memset(nnum, 0, sizeof(nnum));
memset(edge, 0, sizeof(edge));
for (int i = 0; i < 100005; i++) fa[i] = i;
for (int i = 0; i < 100005; i++) sum[i] = 1;
}
bool input() {
while (scanf("%d %d", &n, &m) == 2) {
for (int i = 1; i <= n; i++) scanf("%d", &nnum[i]);
int q = m;
int cnt = 0;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[i] = Node(u, v, min(nnum[u], nnum[v]));
}
return false;
}
return true;
}
bool cmp(Node x, Node y) { return x.val > y.val; }
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void cal() {
sort(edge, edge + m, cmp);
double ans = 0;
for (int i = 0; i < m; i++) {
int dx = find(edge[i].fro);
int dy = find(edge[i].to);
if (dx != dy) {
ans += (double)edge[i].val * sum[dx] * sum[dy];
fa[dx] = dy;
sum[dy] += sum[dx];
}
}
printf("%.6lf\n", (ans * 2) / (n * 1.0 * (n - 1)));
}
void output() {}
int main() {
while (true) {
init();
if (input()) return 0;
cal();
output();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int pw(int a, int n) {
int ans = 1;
while (n) {
if (n % 2 == 1) {
ans = ans * a;
n--;
} else {
a = a * a;
n = n / 2;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, i;
cin >> n;
long long ans;
ans = min(9, n);
for (i = 1; i <= 9; i++) {
if (n > pow(10, i) - 1) {
ans += (min(pw(10, i + 1) - 1, n) - (pw(10, i) - 1)) * 1LL * (i + 1);
}
}
cout << ans << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
long long int second;
long long int length;
};
long long int power(long long int n, long long int k) {
long long int result = 1;
while (k > 0) {
if (k % 2 == 1) result = (result * n) % 1000000009;
n = (n * n) % 1000000009;
k = k / 2;
}
return result;
}
int main() {
long long int n, m, k;
cin >> n >> m >> k;
long long int val = n / k;
long long int ans = 0;
long long int z = m - (n - val);
val = z;
if (val < 0) val = 0;
long long int r =
(((power(2, val + 1) - 2) * k) % 1000000009 + m - val * k) % 1000000009;
if (r < 0) r += 1000000009;
cout << r << endl;
return 0;
}
| 8
|
#include <bits/stdc++.h>
int main() {
int a, b, y, sophuttoida;
scanf("%d %d", &a, &b);
y = a - b;
if ((a + b) > 2) {
if (y % 3 == 0) {
sophuttoida = a + b - 3;
} else {
sophuttoida = a + b - 2;
}
} else {
sophuttoida = 0;
}
printf("%d", sophuttoida);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
inline string get_string() {
char ch[1000000];
scanf("%s", ch);
return ch;
}
inline int get_Int() {
int x;
scanf("%d", &x);
return x;
}
inline string get_String() {
string x;
cin >> x;
return x;
}
inline long long get_long() {
long long x;
cin >> x;
return x;
}
vector<string> Position(3);
void solve() {
int n, k;
scanf("%d %d", &n, &k);
bool condition = true;
for (int i = 0; i < 3; i++) {
cin >> Position[i];
if (Position[i][0] == 's') Position[i][0] = '1';
for (int j = 1; j < n; j++)
if (Position[i][j] != '.') Position[i][j] = '0';
}
bool canGo = false;
while (condition && canGo == false) {
condition = false;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n - 1; j++) {
if (Position[i][j] == '1') {
condition = true;
i = 5;
break;
}
}
}
int Index = -1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
if ((Position[i][j] == '1' && Index == -1) ||
(j == Index && Position[i][j] == '1')) {
if (Index == -1) Index = j;
if (j == n - 1) {
canGo = true;
i = 5;
break;
}
Position[i][j] = '.';
for (int NextRow = 0; NextRow < 3; NextRow++) {
if (Position[NextRow][j + 1] != '0' && abs(NextRow - i) <= 1) {
if (NextRow < i && Position[i][j + 1] == '0') continue;
if (NextRow > i && Position[i][j + 1] == '0') continue;
Position[NextRow][j + 1] = '1';
}
}
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
if (Position[i][j] == '0') {
Position[i][j] = '.';
if (j >= 2) Position[i][j - 2] = '0';
}
}
}
}
if (canGo)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double w, h, w1 = 1, h1 = 1, w2, h2;
cin >> h >> w;
for (int x = 0; (1ll << x) <= h; x++) {
h2 = (1 << x);
w2 = ceil(h2 / 1.25 - 1e-9);
if (w2 < floor(h2 / .8 + 1e-9) + 1e-9 && w2 < w + 1e-9) {
w2 = min(w, floor(h2 / .8 + 1e-9));
if (w2 * h2 > w1 * h1) {
w1 = w2;
h1 = h2;
} else if (abs(w1 * h1 - w2 * h2) < 1e-9 && h2 > h1) {
h1 = h2;
w1 = w2;
}
}
}
for (int x = 0; (1ll << x) <= w; x++) {
w2 = (1 << x);
h2 = ceil(w2 * .8 - 1e-9);
if (h2 < floor(w2 * 1.25 + 1e-9) + 1e-9 && h2 < h + 1e-9) {
h2 = min(h, floor(w2 * 1.25 + 1e-9));
if (w1 * h1 < w2 * h2) {
w1 = w2;
h1 = h2;
} else if (abs(w1 * h1 - w2 * h2) < 1e-9 && h2 > h1) {
h1 = h2;
w1 = w2;
}
}
}
cout.precision(0);
cout.flags(ios::fixed);
cout << h1 << " " << w1 << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100060;
class Point {
public:
double x, y;
void read() { scanf("%lf%lf", &x, &y); }
Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
double len() { return sqrt(x * x + y * y); }
} P, v[Maxn];
const double pi = acos(-1);
const double eps = 1e-7;
Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
Point operator+(const Point &a, const Point &b) {
return Point(a.x + b.x, a.y + b.y);
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double dis(Point a, Point b) {
return sqrt((double)(a.x - b.x) * (a.x - b.x) +
(double)(a.y - b.y) * (a.y - b.y));
}
double DisToLine(Point p, Point a, Point v2) {
Point v1 = p - a;
return fabs(cross(v2, v1) / v2.len());
}
int main() {
int n;
scanf("%d", &n);
P.read();
double R = 0, r = 1e9;
for (int i = 1; i <= n; ++i) v[i].read();
for (int i = 1; i <= n; ++i) {
double len = dis(P, v[i]);
R = max(R, len), r = min(r, len);
}
v[++n] = v[1];
for (int i = 1; i < n; ++i) {
if (dot(P - v[i], v[i + 1] - v[i]) >= 0 &&
dot(P - v[i + 1], v[i] - v[i + 1]) >= 0) {
r = min(r, DisToLine(P, v[i], v[i + 1] - v[i]));
}
}
double area = pi * (R - r) * (R + r);
printf("%.6lf\n", area);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n;
map<string, int> count_;
string ans[70007];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 0; j < 9; j++) {
for (int l = 1; l <= 9 - j; l++) {
string v = s.substr(j, l);
if (count_[v] == 0) {
count_[v] = i;
} else if (count_[v] != i) {
count_[v] = -1;
}
}
}
ans[i] = "XXXXXXXXXX";
}
for (map<string, int>::iterator it = count_.begin(); it != count_.end();
it++) {
int j = it->second;
if (j != -1) {
if (ans[j].length() > it->first.length()) {
ans[j] = it->first;
}
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int n, a, sol, c[MAX];
multiset<int> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
c[a]++;
}
for (int i = 0; i <= MAX; i++)
if (c[i]) sol += c[i] - 1;
printf("%d\n", sol + 1);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2097152;
int n, m, a[N], r[N], pw, len;
bool vis[N];
struct Complex {
double r, i;
};
inline Complex operator+(Complex a, Complex b) {
return {a.r + b.r, a.i + b.i};
}
inline Complex operator*(Complex a, Complex b) {
return {a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r};
}
inline Complex operator-(Complex a, Complex b) {
return {a.r - b.r, a.i - b.i};
}
const double PI = acos(-1);
void FastFastTle(Complex a[N], int fl) {
for (int i = 0; i < len; i++)
if (i < r[i]) swap(a[i], a[r[i]]);
for (int l = 1; l < len; l <<= 1) {
Complex wn{cos(PI / l), sin(PI / l) * fl};
for (int i = 0; i < len; i += l << 1) {
Complex w{1, 0};
for (int j = 0; j < l; j++, w = w * wn) {
Complex x = a[i + j], y = w * a[i + l + j];
a[i + j] = x + y;
a[i + l + j] = x - y;
}
}
}
if (fl == -1)
for (int i = 0; i < len; i++) a[i].r /= len;
}
Complex f[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], vis[a[i]] = 1;
len = 1;
while (len <= m) len <<= 1, ++pw;
len <<= 1;
++pw;
for (int i = 0; i < len; i++) r[i] = (r[i >> 1] >> 1) + ((i & 1) << (pw - 1));
for (int i = 1; i <= m; i++) f[i].r = vis[i];
FastFastTle(f, 1);
for (int i = 0; i < len; i++) f[i] = f[i] * f[i];
FastFastTle(f, -1);
for (int i = 1; i <= m; i++) {
if (f[i].r + 0.5 < 1) continue;
if (!vis[i]) {
cout << "NO" << endl;
return 0;
}
vis[i] = 0;
}
cout << "YES\n" << accumulate(vis + 1, vis + m + 1, 0) << endl;
for (int i = 1; i <= m; i++)
if (vis[i]) cout << i << ' ';
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} debug;
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
bool first = true;
os << "[";
for (typename vector<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
const int NN = 112345;
int seg[NN];
void update(int i, int v) {
for (i += 5; i < NN; i += i & -i) seg[i] += v;
}
int query(int i) {
int ans = 0;
for (i += 5; i > 0; i -= i & -i) ans += seg[i];
return ans;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) update(i, 1);
int root = 0, d = -1, width = n;
while (m--) {
int t, a, b;
cin >> t >> a;
if (t & 1) {
int L = a, R = width - a;
if (L < R and d == -1) {
for (int i = 0; i < L; ++i) {
int x = root + L - 1 - i, y = root + L + i;
int v = query(x) - query(x - 1);
;
update(y, v);
}
root += L;
} else if (L < R) {
for (int i = 0; i < L; ++i) {
int x = root - L + 1 + i, y = root - L - i;
int v = query(x) - query(x - 1);
;
update(y, v);
}
root -= L;
} else if (d == -1) {
for (int i = 0; i < R; ++i) {
int x = root + width - R + i, y = root + width - R - 1 - i;
int v = query(x) - query(x - 1);
;
update(y, v);
}
root += width - R - 1, d = 1;
} else {
for (int i = 0; i < R; ++i) {
int x = root - width + R - i, y = root - width + R + 1 + i;
int v = query(x) - query(x - 1);
;
update(y, v);
}
root += R + 1 - width, d = -1;
}
width = max(L, R);
;
} else {
int x, y;
cin >> b;
if (d == -1)
x = root + a, y = root + b - 1;
else
x = root - a, y = root - b + 1;
if (x > y) swap(x, y);
;
int ans = query(y) - query(x - 1);
cout << ans << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long int z = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int k, j;
long long c = 0, sum = 0;
cin >> k;
string s;
cin >> s;
vector<long long> v;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
v.push_back(c);
c = 0;
continue;
}
c++;
}
v.push_back(c);
if (k == 0) {
for (auto x : v) sum += (x * (x + 1)) / 2;
} else {
for (int i = 0; i < v.size(); i++) {
j = i + k;
if (j < v.size()) sum += (v[i] + 1) * (v[j] + 1);
if (j >= v.size() - 1) break;
}
}
cout << sum;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, type, x, y, z, sx, sy, sz, Ix, Iy, Iz, cx, cy, k, tot, Q, A, S, tmp;
int L[N * 25], R[N * 25], a[N * 25], rt[N], son[N], ne[N], In[N], Out[N], v[N],
d[N], f[N][20];
void dfs(int x) {
In[x] = m++;
for (int y = son[x]; y; y = ne[y])
if (!d[y]) d[y] = d[x] + 1, dfs(y);
Out[x] = m++;
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
for (int i = 17; i >= 0; i--)
if (d[f[x][i]] > d[y]) x = f[x][i];
if (d[x] - d[y]) x = f[x][0];
if (x == y) return x;
for (int i = 17; i >= 0; i--)
if (f[x][i] - f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
void build(int &t, int l, int r) {
t = ++tot;
if (l == r) return;
int mid = (l + r) / 2;
build(L[t], l, mid);
build(R[t], mid + 1, r);
}
void add(int t, int &t1, int l, int r, int x) {
t1 = ++tot;
if (l == r) {
a[t1] = a[t] + A;
return;
}
int mid = (l + r) / 2;
if (x <= mid) {
R[t1] = R[t];
add(L[t], L[t1], l, mid, x);
} else
L[t1] = L[t], add(R[t], R[t1], mid + 1, r, x);
a[t1] = a[L[t1]] + a[R[t1]];
}
int query(int t, int t1, int l, int r, int x) {
if (r == x) return a[t] - a[t1];
int mid = (l + r) / 2;
if (x <= mid) return query(L[t], L[t1], l, mid, x);
return a[L[t]] - a[L[t1]] + query(R[t], R[t1], mid + 1, r, x);
}
int work(int i, int x, int sx, int k) {
int y = x;
for (int j = 17; j >= 0; j--)
if (z = f[y][j])
Iz = v[z] <= S, sz = d[z] - query(rt[i], rt[S], 1, m, In[z]),
y = sx - sz < k ? z : y;
return y;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", f[i]), ne[i] = son[f[i][0]], son[f[i][0]] = i;
for (int j = 0; j < 17; j++)
for (int i = 1; i <= n; i++) f[i][j + 1] = f[f[i][j]][j];
dfs(0), m -= 2;
build(rt[0], 1, m);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &type, &x);
if (type < 2) {
v[x] = i;
A = 1;
add(rt[i - 1], tmp, 1, m, In[x]);
A = -1;
add(tmp, rt[i], 1, m, Out[x]);
} else {
scanf("%d%d%d", &y, &k, &S);
z = lca(x, y);
rt[i] = rt[i - 1], Ix = v[x] <= S,
sx = d[x] - query(rt[i], rt[S], 1, m, In[x]), Iy = v[y] <= S,
sy = d[y] - query(rt[i], rt[S], 1, m, In[y]), Iz = v[z] <= S,
sz = d[z] - query(rt[i], rt[S], 1, m, In[z]), cx = sx - sz + Iz,
cy = sy - sz, k += Ix,
printf("%d\n", cx + cy - Iy < k ? -1
: cx >= k ? work(i, x, sx, k)
: work(i, y, sy, cy + cx - k + 1));
}
}
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int const nmax = 200000;
class FenwickTree {
private:
int n;
vector<int> aib;
public:
FenwickTree(int n_) {
n = n_;
aib.resize(1 + n);
}
void update(int pos, int val) {
for (int x = pos; x <= n; x += (x ^ (x & (x - 1)))) aib[x] += val;
}
int query(int pos) {
int result = 0;
for (int x = pos; 0 < x; x &= (x - 1)) result += aib[x];
return result;
}
int lowerthan(int target) {
int x = 0;
for (int jump = (1 << 20); 0 < jump; jump /= 2) {
if (x + jump <= n && aib[x + jump] < target) {
target -= aib[x + jump];
x += jump;
}
}
return x + 1;
}
};
char s[1 + nmax];
set<int> freq[1 + nmax];
void event(int x, int y, int val, FenwickTree &aib) {
set<int>::iterator it;
it = freq[val].lower_bound(x);
while (it != freq[val].end() && *it <= y) {
aib.update(*it, -1);
freq[val].erase(it++);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
int ptr = 0;
map<char, int> id;
for (char i = 'a'; i <= 'z'; i++) id[i] = ++ptr;
for (char i = 'A'; i <= 'Z'; i++) id[i] = ++ptr;
for (char i = '0'; i <= '9'; i++) id[i] = ++ptr;
FenwickTree aib(n);
for (int i = 1; i <= n; i++) {
aib.update(i, 1);
cin >> s[i];
freq[id[s[i]]].insert(i);
}
for (int i = 1; i <= q; i++) {
int x, y;
char c;
cin >> x >> y >> c;
event(aib.lowerthan(x), aib.lowerthan(y), id[c], aib);
}
for (int i = 1; i <= n; i++)
if (aib.query(i) - aib.query(i - 1) == 1) cout << s[i];
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 2100 * 500;
const int maxm = 4100;
const int mod = 1e9 + 7;
const int inf = 1e9 + 500;
vector<pair<char, pair<int, int> > > bach[maxn];
int cn = 2;
int en[maxn];
int trii[maxm][26];
int vazn[maxm][26];
int enn[maxm];
int sz[maxn];
int cnn = 1;
int k;
int dp[maxm][2100];
void add(string s) {
int p = 1;
for (int i = 0; i < s.size(); i++) {
s[i] -= 'a';
char c = s[i];
bool peyda = 0;
for (int j = 0; j < bach[p].size(); j++) {
if (bach[p][j].first == c) {
peyda = 1;
p = bach[p][j].second.first;
break;
}
}
if (!peyda) {
bach[p].push_back(make_pair(c, make_pair(cn, 1)));
p = cn;
cn++;
}
}
en[p]++;
}
int compp(int p) {
int kh = cnn;
cnn++;
for (int i = 0; i < bach[p].size(); i++) {
int v = compp(bach[p][i].second.first);
trii[kh][bach[p][i].first] = v;
vazn[kh][bach[p][i].first] = bach[p][i].second.second;
}
enn[kh] = en[p];
return kh;
}
void comp(int p) {
for (int i = 0; i < bach[p].size(); i++) {
comp(bach[p][i].second.first);
}
for (int i = 0; i < bach[p].size(); i++) {
char c = bach[p][i].first;
int v = bach[p][i].second.first;
if (bach[v].size() == 1 && en[v] == 0) {
bach[p][i].second.second += bach[v][0].second.second;
bach[p][i].second.first = bach[v][0].second.first;
}
}
}
void dfs(int a) {
sz[a] = enn[a];
for (int i = 0; i <= sz[a]; i++) {
dp[a][i] = 0;
}
for (int i = 0; i < 26; i++) {
int v = trii[a][i];
if (v != 0) {
dfs(v);
for (int p = sz[a] + sz[v]; p >= 0; p--) {
for (int k = 0; k <= sz[v]; k++) {
int j = p - k;
if (j < 0 || j > sz[a]) {
continue;
}
dp[a][p] =
max(dp[a][p], dp[a][j] + dp[v][k] + vazn[a][i] * k * (k - 1) / 2);
}
}
sz[a] += sz[v];
}
}
}
int main() {
for (int i = 0; i < maxm; i++) {
for (int j = 0; j < 2100; j++) {
dp[i][j] = -inf;
}
}
int n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
add(s);
}
comp(1);
compp(1);
dfs(1);
cout << dp[1][k];
}
| 10
|
#include <iostream>
#include <vector>
#include <random>
typedef unsigned long long ull;
typedef signed long long sll;
using namespace std;
size_t vmin(vector<size_t>& values) {
size_t ans = -1;
for (auto& v : values) ans = min(ans, v);
return ans;
}
size_t vmax(vector<size_t>& values) {
size_t ans = 0;
for (auto& v : values) ans = max(ans, v);
return ans;
}
size_t first_incorrect, last_incorrect;
vector<size_t> coord_sums, coord_sq_sums;
vector<vector<size_t>> shuffled_positions;
size_t m, k, i, j, t, correct_coef, d, cur_sq_sum, cur_coef;
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL);
cin >> m >> k;
shuffled_positions.resize(k);
coord_sums.reserve(k); coord_sq_sums.reserve(k);
for (auto& row : shuffled_positions) {
row.resize(m);
coord_sums.push_back(0);
coord_sq_sums.push_back(0);
for (auto& v : row) {
cin >> v;
coord_sums.back() += v;
coord_sq_sums.back() += v * v;
}
}
first_incorrect = last_incorrect = 0;
for (i = 1; i < k - 1; i++) {
if (coord_sums[i + 1] - coord_sums[i - 0] !=
coord_sums[i - 0] - coord_sums[i - 1]) {
if (!first_incorrect) first_incorrect = i;
last_incorrect = i;
}
}
if (first_incorrect == 1) {
j = last_incorrect - 1;
} else if (last_incorrect == k - 2) {
j = first_incorrect + 1;
} else {
j = first_incorrect + 1;
}
cout << j << " ";
if (j < 3) {
t = j + 1;
} else {
t = 0;
}
correct_coef = coord_sq_sums[t] + coord_sq_sums[t + 2]
- 2 * coord_sq_sums[t + 1];
d = (coord_sums[t + 1] - coord_sums[t]) - (coord_sums[j + 1] - coord_sums[j]);
#ifndef ONLINE_JUDGE
cout << "[d=" << d << ", cc=" << correct_coef << "]";
#endif // ONLINE_JUDGE
for (i = 0; i < m; i++) {
cur_sq_sum = coord_sq_sums[j];
cur_sq_sum -= shuffled_positions[j][i] * shuffled_positions[j][i];
cur_sq_sum += (shuffled_positions[j][i] - d) * (shuffled_positions[j][i] - d);
cur_coef = coord_sq_sums[j - 1] + coord_sq_sums[j + 1] - 2 * cur_sq_sum;
#ifndef ONLINE_JUDGE
cout << " [" << shuffled_positions[j][i] - d << "->" << shuffled_positions[j][i]
<< " csqs=" << cur_sq_sum << " cc=" << cur_coef << "]";
#endif
if (cur_coef == correct_coef) {
cout << shuffled_positions[j][i] - d << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 22
|
#include <bits/stdc++.h>
long long dp[105][105][105];
long long pre[105][105][105];
long long flo[105][105][105];
long long cost[105][105];
long long clr[105];
int main() {
int n, m, cnt;
scanf("%d%d%d", &n, &m, &cnt);
for (int i = 1, p; i <= n; i++) {
scanf("%d", &p);
clr[i] = p;
}
for (int i = 1, p; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &p);
cost[i][j] = p;
}
long long setans = 0;
for (int i = 1; i <= n; i++)
if (clr[i] != 0) setans -= cost[i][clr[i]];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m + 1; j++)
for (int k = 0; k <= cnt + 1; k++)
pre[i][j][k] = flo[i][j][k] = dp[i][j][k] = 10000000000000000ll;
for (int j = 1; j <= m; j++) dp[0][j][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
for (int k = 1; k <= cnt; k++) {
dp[i][j][k] =
((dp[i - 1][j][k] < pre[i - 1][j - 1][k - 1]
? dp[i - 1][j][k]
: pre[i - 1][j - 1][k - 1]) < flo[i - 1][j + 1][k - 1]
? (dp[i - 1][j][k] < pre[i - 1][j - 1][k - 1]
? dp[i - 1][j][k]
: pre[i - 1][j - 1][k - 1])
: flo[i - 1][j + 1][k - 1]) +
cost[i][j];
}
if (clr[i] != 0) {
for (int j = 1; j <= m; j++) {
if (j == clr[i]) continue;
for (int k = 1; k <= cnt; k++) dp[i][j][k] = 10000000000000000ll;
}
}
for (int k = 1; k <= cnt; k++) {
pre[i][0][k] = 10000000000000000ll;
flo[i][m + 1][k] = 10000000000000000ll;
for (int j = 1; j <= m; j++)
pre[i][j][k] =
(dp[i][j][k] < pre[i][j - 1][k] ? dp[i][j][k] : pre[i][j - 1][k]);
for (int j = m; j >= 1; j--)
flo[i][j][k] =
(dp[i][j][k] < flo[i][j + 1][k] ? dp[i][j][k] : flo[i][j + 1][k]);
}
}
long long ans = pre[n][m][cnt];
if (ans < 10000000000000000ll)
std::cout << ans + setans;
else
std::cout << "-1";
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const long long maxn = 3e5 + 10, maxm = 1e6 + 10, lg = 14, mod = 1e9 + 7,
inf = 1e18;
const long long M = (1 << lg) + 20;
string s;
long long a[lg], b[lg], dp[M], ans = inf;
long long ctn(char c) { return (c <= '9' ? c - '0' : c - 'a' + 10); }
char ntc(long long x) { return char(x < 10 ? x + '0' : x - 10 + 'a'); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
long long n = (long long)(s.size());
for (int i = 0; i < n; i++) a[i] = ctn(s[n - i - 1]);
for (int car = 0; car < (1 << (n - 1)); car++) {
long long tot = 0;
bool first = 1;
for (int i = 0; i < n; i++) b[i] = a[i];
for (int i = 0; i < n; i++) {
if (car >> i & 1) b[i] -= 16, b[i + 1]++;
tot += b[i], first &= (b[i] < 16);
}
if (tot != 0 || !first) continue;
memset(dp, 69, sizeof(dp));
dp[0] = 0;
for (int msk = 1; msk < (1 << n); msk++) {
long long sum = 0;
for (int i = 0; i < n; i++)
if (msk >> i & 1) sum += b[i];
if (sum < 0 || sum >= 16) continue;
for (int i = 0; i < n; i++)
if (msk >> i & 1)
if (dp[msk ^ (1 << i)] < inf)
dp[msk] =
min(dp[msk], dp[msk ^ (1 << i)] + ((sum - b[i]) << (4 * i)));
}
ans = min(ans, dp[(1ll << n) - 1]);
}
if (ans >= inf) return cout << "NO\n", 0;
s = "";
while (n--) {
s = ntc(ans & 15) + s;
ans >>= 4;
}
cout << s;
return 0;
}
| 25
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chk_mi(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <class T>
bool chk_mx(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <class T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <const int maxn, const int maxm>
struct Link_list {
int head[maxn], To[maxm], nxt[maxm], tot;
void init() { memset(head, tot = 0, sizeof head); }
void add(int x, int y) {
nxt[++tot] = head[x];
head[x] = tot;
To[tot] = y;
}
};
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
void Rd(int &res) {
res = 0;
char c;
while (c = getchar(), c < 48)
;
do res = (res << 3) + (res << 1) + (c & 15);
while (c = getchar(), 47 < c);
}
int A[300005], L[300005], R[300005], Sum[300005];
vector<int> E[1000005];
int find(int x, int l, int r) {
if (l > r) return 0;
if (E[x].empty()) return 0;
int lt = lower_bound(E[x].begin(), E[x].end(), l) - E[x].begin() - 1;
int rt = upper_bound(E[x].begin(), E[x].end(), r) - E[x].begin() - 1;
return rt - lt;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
int now = 0;
E[0].push_back(0);
for (int i = (1), i_END = (n); i <= i_END; i++) {
scanf("%d", &A[i]);
now = (now + A[i]) % k;
Sum[i] = now;
E[now].push_back(i);
}
for (int i = (1), i_END = (n); i <= i_END; i++) L[i] = i, R[i] = i;
for (int i = (2), i_END = (n); i <= i_END; i++) {
int now = i;
while (A[now - 1] <= A[i] && now > 1) now = L[now - 1];
L[i] = now;
}
for (int i = (n - 1), i_END = (1); i >= i_END; i--) {
int now = i;
while (A[now + 1] < A[i] && now < n) {
now = R[now + 1];
}
R[i] = now;
}
long long ans = 0;
for (int i = (1), i_END = (n); i <= i_END; i++) {
if (i - L[i] < R[i] - i) {
for (int j = (L[i]), j_END = (i); j <= j_END; j++) {
int a = Sum[j - 1];
int b = (a + A[i]) % k;
ans += find(b, i, R[i]);
}
} else {
for (int j = (i), j_END = (R[i]); j <= j_END; j++) {
int a = Sum[j];
int b = ((a - A[i]) % k + k) % k;
ans += find(b, L[i] - 1, i - 1);
}
}
}
printf("%lld\n", ans - n);
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
int n, m;
int dist[N][N];
vector<int> reach[N][N], adj[N], nx;
double prob[N], dprob[N];
double f(int city) {
double pE = 0;
for (int dist1 = 0; dist1 < n + 1; ++dist1) {
double today = 1.0 / n;
auto& reachables = reach[city][dist1];
if (reachables.empty()) continue;
int total = 0;
for (int r : reachables)
for (int v : adj[r]) {
if (prob[v] == 0.0) nx.push_back(v);
prob[v] += 1.0 / n / adj[r].size();
}
double tomorrow = 0;
for (int city2 = 1; city2 < n + 1; ++city2) {
for (int v : nx) {
int d = dist[city2][v];
dprob[d] = max(dprob[d], prob[v]);
}
double E = 0;
for (int v : nx) {
int d = dist[city2][v];
E += dprob[d];
dprob[d] = 0;
}
tomorrow = max(tomorrow, E);
}
for (int v : nx) prob[v] = 0;
nx.clear();
pE += max(today, tomorrow);
}
return pE;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < n + 1; ++j) dist[i][j] = 0xdeadbee;
dist[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
dist[u][v] = dist[v][u] = 1;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int k = 1; k < n + 1; ++k)
for (int i = 1; i < n + 1; ++i)
for (int j = 1; j < n + 1; ++j)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
for (int i = 1; i < n + 1; ++i)
for (int j = 1; j < n + 1; ++j)
if (dist[i][j] != 0xdeadbee) reach[i][dist[i][j]].push_back(j);
double mx = 0;
int mxi;
for (int i = 1; i < n + 1; ++i) {
if (mx < f(i)) {
mx = f(i);
mxi = i;
}
}
printf("%.20lf\n", mx);
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2;
int i, j, l;
cin >> s1 >> s2;
l = s1.length();
bool ch = false;
for (i = l - 1; i >= 0; i--) {
if (s1[i] != 'z') {
s1[i]++;
for (j = i + 1; j < l; j++) s1[j] = 'a';
ch = true;
break;
}
}
if (ch and s1 < s2)
cout << s1 << endl;
else
cout << "No such string\n";
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int arr[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
sort(arr, arr + n);
int ans = n;
long long sum = 0;
for (int i = 0; i < n; ++i) {
if (sum > arr[i])
--ans;
else
sum += arr[i];
}
printf("%d", ans);
return 0;
}
| 5
|
//我忘不掉夏小姐了。
//如果不是知道了咩粟小姐，说不定我已经对这个世界没有留恋了。
//巫沐小姐真的好可爱啊。做料理的时候笨拙的样子很可爱，故意撒娇，修女小姐也很可爱，唱歌的时候很可爱，生气拍桌子的时候也很可爱。
//所以我离不开星夜小姐了。如果早晨不是有多多小姐的起床闹钟的话，说不定我永远都不愿意睁眼了。如果晚上不是有黎歌小姐的直播预定的话，这一天我都不希望过完了。
//萨摩小姐的眼睛好灵动，如果能映照出我就好了。冷鸢小姐的笑容好温柔，如果只为我一个人绽放就好了。鹿乃小姐的头发好柔顺，如果能让我尽情抚摸就好了。
//白桃小姐这样的存在真的是被允许的吗。
//只是像现在这样默念七海小姐的名字，我就觉得自己是世界上最最最最最幸福的傻子。
#include<bits/stdc++.h>
using namespace std;
int n,c[200005];
vector<pair<int,int>> ans;
bool vis[200005];
void swp(int u,int v){
tie(c[u],c[v])=make_pair(-c[v],-c[u]);
ans.emplace_back(u,v);
}
void cycswp(int u,int v){
swp(u,v);
int x=u;
while(c[-c[x]]>0)swp(x,-c[x]);
x=-c[x];
while(c[-c[x]]>0)swp(x,-c[x]);
swp(x,-c[x]);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>c[i];
int p=-1;
for(int i=1;i<=n;i++)if(!vis[i]&&c[i]!=i){
int x=i;
do vis[x=c[x]]=true;
while(x!=i);
if(p==-1)p=i;
else cycswp(p,i),p=-1;
}
if(p!=-1){
bool f=true;
for(int i=1;i<=n;i++)if(c[i]==i){
cycswp(p,i);
f=false;
break;
}
if(f){
int x=c[p],y=c[c[p]];
swp(p,x);
cycswp(x,y);
}
}
cout<<ans.size()<<'\n';
for(pair<int,int> &p:ans)cout<<p.first<<' '<<p.second<<'\n';
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int mp[505][505];
int main() {
int n;
scanf("%d", &n);
memset(mp, 0, sizeof(mp));
char s[505];
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= n; j++) {
if (s[j] == 'X') mp[i][j] = 1;
}
}
int ans = 0;
for (int i = 2; i < n; i++) {
for (int j = 2; j < n; j++) {
if (mp[i][j] && mp[i - 1][j - 1] && mp[i - 1][j + 1] &&
mp[i + 1][j + 1] && mp[i + 1][j - 1]) {
ans++;
}
}
}
printf("%d\n", ans);
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5 + 5;
int T, n, t[Maxn * 4], m;
long long ans;
struct Node {
long long num;
int ini, seq;
} a[Maxn];
bool cmp1(const Node &a, const Node &b) { return a.num < b.num; }
bool cmp2(const Node &a, const Node &b) { return a.ini < b.ini; }
inline int lowbit(int x) { return x & -x; }
void add(int x) {
while (x <= m) {
t[x]++;
x += lowbit(x);
}
}
long long query(int l, int r) {
long long sumr = 0, suml = 0;
while (r) {
sumr += t[r];
r -= lowbit(r);
}
while (l) {
suml += t[l];
l -= lowbit(l);
}
return sumr - suml;
}
int main() {
cin >> T;
while (T--) {
cin >> n;
memset(t, 0, sizeof(t));
ans = 0;
for (int i = 1; i <= n; ++i) cin >> a[i].num, a[i].ini = i;
sort(a + 1, a + 1 + n, cmp1);
a[1].seq = 1;
for (int i = 2; i <= n; ++i)
a[i].seq = a[i - 1].seq + (a[i].num != a[i - 1].num);
m = a[n].seq;
sort(a + 1, a + 1 + n, cmp2);
for (int i = 1; i <= n; ++i) {
long long l = query(0, a[i].seq - 1), r = query(a[i].seq, m);
if (l < r)
ans += l;
else
ans += r;
add(a[i].seq);
}
cout << ans << "\n";
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, L, brk, cnt = 0;
cin >> n >> L >> brk;
long long t = 0;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
cnt = cnt + (x - t) / brk;
t = x + y;
if (i == n - 1) cnt += (L - t) / brk;
}
if (n == 0) cnt = L / brk;
cout << cnt;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int one[8] = {0};
for (int i = 1; i < 8; i++) one[i] = one[i / 2] + i % 2;
{
int n, m;
cin >> n >> m;
string mat[n];
for (int i = 0; i < n; i++) {
cin >> mat[i];
}
if (min(n, m) > 3) {
cout << "-1";
return 0;
}
int x = min(n, m);
int y = n + m - x;
int a[x][y];
if (x == n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) a[i][j] = mat[i][j] - '0';
}
} else {
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) a[i][j] = mat[j][i] - '0';
}
}
if (x == 1) {
cout << "0";
return 0;
} else if (x == 2) {
int arr[2] = {0};
for (int i = 0; i < y; i++) {
int val = a[0][i] * 2 + a[1][i];
if (i % 2 == 0) {
arr[0] += min(one[val ^ 0], one[val ^ 3]);
arr[1] += min(one[val ^ 1], one[val ^ 2]);
} else {
arr[1] += min(one[val ^ 0], one[val ^ 3]);
arr[0] += min(one[val ^ 1], one[val ^ 2]);
}
}
cout << min(arr[0], arr[1]);
} else {
int arr[4] = {0};
for (int i = 0; i < y; i++) {
int val = a[0][i] * 4 + a[1][i] * 2 + a[2][i];
if (i % 2 == 0) {
arr[0] += min(one[val ^ 0], one[val ^ 7]);
arr[1] += min(one[val ^ 1], one[val ^ 6]);
arr[2] += min(one[val ^ 2], one[val ^ 5]);
arr[3] += min(one[val ^ 3], one[val ^ 4]);
} else {
arr[3] += min(one[val ^ 1], one[val ^ 6]);
arr[2] += min(one[val ^ 0], one[val ^ 7]);
arr[1] += min(one[val ^ 4], one[val ^ 3]);
arr[0] += min(one[val ^ 5], one[val ^ 2]);
}
}
cout << min(arr[2], min(arr[0], min(arr[3], arr[1])));
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
int main() {
int k;
scanf("%d", &k);
int q = 0;
for (int i = 1; i < k; i++) {
for (int j = 1; j < k; j++) {
if ((q % 10) + i >= k)
q += 10 + i - k;
else
q += i;
printf("%d ", q);
}
printf("\n");
q = 0;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 9223372036854775807;
long long a[MAXN], b[MAXN], c[MAXN];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
}
for (int i = 1; i <= k; i++) {
scanf("%lld", &c[i]);
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
sort(c + 1, c + 1 + k);
long long ans = INF;
for (int i = 1; i <= n; i++) {
long long aa = a[i];
long long b0 = lower_bound(b + 1, b + 1 + m, a[i]) - b;
long long bb = b[b0];
long long c0 = lower_bound(c + 1, c + 1 + k, a[i]) - c;
long long cc = c[c0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
if (b0 - 1 >= 1 && c0 - 1 >= 1) {
bb = b[b0 - 1];
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0];
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
cc = c[c0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (b0 - 1 < 1 && c0 - 1 >= 1) {
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
cc = c[c0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (b0 - 1 >= 1 && c0 - 1 < 1) {
bb = b[b0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
}
for (int i = 1; i <= m; i++) {
long long bb = b[i];
long long a0 = lower_bound(a + 1, a + 1 + n, b[i]) - a;
long long aa = a[a0];
long long c0 = lower_bound(c + 1, c + 1 + k, b[i]) - c;
long long cc = c[c0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
if (a0 - 1 >= 1 && c0 - 1 >= 1) {
aa = a[a0 - 1];
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0];
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0 - 1];
cc = c[c0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (a0 - 1 < 1 && c0 - 1 >= 1) {
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
cc = c[c0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
cc = c[c0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (a0 - 1 >= 1 && c0 - 1 < 1) {
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
}
for (int i = 1; i <= k; i++) {
long long cc = c[i];
long long b0 = lower_bound(b + 1, b + 1 + m, c[i]) - b;
long long bb = b[b0];
long long a0 = lower_bound(a + 1, a + 1 + n, c[i]) - a;
long long aa = a[a0];
long long tmp =
(aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) + (aa - cc) * (aa - cc);
ans = min(ans, tmp);
if (a0 - 1 >= 1 && b0 - 1 >= 1) {
bb = b[b0 - 1];
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0];
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
aa = a[a0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (a0 - 1 < 1 && b0 - 1 >= 1) {
bb = b[b0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
bb = b[b0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
if (a0 - 1 >= 1 && b0 - 1 < 1) {
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0 - 1];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
aa = a[a0];
tmp = (aa - bb) * (aa - bb) + (cc - bb) * (cc - bb) +
(aa - cc) * (aa - cc);
ans = min(ans, tmp);
}
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) {
a[i] = 0;
}
for (int i = 1; i <= m; i++) {
b[i] = 0;
}
for (int i = 1; i <= k; i++) {
c[i] = 0;
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int Log = 60;
const int N = 210000;
const int mod = 1e9 + 7;
long long p2[Log + 5];
struct edge {
int to, nxt;
long long co;
} e[N * 2];
int h[N], E = 0;
int n, m;
long long lb[Log + 5], tot = 0, cnt[Log + 5], siz[Log + 5];
int used[N], f[N], g[N];
long long lan[N];
vector<int> now;
long long qpow(long long a, long long b) {
int res = 1;
for (; b > 0; b /= 2, a = a * a % mod)
if (b % 2) res = res * a % mod;
return res;
}
void addedge(int u, int v, long long w) {
E++;
e[E].to = v;
e[E].co = w;
e[E].nxt = h[u];
h[u] = E;
return;
}
void ins(long long x) {
for (int i = Log; i >= 0; i--) {
if (!(x & p2[i])) continue;
if (lb[i] == 0) {
lb[i] = x, tot++;
return;
} else
x ^= lb[i];
}
return;
}
void dfs(int u, int fa, long long co) {
now.push_back(u);
used[u] = 1;
lan[u] = lan[fa] ^ co;
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
long long w = e[i].co;
if (v == fa) continue;
if (used[v])
ins(lan[u] ^ lan[v] ^ w);
else
dfs(v, u, w);
}
return;
}
long long C(int n, int m) {
if (n < m) return 0;
return f[n] * g[m] % mod * g[n - m] % mod;
}
long long cal(int root) {
now.clear();
tot = 0;
for (int i = 0; i <= Log; i++) lb[i] = cnt[i] = siz[i] = 0;
dfs(root, 0, 0);
for (int i = 0; i <= Log; i++) {
for (int j = 0; j <= Log; j++) {
if (lb[i] & p2[j]) cnt[j]++;
}
}
int len = now.size();
for (int i = 0; i < len; i++) {
for (int j = 0; j <= Log; j++) {
if (lan[now[i]] & p2[j]) siz[j]++;
}
}
long long sum = 0;
for (int i = 0; i < len; i++) {
for (int j = 0; j <= Log; j++) {
int t0 = p2[j] & lan[now[i]] ? siz[j] : len - siz[j];
int t1 = len - t0;
t0--;
if (cnt[j] > 0) sum += p2[j] % mod * t0 % mod * qpow(2, tot - 1) % mod;
sum %= mod;
if (cnt[j] > 0)
sum += p2[j] % mod * t1 % mod * qpow(2, tot - 1) % mod;
else
sum += p2[j] % mod * t1 % mod * qpow(2, tot) % mod;
sum %= mod;
}
}
return sum;
}
int main() {
p2[0] = 1;
for (int i = 1; i <= Log; i++) p2[i] = p2[i - 1] * 2;
scanf("%d%d", &n, &m);
f[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
for (int i = 0; i <= n; i++) g[i] = qpow(f[i], mod - 2);
int u, v;
long long w;
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
ans += cal(i);
ans %= mod;
}
printf("%lld\n", ans * qpow(2, mod - 2) % mod);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long maxn = 200010;
long long n, k;
long long fac[maxn];
long long ifac[maxn];
long long ksm(long long a, long long b) {
long long ret = 1;
while (b != 0) {
if (b % 2 == 1) ret = (ret * a) % mod;
b /= 2;
a = (a * a) % mod;
}
return ret;
}
void init() {
fac[0] = ifac[0] = 1;
for (long long i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % mod;
ifac[i] = ksm(fac[i], mod - 2);
}
}
long long ccc(long long a, long long b) {
if (a < b) return 0;
return fac[a] * ifac[b] % mod * ifac[a - b] % mod;
}
int main() {
scanf("%lld%lld", &n, &k);
long long i, ans = 0;
if (k >= n)
ans = 0;
else {
init();
k = n - k;
for (i = 0; i <= k; i++)
ans = (ans + (i % 2 ? -1 : 1) * ccc(k, i) * ksm(k - i, n) % mod + mod) %
mod;
if (k < n) ans = 2 * ans * ccc(n, k) % mod;
}
printf("%lld", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
#pragma GCC optimize "-O3"
bool ask(int x1, int y1, int x2, int y2) {
x1++;
y1++;
x2++;
y2++;
cout << "? " << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
fflush(stdout);
int ans;
cin >> ans;
return ans;
}
bool check(vector<vector<int> > a) {
if (a[0][0] != a[2][1]) return false;
if (a[1][0] == a[2][0]) return true;
if (a[1][0] == a[1][1]) return true;
if (a[0][1] == a[1][1]) return true;
return false;
}
int solve1(vector<vector<int> > a) {
vector<vector<int> > temp = a;
bool ispal1 = false;
bool ispal2 = false;
for (int i = 0; i < (temp.size()); i++) {
for (int j = 0; j < (temp[i].size()); j++) {
if (a[i][j] == 2) temp[i][j] = 1;
if (a[i][j] == 3) temp[i][j] = 0;
}
}
ispal1 = check(temp);
temp = a;
for (int i = 0; i < (temp.size()); i++) {
for (int j = 0; j < (temp[i].size()); j++) {
if (a[i][j] == 2) temp[i][j] = 0;
if (a[i][j] == 3) temp[i][j] = 1;
}
}
ispal2 = check(temp);
if (ispal1 == ispal2) return -1;
return (ispal1);
}
void answer(vector<vector<int> > a, int two) {
cout << "!\n";
for (int i = 0; i < (a.size()); i++) {
for (int j = 0; j < (a[i].size()); j++) {
if (a[i][j] == 2)
a[i][j] = two;
else if (a[i][j] == 3)
a[i][j] = 1 - two;
cout << a[i][j];
}
cout << "\n";
}
fflush(stdout);
exit(0);
}
vector<vector<int> > a;
void relax(int x1, int y1, int x2, int y2) {
int fx = x1;
int fy = y1;
int sx = x2;
int sy = y2;
int mx;
if (a[x1][y1] >= 2)
mx = 5;
else
mx = 1;
if (x1 > x2 || y1 > y2) {
swap(x1, x2);
swap(y1, y2);
}
if (ask(x1, y1, x2, y2))
a[sx][sy] = a[fx][fy];
else
a[sx][sy] = mx - a[fx][fy];
}
int main() {
int n;
cin >> n;
a.resize(n);
for (int i = 0; i < (n); i++) a[i].resize(n);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) a[i][j] = 9;
bool keks;
a[0][0] = 1;
a[n - 1][n - 1] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i + j == 0) continue;
if (i + j == 2 * n - 2) continue;
if ((i + j) % 2 == 1) continue;
if (i > 1) {
relax(i - 2, j, i, j);
} else if (j > 1) {
relax(i, j - 2, i, j);
} else {
relax(i - 1, j - 1, i, j);
}
}
}
a[0][1] = 2;
for (int j = 3; j < n; j += 2) {
relax(0, j - 2, 0, j);
}
for (int j = 1; j < n; j += 2) {
relax(0, j, 1, j + 1);
}
for (int i = 2; i < n; i++) {
for (int j = 1; j < n; j++) {
if (a[i - 2][j] >= 2) {
relax(i - 2, j, i, j);
}
}
}
for (int i = 1; i < n; i += 2) {
relax(i + 1, 1, i, 0);
}
vector<vector<int> > ar;
ar.resize(3);
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < n - 1; j++) {
for (int k = 0; k < (3); k++) {
ar[k] = {a[i + k][j], a[i + k][j + 1]};
}
int ans = solve1(ar);
if (ans == -1) continue;
if (ask(i, j, i + 2, j + 1))
ans = ans;
else
ans = 1 - ans;
answer(a, ans);
}
}
}
| 16
|
#include <bits/stdc++.h>
const int MAXN = (int)(1e8);
const int inf = (int)(1e9);
using namespace std;
int main() {
long long n, h, k, s = 0, t = 0, temp = 0;
cin >> n >> h >> k;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (s + x > h) {
temp = (s - (h - x)) / k;
if ((s - (h - x)) % k != 0) temp++;
s -= temp * k;
if (s < 0) s = 0;
t += temp;
}
s += x;
}
if (s > 0) {
t += s / k;
if (s % k != 0) t++;
}
cout << t;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, min = 0, max = 0, c = 0;
cin >> n >> m;
int ar[m], arr[m];
for (int i = 0; i < m; i++) {
cin >> ar[i];
arr[i] = ar[i];
}
while (c < n) {
sort(ar, ar + m);
i = 0;
while (ar[i] == 0 && i < m) i++;
min += ar[i];
ar[i] -= 1;
c += 1;
}
c = 0;
while (c < n) {
sort(arr, arr + m, greater<int>());
max += arr[0];
arr[0] -= 1;
c += 1;
}
cout << max << " " << min;
return 0;
}
| 3
|
#include <bits/stdc++.h>
int main() {
int n;
int m;
int arr[100];
int x;
int y;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
if ((x - 1) >= 1) {
arr[x - 2] = arr[x - 2] + (y - 1);
}
if ((x + 1) <= n) {
arr[x] = arr[x] + (arr[x - 1] - y);
}
arr[x - 1] = 0;
}
for (i = 0; i < n; i++) {
printf("%d\n", arr[i]);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long pr(long long a, long long b, char c) {
if (c == '+') return a + b;
return a * b;
}
int main() {
vector<int> num(4);
vector<char> sym(3);
vector<bool> check(4, 0);
long long result = 1000000000000;
for (int i = 0; i < 4; i++) cin >> num[i];
for (int i = 0; i < 3; i++) cin >> sym[i];
for (int i = 0; i < 4; i++) {
check[i] = 1;
for (int j = i + 1; j < 4; j++) {
check[j] = 1;
long long temp = pr(num[i], num[j], sym[0]);
long long a[2];
int index = 0;
for (int el = 0; el < 4; el++) {
if (check[el] == 0) {
a[index] = num[el];
index++;
}
}
long long pod = pr(temp, a[0], sym[1]);
pod = pr(pod, a[1], sym[2]);
result = min(pod, result);
pod = pr(a[0], a[1], sym[1]);
pod = pr(pod, temp, sym[2]);
result = min(pod, result);
pod = pr(temp, a[1], sym[1]);
pod = pr(pod, a[0], sym[2]);
result = min(pod, result);
check[j] = 0;
}
check[i] = 0;
}
cout << result << "\n";
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 500005, inf = 1111111111;
int n, m, u[max_n], v[max_n], f[max_n];
vector<int> g[max_n], ans;
void add_edges() {
vector<int> q;
for (int i = 1; i <= n; ++i) {
if (g[i].size() % 2 == 1) {
q.push_back(i);
}
}
if (q.size() % 2 == 1) {
exit(228);
}
for (int i = 0; i + 1 < q.size(); i += 2) {
u[m] = q[i];
v[m] = q[i + 1];
g[u[m]].push_back(m);
g[v[m]].push_back(m);
++m;
}
if (m % 2 == 1) {
u[m] = 1;
v[m] = 1;
g[1].push_back(m);
++m;
}
}
void find_path(int vv) {
stack<int> st;
st.push(vv);
while (!st.empty()) {
vv = st.top();
int ff = 0;
while (g[vv].size()) {
int to = g[vv].back();
g[vv].pop_back();
if (f[to] == 0) {
f[to] = 1;
ff = 1;
if (vv == v[to]) {
swap(u[to], v[to]);
}
st.push(v[to]);
break;
}
}
if (ff == 0) {
ans.push_back(vv);
st.pop();
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u[i], &v[i]);
g[u[i]].push_back(i);
g[v[i]].push_back(i);
}
add_edges();
find_path(1);
printf("%d\n", ans.size() - 1);
for (int i = 0; i + 1 < ans.size(); ++i) {
if (i % 2 == 0) {
printf("%d %d\n", ans[i], ans[i + 1]);
} else {
printf("%d %d\n", ans[i + 1], ans[i]);
}
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, b1, b2, mul, X, Y, a[15], b[15], i;
while (scanf("%I64d %I64d", &n, &b1) == 2) {
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
scanf("%I64d %I64d", &m, &b2);
for (i = 0; i < m; i++) {
scanf("%I64d", &b[i]);
}
mul = 1;
X = 0;
i = n - 1;
for (i = n - 1; i >= 0; i--) {
X += a[i] * mul;
mul *= b1;
}
mul = 1;
Y = 0;
for (i = m - 1; i >= 0; i--) {
Y += b[i] * mul;
mul *= b2;
}
if (X > Y) {
printf(">\n");
} else if (X == Y) {
printf("=\n");
} else {
printf("<\n");
}
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long int power(long long int a, long long int b) {
long long int ret = 1;
while (b) {
if (b % 2) ret *= a;
a *= a;
b /= 2;
}
return ret;
}
int main() {
FastIO();
long long int a, b, ans = 0;
cin >> a >> b;
for (long long int i = 1; i <= 62; i++) {
long long int p = power(2, i) - 1;
for (long long int j = 0; j <= i - 2; j++) {
long long int q = power(2, j);
if (a <= p - q && p - q <= b) ans++;
}
}
cout << ans << '\n';
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
char ch;
cin >> ch;
string s;
string s2[100];
getline(cin, s);
int i;
for (i = 0; i < t; i++) {
getline(cin, s2[i]);
}
if (t % 2 == 0) {
cout << "home" << endl;
} else {
cout << "contest" << endl;
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2, x = (x * x) % 1000000007;
}
return res % 1000000007;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long arr[n][m];
long long i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> arr[i][j];
long long zero[n];
long long one[n];
for (k = 0; k < 10; k++) {
for (i = 0; i < n; i++) zero[i] = -1, one[i] = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if ((arr[i][j] & (1 << k))) {
one[i] = j;
} else
zero[i] = j;
}
}
long long cnt1 = 0;
for (i = 0; i < n; i++) {
if (one[i] != -1) cnt1++;
}
if (cnt1 % 2) {
cout << "TAK\n";
for (i = 0; i < n; i++) {
if (one[i] != -1)
cout << one[i] + 1;
else
cout << zero[i] + 1;
cout << " ";
}
return 0;
} else {
bool poss = false;
for (i = 0; i < n; i++) {
if (one[i] != -1 and zero[i] != -1) {
one[i] = zero[i];
poss = true;
break;
}
}
if (poss) {
cout << "TAK\n";
for (i = 0; i < n; i++) {
if (one[i] != -1)
cout << one[i] + 1;
else
cout << zero[i] + 1;
cout << " ";
}
return 0;
}
}
}
cout << "NIE";
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char a[22][100002];
int f[21][(1 << 20) + 1];
int main() {
scanf("%d%d", &n, &m);
ans = 1e9;
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) tmp = tmp * 2 + a[j][i] - '0';
f[0][tmp]++;
}
for (int i = 0; i <= n - 1; i++)
for (int j = n; j; j--)
for (int k = 0; k <= (1 << n) - 1; k++) f[j][k] += f[j - 1][k ^ (1 << i)];
for (int k = 0; k <= (1 << n) - 1; k++) {
int tmp = 0;
for (int i = 0; i <= n; i++) tmp += min(i, n - i) * f[i][k];
ans = min(ans, tmp);
}
printf("%d", ans);
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
struct info {
ll ls, rs, sum, len;
ll sl, sr;
info operator+(const info &t) {
ll nls = (ls == len && sr <= t.sl) ? (ls + t.ls) : ls;
ll nrs = (t.rs == t.len && sr <= t.sl) ? (t.rs + rs) : t.rs;
ll nlen = len + t.len;
ll nsum = sum + t.sum;
if (sr <= t.sl) nsum += rs * t.ls;
return info{nls, nrs, nsum, nlen, sl, t.sr};
}
};
struct Segment {
vector<info> sum;
Segment(int n) : sum(n << 2) {}
void pushup(int pos) { sum[pos] = sum[pos << 1] + sum[pos << 1 | 1]; }
info query(int ql, int qr, int pos, int l, int r) {
if (ql <= l && r <= qr) {
return sum[pos];
}
int mid = (l + r) >> 1;
if (qr <= mid) {
return query(ql, qr, pos << 1, l, mid);
} else if (ql > mid) {
return query(ql, qr, pos << 1 | 1, mid + 1, r);
} else {
return query(ql, qr, pos << 1, l, mid) +
query(ql, qr, pos << 1 | 1, mid + 1, r);
}
}
void update(int v, int w, int pos, int l, int r) {
if (l == r) {
sum[pos].sl = sum[pos].sr = w;
return;
}
int mid = (l + r) >> 1;
if (v <= mid)
update(v, w, pos << 1, l, mid);
else
update(v, w, pos << 1 | 1, mid + 1, r);
pushup(pos);
}
void build(int pos, int l, int r, vector<int> &a) {
if (l == r) {
sum[pos] = info{1, 1, 1, 1, a[l], a[l]};
return;
}
int mid = (l + r) >> 1;
build(pos << 1, l, mid, a);
build(pos << 1 | 1, mid + 1, r, a);
pushup(pos);
}
};
void solve() {
int n, q;
cin >> n >> q;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
Segment t(n);
t.build(1, 1, n, a);
while (q--) {
int op, x, y;
cin >> op >> x >> y;
if (op == 1) {
t.update(x, y, 1, 1, n);
} else {
cout << t.query(x, y, 1, 1, n).sum << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int N;
vector<int> edge[MAXN];
int par[MAXN];
int dep[MAXN];
void flood(int cloc, int cdep, int last) {
par[cloc] = last;
dep[cloc] = cdep;
for (int neigh : edge[cloc]) {
if (neigh == last) continue;
flood(neigh, cdep + 1, cloc);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
edge[x].push_back(y);
edge[y].push_back(x);
}
flood(0, 0, -1);
int n0 = 0;
for (int i = 0; i < N; i++)
if (dep[i] % 2 == 0) n0++;
n0 = min(n0, N - n0);
cout << n0 - 1 << "\n";
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
long long mn = 1e9, mx = -1e9, ans, cnt, sm;
bool ok, okk, used[1000010], use[10010];
string s[13] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "B", "H"};
int getpos(string a) {
for (int i = 0; i < 12; i++) {
if (s[i] == a) {
return i;
}
}
}
int dis(string x, string y) {
int dx = getpos(x);
int dy = getpos(y);
if (dy >= dx) {
return dy - dx;
} else {
return 12 + dy - dx;
}
}
bool maj(string x, string y, string z) {
return ((dis(x, y) == 4) && (dis(y, z) == 3));
}
bool mnr(string x, string y, string z) {
return ((dis(x, y) == 3) && (dis(y, z) == 4));
}
int main() {
string s[10];
for (int i = 0; i < 3; i++) {
cin >> s[i];
}
sort(s, s + 3);
do {
if (maj(s[0], s[1], s[2])) {
cout << "major";
return 0;
} else if (mnr(s[0], s[1], s[2])) {
cout << "minor";
return 0;
}
} while (next_permutation(s, s + 3));
cout << "strange";
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
int c[30], r[30];
for (int i = 0; i < 30; i++) {
c[i] = 0;
r[i] = 0;
}
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> x;
c[j] += x;
r[i] += x;
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (c[j] > r[i]) ans++;
}
cout << ans;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, m, a[N], b[N];
struct item {
int val, le, ri;
};
item t[4 * N];
inline item mrg(item a, item b) {
if (a.le == -1) {
return b;
}
if (b.le == -1) {
return a;
}
item c;
c.val = a.val + b.val - (a.ri < b.le);
c.le = a.le;
c.ri = b.ri;
return c;
}
void build(int v, int l, int r) {
if (l == r) {
t[v].val = 1;
t[v].le = t[v].ri = b[l];
return;
}
int mid = (r + l) >> 1;
build(v + v, l, mid);
build(v + v + 1, mid + 1, r);
t[v] = mrg(t[v + v], t[v + v + 1]);
}
void update(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v].le = t[v].ri = val;
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
update(v + v, l, mid, pos, val);
} else {
update(v + v + 1, mid + 1, r, pos, val);
}
t[v] = mrg(t[v + v], t[v + v + 1]);
}
item bad = {-1, -1, -1};
item get(int v, int l, int r, int tl, int tr) {
if (l > r || l > tr || tl > r) {
return bad;
}
if (tl <= l && r <= tr) {
return t[v];
}
int mid = (r + l) >> 1;
return mrg(get(v + v, l, mid, tl, tr), get(v + v + 1, mid + 1, r, tl, tr));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]] = i;
}
build(1, 1, n);
cin >> m;
for (int i = 1; i <= m; i++) {
int type, l, r;
cin >> type >> l >> r;
if (type == 1) {
cout << get(1, 1, n, l, r).val << "\n";
} else {
update(1, 1, n, a[l], r);
update(1, 1, n, a[r], l);
swap(a[l], a[r]);
}
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
char G[205][205];
struct LOOP {
int mask;
} LP[205 * 205];
int shu[205][205], flag[205][205];
int dp[205][205], data[10][2], n, m, nct, nn;
bool judge(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return false;
return true;
}
char s[1000005];
int mk[1 << 11], ans;
int dfs(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
if (shu[x][y]) {
if (mk[LP[shu[x][y]].mask] == 0) ans = 1;
return dp[x][y] = mk[LP[shu[x][y]].mask];
}
int ha = G[x][y] - '0';
int xx = x + data[ha][0], yy = y + data[ha][1];
int d = dfs(xx, yy);
dp[x][y] = d;
if (d == 0) return d;
if (s[d - 1] - '0' == ha) dp[x][y] = dp[xx][yy] - 1;
if (dp[x][y] == 0) ans = 1;
return dp[x][y];
}
int main() {
int q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%s", G[i] + 1);
for (int i = 0; i < 10; i++) scanf("%d%d", &data[i][0], &data[i][1]);
nct = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int ha = G[i][j] - '0';
if (judge(i + data[ha][0], j + data[ha][1]) == 0) {
shu[i][j] = nct;
LP[nct++].mask = 1 << ha;
flag[i][j] = 1;
}
}
nn = 2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (flag[i][j] == 0) {
flag[i][j] = nn;
int x = i, y = j, tmp = 0;
while (1) {
int ha = G[x][y] - '0';
x += data[ha][0];
y += data[ha][1];
if (flag[x][y]) {
if (flag[x][y] == nn) tmp = 1;
break;
}
flag[x][y] = nn;
}
if (tmp) {
shu[i][j] = nct;
int ha = G[i][j] - '0';
x = i + data[ha][0];
y = j + data[ha][1];
LP[nct].mask = 1 << ha;
while (x != i || y != j) {
ha = G[x][y] - '0';
shu[x][y] = nct;
LP[nct].mask |= 1 << ha;
x += data[ha][0];
y += data[ha][1];
}
nct++;
}
nn++;
}
while (q--) {
memset(dp, -1, sizeof(dp));
scanf("%s", s);
int len = strlen(s);
int ho = 0;
for (int i = 0; i < (1 << 10); i++) mk[i] = len;
for (int i = len - 1; i >= 0; i--) {
ho |= 1 << (s[i] - '0');
mk[ho] = min(mk[ho], i);
}
for (int i = 1; i < (1 << 10); i++)
for (int j = i & (i - 1); j; j = i & (j - 1)) mk[i] = min(mk[i], mk[j]);
ans = 0;
for (int i = 1; i <= n && ans == 0; i++)
for (int j = 1; j <= m && ans == 0; j++)
if (dp[i][j] == -1) {
dfs(i, j);
}
if (ans)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void chmin(T &t, U f) {
if (t > f) t = f;
}
template <class T, class U>
void chmax(T &t, U f) {
if (t < f) t = f;
}
signed main() {
long long a, b, c;
scanf("%lld:%lld%lld", &a, &b, &c);
long long t = a * 60 + b + c;
t %= 24 * 60;
printf("%02lld:%02lld\n", t / 60, t % 60);
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int pow[n];
for (long long int i = 1; i <= n; i++) cin >> pow[i];
long long int MAX = pow[1], num = 0;
for (long long int i = 2; i <= n && num < k; i++) {
if (pow[i] < MAX)
num++;
else {
MAX = pow[i];
num = 1;
}
}
cout << MAX << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string zero = ".";
string one = "-.";
string two = "--";
string code;
cin >> code;
string ans;
for (int i = 0; i < code.length(); i++) {
if (code[i] == '.') {
ans += "0";
continue;
}
if (code[i] == '-') {
if (i + 1 < code.length()) {
if (code[i + 1] == '.') {
ans += "1";
i++;
continue;
}
if (code[i + 1] == '-') {
ans += "2";
i++;
continue;
}
}
}
}
cout << ans;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
int32_t main() {
long long n, m;
cin >> n >> m;
vector<long long> arr(n), brr(m);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long i = 0; i < m; i++) {
cin >> brr[i];
}
for (long long i = 0; i <= 1200; i++) {
bool poss = true;
vector<long long> c;
for (auto a : arr) {
bool yes = false;
for (auto b : brr) {
if (((a & b) | i) == i) {
yes = true;
c.push_back(a & b);
break;
}
}
if (!yes) {
poss = false;
break;
}
}
if (poss) {
long long val = c[0];
for (auto x : c) {
val = (val | x);
}
if (val == i) {
cout << i << endl;
exit(0);
}
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, k, ans;
string s;
vector<pair<string, string>> teams;
map<string, int> a;
map<string, int> b;
int isB[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
string s, t;
cin >> s >> t;
s = s.substr(0, 3);
t = s.substr(0, 2) + t.substr(0, 1);
teams.push_back({s, t});
a[s]++;
}
bool isOk = false;
while (!isOk) {
isOk = 1;
for (int i = 0; i < n; i++) {
if (!isB[i] && a[teams[i].first] > 1) {
isOk = 0;
isB[i] = 1;
b[teams[i].second]++;
} else if (!isB[i] && b[teams[i].first]) {
isOk = 0;
isB[i] = 1;
b[teams[i].second]++;
} else if (isB[i] && b[teams[i].second] > 1) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
if (isB[i]) {
cout << teams[i].second << endl;
} else {
cout << teams[i].first << endl;
}
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-6;
const int infi = (int)1e9;
const long long infl = (long long)1e16;
const int MOD = (int)1e9 + 7;
const int MAX = (int)5e5 + 10;
const int dx[] = {1, -1, 0, 0, 1, 1, -1, -1, 0};
const int dy[] = {0, 0, -1, 1, 1, -1, 1, -1, 0};
long long dot(long long x, long long y, long long xx, long long yy) {
return x * yy + xx * y;
}
int main() {
long long a, b;
cin >> a >> b;
string s;
cin >> s;
long long x = 0, y = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (x == a && y == b) {
cout << "Yes\n";
return 0;
}
if (s[i] == 'U') y++;
if (s[i] == 'D') y--;
if (s[i] == 'R') x++;
if (s[i] == 'L') x--;
if (x == a && y == b) {
cout << "Yes\n";
return 0;
}
}
long long tx = x, ty = y;
long long xx = 0, yy = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == 'U') yy++;
if (s[i] == 'D') yy--;
if (s[i] == 'R') xx++;
if (s[i] == 'L') xx--;
if (tx == 0 && ty != 0) {
if ((b - yy) % ty == 0) {
long long k = (b - yy) / ty;
if (k >= 0 && xx + k * tx == a) {
cout << "Yes\n";
return 0;
}
}
} else if (tx != 0 && ty == 0) {
if ((a - xx) % tx == 0) {
long long k = (a - xx) / tx;
if (k >= 0 && yy + k * ty == b) {
cout << "Yes\n";
return 0;
}
}
} else if (ty == 0 && tx == 0) {
if (a == xx && b == yy) {
cout << "Yes\n";
return 0;
}
} else {
if ((a - xx) % tx == 0) {
long long k = (a - xx) / tx;
if (k >= 0 && yy + k * ty == b) {
cout << "Yes\n";
return 0;
}
}
}
}
cout << "No\n";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adjList[200005];
long long x[200005], n, dp[200005][2];
long long FastMod(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b = b >> 1;
}
return res;
}
void dfs(long long node, long long par) {
long long val = 1;
for (auto neighbour : adjList[node]) {
if (neighbour != par) {
dfs(neighbour, node);
val = (val * (dp[neighbour][0] + dp[neighbour][1])) % 1000000007;
}
}
if (x[node] == 1) {
dp[node][0] = 0;
dp[node][1] = val;
} else {
dp[node][0] = val;
long long temp = 1;
for (auto neighbour : adjList[node]) {
if (neighbour != par) {
long long temp = (dp[neighbour][0] + dp[neighbour][1]) % 1000000007;
temp = FastMod(temp, 1000000007 - 2);
temp = (temp * dp[node][0]) % 1000000007;
temp = (temp * dp[neighbour][1]) % 1000000007;
dp[node][1] = (dp[node][1] + temp) % 1000000007;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long x;
cin >> x;
adjList[i + 1].push_back(x);
adjList[x].push_back(i + 1);
}
for (long long i = 0; i < n; i++) cin >> x[i];
dfs(0, -1);
cout << dp[0][1] << "\n";
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
double pow(double a, int b) {
double r = 1;
double base = a;
while (b != 0) {
if (b & 1) r *= base;
base *= base;
b >>= 1;
}
return r;
}
int main() {
int n, m;
while (scanf("%d %d", &m, &n) != EOF) {
double ans = 0;
for (int i = 1; i <= m; i++)
ans += (pow((1.0 * i) / m, n) - pow(1.0 * (i - 1) / m, n)) * i;
printf("%lf\n", ans);
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
struct p {
int st, en, d;
};
bool cmp(p a, p b) { return a.d < b.d; }
bool cmp1(p a, p b) { return a.st < b.st; }
p b[500005];
long long dp[5005], dp1[5005], dp2[5005];
int a[500005];
int main() {
for (int i = 0; i < 5005; i++)
dp[i] = 100000000000000LL, dp1[i] = 100000000000000LL;
int k, n;
cin >> k >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
b[i - 1].st = a[i - 1], b[i - 1].en = a[i], b[i - 1].d = a[i] - a[i - 1];
}
sort(b, b + n - 1, cmp);
sort(b, b + min(3 * k, n - 1), cmp1);
dp1[1] = b[0].d;
dp1[0] = 0, dp[0] = 0;
if (n == 2) {
cout << dp1[1] << endl;
return 0;
}
for (int i = 1; i < min(n - 1, 3 * k); i++) {
for (int cnt = 0; cnt <= k; cnt++) {
if (cnt == 0)
dp2[cnt] = 0;
else if (b[i].st == b[i - 1].en) {
dp2[cnt] = min(dp1[cnt], dp[cnt - 1] + b[i].d);
if (dp2[cnt] > 100000000000000LL) dp2[cnt] = 100000000000000LL;
} else {
dp2[cnt] = min(dp1[cnt], dp1[cnt - 1] + b[i].d);
if (dp2[cnt] > 100000000000000LL) dp2[cnt] = 100000000000000LL;
}
}
for (int cnt = 0; cnt <= k; cnt++) {
dp[cnt] = dp1[cnt];
dp1[cnt] = dp2[cnt];
}
}
cout << dp2[k] << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
map<long long, int> dec(long long x) {
map<long long, int> mp;
for (long long d = 2; d * d <= x; d++)
while (x % d == 0) {
x /= d;
mp[d]++;
}
if (x > 1) mp[x]++;
return mp;
}
void fmain(int tid) {
long long p, q;
scanf("%lld%lld", &p, &q);
if (p % q) {
printf("%lld\n", p);
return;
}
map<long long, int> mp = dec(q);
long long ans = 1;
for (auto pr : mp) {
long long P = pr.first;
int cc = pr.second;
for (int(i) = 1; (i) <= (int)(cc - 1); (i)++) P *= pr.first;
long long tmp = 1, X = p;
while (X % P == 0) {
X /= pr.first;
tmp *= pr.first;
}
maxtt(ans, p / tmp);
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
scanf("%d", &t);
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int i, j, k;
int m, n;
int a, b;
int num;
while (scanf("%d%d", &n, &m) != EOF) {
a = 0;
b = 1000;
while (n--) {
scanf("%d%d", &j, &k);
if (j > k) {
i = k;
k = j;
j = i;
}
if (j > a) a = j;
if (k < b) b = k;
}
if (a > b)
printf("%d\n", -1);
else if (a <= m && m <= b)
printf("%d\n", 0);
else if (a > m)
printf("%d\n", a - m);
else
printf("%d\n", m - b);
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int R, C, K, Tail;
int Board[60][60], Road[60][60], Best[60][60], Oki[60][60];
int Allow[100000][5];
int Last[60][60];
char Now[5];
int Res;
int Check[30];
char Ans[10000];
int QR[10000], QC[10000];
void pre_process(char now, int left) {
if (now > 'z') {
if (left == 0) {
int i;
for (i = 0; i < (int)(K); i++) Allow[Tail][i] = (int)(Now[i] - 'a');
Tail++;
}
return;
}
pre_process(now + 1, left);
if (left > 0) {
Now[left - 1] = now;
pre_process(now + 1, left - 1);
}
}
bool isValid(int r, int c) {
return 0 <= r && r < R && 0 <= c && c < C && Road[r][c];
}
int main() {
int i, j, k, r, c;
int sr, sc, er, ec;
char a;
int dr[4] = {-1, 0, 1, 0};
int dc[4] = {0, 1, 0, -1};
int tt, et;
scanf("%d%d%d", &R, &C, &K);
for (i = 0; i < (int)(R); i++) {
for (j = 0; j < (int)(C); j++) {
scanf("%c", &a);
if (!('a' <= a && a <= 'z') && a != 'S' && a != 'T') {
j--;
continue;
}
if ('a' <= a && a <= 'z')
Board[i][j] = a - 'a';
else if (a == 'S')
Board[i][j] = -1, sr = i, sc = j;
else
Board[i][j] = -2, er = i, ec = j;
}
}
Tail = 0;
pre_process('a', K);
Res = -1;
for (i = 0; i < (int)(Tail); i++) {
for (j = 0; j < (int)(26); j++) Check[j] = 0;
for (j = 0; j < (int)(K); j++) Check[Allow[i][j]] = 1;
for (r = 0; r < (int)(R); r++)
for (c = 0; c < (int)(C); c++) {
if (Board[r][c] >= 0)
Road[r][c] = Check[Board[r][c]];
else
Road[r][c] = 1;
Best[r][c] = -1;
Oki[r][c] = 0;
Last[r][c] = 0;
}
tt = 1;
QR[0] = sr, QC[0] = sc;
Best[sr][sc] = 0;
for (j = 0; j < (int)(tt); j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Best[r + dr[k]][c + dc[k]] == -1) {
Best[r + dr[k]][c + dc[k]] = Best[r][c] + 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
if (Best[er][ec] == -1 || (Res != -1 && Best[er][ec] > Res)) continue;
bool update = false;
if (Res == -1 || Best[er][ec] < Res) update = true;
Res = Best[er][ec];
Ans[Res - 1] = Ans[Res] = 0;
tt = 1;
QR[0] = er, QC[0] = ec;
Oki[er][ec] = 1;
for (j = 0; j < (int)(tt); j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) &&
Best[r + dr[k]][c + dc[k]] == Best[r][c] - 1 &&
!Oki[r + dr[k]][c + dc[k]]) {
Oki[r + dr[k]][c + dc[k]] = 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
int cur = 0, tt = 1, move = 0;
QR[0] = sr, QC[0] = sc;
Best[sr][sc] = 0;
while (cur < Res - 1) {
et = tt;
int best = -1;
for (j = move; j < et; j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Oki[r + dr[k]][c + dc[k]] &&
Best[r + dr[k]][c + dc[k]] == cur + 1) {
if (best == -1 || best > Board[r + dr[k]][c + dc[k]]) {
best = Board[r + dr[k]][c + dc[k]];
}
}
}
if (!update && (char)(best + 'a') > Ans[cur]) break;
if (!update && (char)(best + 'a') < Ans[cur]) update = true;
Ans[cur] = (char)(best + 'a');
cur++;
for (j = move; j < et; j++) {
r = QR[j], c = QC[j];
for (k = 0; k < (int)(4); k++)
if (isValid(r + dr[k], c + dc[k]) && Oki[r + dr[k]][c + dc[k]] &&
Best[r + dr[k]][c + dc[k]] == cur &&
!Last[r + dr[k]][c + dc[k]]) {
if (best == Board[r + dr[k]][c + dc[k]]) {
Last[r + dr[k]][c + dc[k]] = 1;
QR[tt] = r + dr[k], QC[tt] = c + dc[k];
tt++;
}
}
}
move = et;
}
}
if (Res == -1)
printf("%d\n", Res);
else
printf("%s\n", Ans);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
char W[510][510];
int p[250010];
int sz[250010];
int n, k;
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
void join(int x, int y) {
int xroot = find(x), yroot = find(y);
if (xroot != yroot) {
sz[yroot] += sz[xroot];
p[xroot] = yroot;
}
}
bool v[510][510];
int iter;
int movx[] = {1, -1, 0, 0};
int movy[] = {0, 0, 1, -1};
void dfs(int x, int y) {
v[x][y] = true;
for (int i = 0; i < 4; i++) {
int nx = x + movx[i], ny = y + movy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
if (v[nx][ny]) continue;
if (W[nx][ny] != W[x][y]) continue;
join(x * n + y, nx * n + ny);
dfs(nx, ny);
}
}
int M[250010];
int neigh(int x, int y) {
int sum = 0;
for (int i = 0; i < k; i++) {
if (x - 1 < 0) break;
if (W[x - 1][y + i] == 'X') continue;
int C = find((x - 1) * n + y + i);
if (M[C] == iter) continue;
M[C] = iter;
sum += sz[C];
}
for (int i = 0; i < k; i++) {
if (x + k >= n) break;
if (W[x + k][y + i] == 'X') continue;
int C = find((x + k) * n + y + i);
if (M[C] == iter) continue;
M[C] = iter;
sum += sz[C];
}
for (int i = 0; i < k; i++) {
if (y - 1 < 0) break;
if (W[x + i][y - 1] == 'X') continue;
int C = find((x + i) * n + y - 1);
if (M[C] == iter) continue;
M[C] = iter;
sum += sz[C];
}
for (int i = 0; i < k; i++) {
if (y + k >= n) break;
if (W[x + i][y + k] == 'X') continue;
int C = find((x + i) * n + y + k);
if (M[C] == iter) continue;
M[C] = iter;
sum += sz[C];
}
return sum;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n * n; i++) {
p[i] = i;
sz[i] = 1;
}
for (int i = 0; i < n; i++) scanf("%s", W[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!v[i][j] && W[i][j] != 'X') {
dfs(i, j);
}
}
}
int best = 0;
iter = 1;
for (int i = 0; i + k <= n; i++) {
int li = 0;
for (int j = 0; j < n; j++) {
for (int r = 0; r < k; r++) {
if (W[i + r][j] == 'X') continue;
int C = find((i + r) * n + j);
sz[C]--;
}
if (j >= k) {
for (int r = 0; r < k; r++) {
if (W[i + r][li] == 'X') continue;
int C = find((i + r) * n + li);
sz[C]++;
}
li++;
}
if (j >= k - 1) {
int cursum = k * k + neigh(i, li);
iter++;
best = max(best, cursum);
}
}
while (li < n) {
for (int r = 0; r < k; r++) {
if (W[i + r][li] == 'X') continue;
int C = find((i + r) * n + li);
sz[C]++;
}
li++;
}
}
printf("%d\n", best);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5, mod = 1e9 + 7, bit = 60;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, t, curr;
cin >> n >> t;
while (t--) {
cin >> curr;
string s;
cin >> s;
for (auto x : s) {
long long int temp = curr;
long long int mxpower = 1;
while (temp % 2 == 0) {
temp >>= 1;
mxpower <<= 1;
}
if (x == 'U') {
if (n + 1 == curr << 1) {
continue;
}
if (temp % 4 == 1) {
curr += mxpower;
} else {
curr -= mxpower;
}
} else if (x == 'L') {
curr -= (mxpower >> 1);
} else {
curr += (mxpower >> 1);
}
}
cout << curr << '\n';
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
inline int ri() {
int x = 0;
bool f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 0;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return f ? x : -x;
}
int v[N];
int n, cur, cnt;
int ans;
void opr(int p) {
v[p] = 1;
cnt++;
while (cur < n && v[n - cur]) ++cur;
}
int main() {
n = ri();
printf("%d", 1);
for (int i = (1); i <= (n); ++i) {
int p = ri();
opr(p);
printf(" %d", cnt - cur + 1);
}
puts("");
return 0;
}
| 7
|
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
const int N = 2e6 + 5;
const double eps = 1e-9;
long long mod = 1e9 + 7;
long long n, a, b, c, d, st, len;
struct node {
long long tim, tp;
} p[N];
long long calc1(long long x) {
if (x == -1) return 0;
return x ? a : -b;
}
long long calc2(long long x) { return x ? c : -d; }
long long tail = 0;
long long mi = inf;
long long res = 0;
long long sum = 0;
int main() {
scanf("%d", &n), scanf("%d", &a), scanf("%d", &b), scanf("%d", &c),
scanf("%d", &d), scanf("%d", &st), scanf("%d", &len);
p[0].tim = -1, p[0].tp = -1;
p[n + 1].tim = 1e18;
for (int i = 1; i <= n; i++) scanf("%d", &p[i].tim), scanf("%d", &p[i].tp);
for (int i = 0; i <= n; i++) {
sum += calc1(p[i].tp);
if (sum < -st) {
cout << -1;
return 0;
}
while (p[tail + 1].tim <= p[i].tim + len) {
++tail, res += calc2(p[tail].tp);
(mi) = (mi) <= (res) ? (mi) : (res);
}
if (sum + mi >= -st) {
cout << p[i].tim + 1;
return 0;
}
mi -= calc2(p[i + 1].tp);
res -= calc2(p[i + 1].tp);
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
bool br1, br2, br;
long long n, k, x, y, z, mini, maxi, w, l, ind, ini, sum, t, len, r, q, m,
imini;
long long _rank(long long x) {
long long sum = 0;
for (long long i = 1; i < n + 1; i++) sum += min(x / i, m);
return sum;
}
long long bin() {
x = 0;
z = n * m;
while (true) {
y = (x + z) / 2;
sum = _rank(y);
if (sum < k)
x = y + 1;
else if (sum >= k && _rank(y - 1) >= k)
z = y - 1;
else
return y;
}
}
void solve() {
cin >> n >> m >> k;
w = bin();
cout << w << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
string s;
long long n;
vector<long long> v;
bool check(long long x) {
long long pos = 0;
long long ret = 0;
for (int i = 0; i < (int)v.size(); i++) {
pos += v[i];
if (pos > x) {
pos = v[i];
ret++;
}
}
return ret + 1 <= n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
s = "";
while (s == "") getline(cin, s);
long long cur = 0, l = 0, r = s.size(), mid;
for (int i = 0; i < (int)s.size(); i++) {
cur++;
if (s[i] == ' ' || s[i] == '-') {
l = max(l, cur);
v.push_back(cur);
cur = 0;
}
}
l = max(l, cur);
v.push_back(cur);
while (l < r) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int m, n;
cin >> m >> n;
int a[111][111];
bool t = true;
int res[101][101];
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
res[i][j] = -1;
cin >> a[i][j];
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == 0) {
for (int k = 1; k <= n; k++) res[i][k] = 0;
for (int k = 1; k <= m; k++) res[k][j] = 0;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j] == 1) {
for (int k = 1; k <= n; k++) {
if (res[i][j] == -1) {
res[i][j] = 1;
break;
}
if ((res[i][k] == -1) || (res[i][k] == 1)) {
res[i][k] = 1;
t = true;
break;
} else {
t = false;
}
}
if (!t) {
for (int k = 1; k <= m; k++) {
if ((res[k][j] == -1) || (res[k][j] == 1)) {
res[k][j] = 1;
t = true;
break;
} else {
t = false;
}
}
}
if (!t) {
cout << "NO";
return 0;
}
}
}
}
if (!t) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) cout << res[i][j] << " ";
cout << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
double a, v, l, d, w, t, vf, v1, xf, x, d1;
double timp(double v0, double l) {
double x, t = 0;
x = (v * v - v0 * v0) / (2 * a);
if (x <= l) {
t += (double)(l - x) / v + x / ((v + v0) / 2);
return t;
} else {
v = (double)sqrt(2 * a * l + v0 * v0);
t = (double)l / ((double)(v + v0) / 2);
return t;
}
}
int main() {
cin >> a >> v >> l >> d >> w;
if (v <= w) {
cout << setprecision(7) << fixed << timp(0, l);
} else {
x = v * v;
x = (double)x / a;
x = (double)x / 2;
xf = (double)(v * v - w * w) / (2 * a);
if (x + xf <= d) {
t = x / (v / 2) + xf / ((v + w) / 2) + (d - x - xf) / v;
t += timp(w, l - d);
cout << setprecision(7) << fixed << t;
} else {
vf = sqrt(2 * a * d);
if (vf <= w) {
t = d / (vf / 2);
t += timp(vf, l - d);
cout << setprecision(7) << fixed << t;
} else {
d1 = (w * w + 2 * a * d) / (4 * a);
v1 = sqrt(2 * a * d1);
t = d1 / (v1 / 2) + (d - d1) / ((v1 + w) / 2);
t += timp(w, l - d);
cout << setprecision(7) << fixed << t;
}
}
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
stack<int> lf;
int q[12345], val[12345], op[12345], memo[12345][123][2];
bool done[12345][123][2], ispls;
string e;
void parse(int l, int r) {
if (e[l] == '(') {
parse(l + 1, q[l] - 1);
parse(q[l] + 1, r - 1);
op[l] = op[l + 1] + op[q[l] + 1] + 1;
} else {
op[l] = 0;
val[l] = e[l] - '0';
}
}
int dp(int v, int x, int type) {
int pr, mr, l, r, i;
if (x < 0 || x > op[v]) {
return ((type) ? ((1 << 30)) : (-(1 << 30)));
} else if (done[v][x][type]) {
return memo[v][x][type];
}
done[v][x][type] = true;
memo[v][x][type] = ((type) ? ((1 << 30)) : (-(1 << 30)));
if (op[v] < x) {
return memo[v][x][type];
} else if (op[v] == 0) {
memo[v][x][type] = val[v];
return memo[v][x][type];
}
l = v + 1;
r = q[v] + 1;
if (ispls) {
pr = x;
mr = op[v] - x;
if (pr > 0) {
pr--;
if (type) {
for (i = 0; i <= pr; i++) {
memo[v][x][type] =
min(memo[v][x][type], dp(l, i, 1) + dp(r, pr - i, 1));
}
} else {
for (i = 0; i <= pr; i++) {
memo[v][x][type] =
max(memo[v][x][type], dp(l, i, 0) + dp(r, pr - i, 0));
}
}
pr++;
}
if (mr > 0) {
if (type) {
for (i = 0; i <= pr; i++) {
memo[v][x][type] =
min(memo[v][x][type], dp(l, i, 1) - dp(r, pr - i, 0));
}
} else {
for (i = 0; i <= pr; i++) {
memo[v][x][type] =
max(memo[v][x][type], dp(l, i, 0) - dp(r, pr - i, 1));
}
}
}
} else {
pr = op[v] - x;
mr = x;
if (pr > 0) {
if (type) {
for (i = 0; i <= mr; i++) {
memo[v][x][type] =
min(memo[v][x][type], dp(l, i, 1) + dp(r, mr - i, 1));
}
} else {
for (i = 0; i <= mr; i++) {
memo[v][x][type] =
max(memo[v][x][type], dp(l, i, 0) + dp(r, mr - i, 0));
}
}
}
if (mr > 0) {
mr--;
if (type) {
for (i = 0; i <= mr; i++) {
memo[v][x][type] =
min(memo[v][x][type], dp(l, i, 1) - dp(r, mr - i, 0));
}
} else {
for (i = 0; i <= mr; i++) {
memo[v][x][type] =
max(memo[v][x][type], dp(l, i, 0) - dp(r, mr - i, 1));
}
}
mr++;
}
}
return memo[v][x][type];
}
int main(void) {
int i, n, p, m, ans;
fill(done[0][0], done[12345][0], false);
cin >> e;
cin >> p >> m;
n = e.length();
for (i = 0; i < n; i++) {
if (e[i] == '(') {
lf.push(i);
} else if (e[i] == '?') {
q[lf.top()] = i;
lf.pop();
}
}
ispls = (p <= m);
parse(0, n - 1);
ans = dp(0, min(p, m), 0);
cout << ans << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (is_same<int, long long>::value ? 1e18L + 666 : 1e9L + 666);
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <class t1, class t2>
bool cmax(t1 &a, const t2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class t1, class t2>
bool cmin(t1 &a, const t2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void run();
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
run();
}
vector<int> make_bfs(const vector<vector<int>> &g, int s) {
int n = ((int)(g).size());
vector<int> dist(n, INF);
dist[s] = 0;
queue<int> q;
q.push(s);
while (((int)(q).size())) {
int v = q.front();
q.pop();
for (auto &x : g[v]) {
if (cmin(dist[x], dist[v] + 1)) {
q.push(x);
}
}
}
return dist;
}
void run() {
int n, m, k;
cin >> n >> m >> k;
vector<int> fld(k);
for (auto &x : fld) {
cin >> x;
--x;
}
vector<vector<int>> g(n);
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> dist_fr = make_bfs(g, 0), dist_to = make_bfs(g, n - 1);
vector<pair<int, int>> d;
for (auto &x : fld) {
d.push_back({dist_fr[x], dist_to[x]});
}
sort(d.begin(), d.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first) {
return a < b;
}
return a > b;
});
int ans = 0;
int cur_mx = d.back().second;
for (int i = k - 2; i > -1; --i) {
cmax(ans, d[i].first + cur_mx + 1);
cmax(cur_mx, d[i].second);
}
cmin(ans, dist_fr[n - 1]);
cout << ans << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void _debug() { cerr << "]" << endl; }
template <typename T>
void _debug(T a) {
cerr << a << ']' << endl;
}
template <typename T, typename... Args>
void _debug(T a, Args... args) {
cerr << a << ", ";
_debug(args...);
}
void solve() {
int n, m, c = 0;
cin >> n >> m;
if (m % n != 0) {
cout << -1;
} else {
m /= n;
while (m % 2 == 0) {
m /= 2;
++c;
}
while (m % 3 == 0) {
m /= 3;
++c;
}
if (m != 1)
cout << -1;
else
cout << c;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
cout << flush;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = LLONG_MAX;
int n, q, sq, len, ord, ii, jj, val, mx, mn, mxpos, mnpos;
long long lazy[1000];
vector<pair<long long, long long> > S[1000];
inline int getseg(int pos) { return pos / sq + (pos % sq != 0); }
void prop(int as) {
for (int i = 0; i < S[as].size(); i++) {
S[as][i].first += lazy[as];
if (S[as][i].second >= ii && S[as][i].second <= jj) S[as][i].first += val;
}
lazy[as] = 0;
sort(S[as].begin(), S[as].end());
}
void update(int sts, int eds) {
for (int i = sts; i <= eds; i++) lazy[i] += val;
}
int query() {
long long FR = -inf, FL = inf;
for (int i = 1; i <= len; i++) {
int posL = 0, posR = 0;
posL =
lower_bound(S[i].begin(), S[i].end(), make_pair(val - lazy[i], -inf)) -
S[i].begin();
posR =
upper_bound(S[i].begin(), S[i].end(), make_pair(val - lazy[i], inf)) -
S[i].begin();
if (S[i][posL].first == val - lazy[i]) FL = min(FL, S[i][posL].second);
if (posR && S[i][posR - 1].first == val - lazy[i])
FR = max(FR, S[i][posR - 1].second);
}
if (FL == inf || FR == -inf) return -1;
return FR - FL;
}
int main() {
scanf("%d %d", &n, &q);
sq = sqrt(n);
len = n / sq + (n % sq != 0);
for (int i = 1; i <= n; i++) {
scanf("%d", &val);
S[getseg(i)].push_back(make_pair(val, i));
}
for (int i = 1; i <= len; i++) sort(S[i].begin(), S[i].end());
while (q--) {
scanf("%d", &ord);
if (ord == 1) {
scanf("%d %d %d", &ii, &jj, &val);
int second = getseg(ii);
int es = getseg(jj);
prop(second);
if (second != es) prop(es);
update(second + 1, es - 1);
} else {
scanf("%d", &val);
printf("%d\n", query());
}
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
int n, m, q;
int x[2000000];
int y[2000000];
int z[2000000];
void place(int i, int a) {
int j = i;
i += m;
x[i] = a;
y[i] = j;
z[i] = j;
while (i > 1) {
i /= 2;
x[i] = gcd(x[2 * i], x[2 * i + 1]);
y[i] = min(y[i], j);
z[i] = max(z[i], j);
}
}
bool test(int a, int i, int j) {
int p1 = 1, p2 = 1, p3 = -1;
while (p1 < m && x[p1] % a != 0) {
p1 *= 2;
if (z[p1] < i) p1++;
p2 = p2 * 2 + 1;
if (y[p2] > j) p2--;
if (p1 != p2) break;
}
if (p1 == p2) return true;
while (p1 < m) {
p1 *= 2;
if (z[p1] < i)
p1++;
else if (x[p1 + 1] % a != 0) {
if (p3 >= 0) return false;
p3 = p1 + 1;
}
p2 = p2 * 2 + 1;
if (y[p2] > j)
p2--;
else if (x[p2 - 1] % a != 0) {
if (p3 >= 0) return false;
p3 = p2 - 1;
}
}
if (x[p1] % a != 0) {
if (p3 >= 0) return false;
p3 = p1;
}
if (x[p2] % a != 0) {
if (p3 >= 0) return false;
p3 = p2;
}
while (p3 < m) {
p3 *= 2;
if (x[p3] % a != 0 && x[p3 + 1] % a != 0) return false;
if (x[p3 + 1] % a != 0) p3++;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
int a, b, c, d;
cin >> n;
m = 1;
while (m < n) m *= 2;
for (int i = 0; i < 2 * m; i++) {
y[i] = 2000000;
}
for (int i = 0; i < n; i++) {
cin >> a;
place(i, a);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> a;
if (a == 1) {
cin >> b >> c >> d;
b--;
c--;
if (test(d, b, c))
cout << "YES\n";
else
cout << "NO\n";
} else {
cin >> b >> c;
b--;
place(b, c);
}
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int a[27], cnt = 1, m, t, anss = 0, tmp[27], p[1005], num[1005];
char s[15];
long long n;
struct node {
int digit[125][125];
} ans, temp, start;
node times(node aa, node b, int x) {
node c;
for (int i = 0; i < x; i++)
for (int j = 0; j < x; j++) c.digit[i][j] = 0;
for (int i = 0; i < x; i++)
for (int j = 0; j < x; j++)
for (int k = 0; k < x; k++)
c.digit[i][j] =
(aa.digit[i][k] * b.digit[k][j] + c.digit[i][j]) % 12345;
return c;
}
void ksm(long long x) {
if (!x)
for (int i = 0; i < cnt; i++) ans.digit[i][i] = 1;
else {
ksm(x >> 1);
temp = times(ans, ans, cnt);
ans = temp;
if (x & 1) {
temp = times(ans, start, cnt);
ans = temp;
}
}
}
void init() {
scanf("%I64d %d\n", &n, &m);
for (int i = 1; i <= m; i++) {
gets(s + 1);
p[i] = s[1] - 'A' + 1;
tmp[s[1] - 'A' + 1] = 1;
for (int j = 3; s[j] >= '0' && s[j] <= '9'; j++)
num[i] = num[i] * 10 + s[j] - '0';
cnt *= num[i];
}
}
void ptm() {
for (int i = 1; i <= m; i++) tmp[p[i]] *= num[i];
for (int i = 0; i < cnt; i++) {
t = i;
for (int j = 1; j <= 26; j++)
if (tmp[j] != 0) a[j] = t % tmp[j], t /= tmp[j];
t = 1;
for (int j = 1; j <= 26; j++)
if (tmp[j] != 0) {
if (a[j] == tmp[j] - 1)
start.digit[i][i - a[j] * t]++;
else
start.digit[i][i + t]++;
t *= tmp[j];
}
}
}
void print() {
for (int i = 0; i < cnt; i++) {
t = i;
for (int j = 1; j <= 26; j++)
if (tmp[j] != 0) {
a[j] = t % tmp[j], t /= tmp[j];
int now = 1;
while (now <= m && (p[now] != j || a[j] % num[now] != 0)) now++;
if (now > m) goto syf;
}
anss = (anss + ans.digit[0][i]) % 12345;
syf:
t;
}
printf("%d\n", anss);
}
int main() {
init();
ptm();
ksm(n);
print();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-6;
const double pi = 1.00 * acos(-1.00);
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.ff);
cerr << ",";
_print(p.ss);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
struct custom_hash {
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return x + FIXED_RANDOM;
}
};
long long binaryExponential(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans % 1000000007 * a % 1000000007) % 1000000007;
}
a = (a % 1000000007 * a % 1000000007) % 1000000007;
b >>= 1;
}
return ans;
}
void seive() {
vector<long long> prime(10000007, 1);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= 10000007; i++) {
if (prime[i]) {
for (int j = i * i; j <= 10000007; j += i) prime[j] = 0;
}
}
}
bool isprime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long g, x, y;
void extendedEuclid(long long a, long long b) {
if (b == 0) {
g = a;
x = 1;
y = 0;
} else {
extendedEuclid(b, a % b);
long long temp = x;
x = y;
y = temp - (a / b) * y;
}
}
long long ETF(long long n) {
long long ans = n;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
ans = (ans / i) * (i - 1);
}
while (n % i == 0) n /= i;
}
if (n > 1) {
ans = (ans / n) * (n - 1);
}
return ans;
}
long long factors(long long n) {
long long count = 0;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
count++;
if (n / i != i) {
count++;
}
}
}
return count;
}
double myPow(double x, int n) {
if (n == 0) return 1.00000;
if (n < 0) {
return (n % 2 == 0) ? 1.00000 / myPow(x * x, abs(n / 2))
: 1.000 / (x * myPow(x * x, abs(n / 2)));
} else {
return (n % 2 == 0) ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
}
}
bool isUnique(vector<long long> &v) {
sort(v.begin(), v.end());
for (long long i = 0; i < v.size(); i++) {
if (v[i] == v[i + 1]) return false;
}
return true;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
void solution() {
long long n;
cin >> n;
vector<int> ans{2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
for (auto &x : ans) {
if ((n - x - 1) % x != 0) {
cout << n - x - 1 << ' ' << x << ' ' << 1 << "\n";
break;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
cout << fixed << setprecision(12);
while (t--) {
solution();
}
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], q, ans[200005], root[200005], len[200005];
int cidx[200005], hang[200005];
long long m[200005];
basic_string<int> inv[200005], qry[200005];
basic_string<int> root_inv[200005], occ[200005], hang_inv[200005];
bool st[200005], cyc[200005];
void dfs1(int x) {
int y = a[x];
st[x] = 1;
if (root[y]) {
root[x] = root[y];
} else if (st[y]) {
root[x] = x;
} else {
dfs1(y);
root[x] = root[y];
}
st[x] = 0;
}
int el[200005], er[200005], et, dub[200005];
void dfs2(int x, int h) {
el[x] = et++;
hang[x] = h;
hang_inv[h] += x;
for (int y : inv[x]) {
if (!cyc[y]) {
dub[y] = dub[x] + 1;
dfs2(y, h);
}
}
er[x] = et;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
inv[a[i]] += i;
}
cin >> q;
for (int i = 0; i < q; i++) {
int y;
cin >> m[i] >> y;
qry[y] += i;
}
for (int i = 1; i <= n; i++)
if (!root[i]) dfs1(i);
for (int i = 1; i <= n; i++) root_inv[root[i]] += i;
for (int i = 1; i <= n; i++) {
if (i == root[i]) {
int l = 1;
cyc[i] = 1;
for (int j = a[i]; j != i; j = a[j]) {
cidx[j] = l;
l++;
cyc[j] = 1;
}
len[i] = l;
}
}
for (int i = 1; i <= n; i++) {
if (cyc[i]) {
dfs2(i, i);
}
}
for (int i = 1; i <= n; i++) {
occ[dub[i]] += el[i];
}
for (int i = 0; i <= n; i++) sort(occ[i].begin(), occ[i].end());
for (int x = 1; x <= n; x++) {
if (!cyc[x]) {
for (int i : qry[x]) {
int d = min(200001ll, m[i] + dub[x]);
auto it1 = lower_bound(occ[d].begin(), occ[d].end(), el[x]);
auto it2 = lower_bound(occ[d].begin(), occ[d].end(), er[x]);
ans[i] = it2 - it1;
}
}
}
for (int x = 1; x <= n; x++) {
if (x == root[x]) {
int sz = root_inv[x].size(), l = len[x];
deque<int> w(sz);
for (int y : root_inv[x]) {
int h = hang[y];
w[dub[y] + (cidx[h] == 0 ? 0 : l - cidx[h])]++;
}
for (int i = l; i < sz; i++) w[i] += w[i - l];
for (int _i = 0, y = x; _i < l; _i++) {
for (int i : qry[y]) {
ans[i] = w[m[i] >= sz ? m[i] - (m[i] - sz) / l * l - l : m[i]];
}
y = a[y];
w.push_front(0);
for (int z : hang_inv[y]) w[dub[z]]++;
w.pop_back();
}
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3007;
string a[MAXN], b[MAXN];
long long l[MAXN], r[MAXN];
mt19937 rnd(time(0));
long long MOD = -1;
const long long BASE = 129;
const long long MN = 1e9;
const long long ADD = 1e6 + 7;
bool check(long long n) {
for (long long d = 2; d * d <= n; ++d) {
if (n % d == 0) return 0;
}
return 1;
}
void gen() {
while (1) {
MOD = MN + rnd() % ADD;
if (check(MOD)) break;
}
}
long long mod(long long n) { return (n % MOD + MOD) % MOD; }
long long n;
long long pw[MAXN];
vector<long long> h[MAXN];
void calc() {
pw[0] = 1;
for (long long i = 1; i < MAXN; ++i) pw[i] = mod(pw[i - 1] * BASE);
for (long long i = 0; i < n; ++i) {
h[i].push_back(0);
for (long long j = 0; j < (long long)a[i].size(); ++j) {
h[i].push_back(mod(h[i].back() * BASE + a[i][j]));
}
}
}
long long geth(long long i, long long l, long long r) {
return mod(h[i][r + 1] - h[i][l] * pw[r - l + 1]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) cin >> b[i];
gen();
calc();
for (long long i = 0; i < n; ++i) {
l[i] = MAXN;
r[i] = -MAXN;
for (long long t = 0; t < (long long)a[i].size(); ++t) {
if (a[i][t] != b[i][t]) {
l[i] = min(l[i], t);
r[i] = max(r[i], t);
}
}
}
string s, t;
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
for (long long j = l[i]; j <= r[i]; ++j) {
s += a[i][j];
t += b[i][j];
}
break;
}
}
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
if (r[i] - l[i] + 1 != s.size()) {
cout << "NO\n";
exit(0);
}
for (long long j = 0; j < (long long)s.size(); ++j) {
if (s[j] != a[i][l[i] + j]) {
cout << "NO\n";
exit(0);
}
if (t[j] != b[i][l[i] + j]) {
cout << "NO\n";
exit(0);
}
}
}
}
while (1) {
bool ch = 1;
char c = 0;
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
if (l[i] == 0) {
ch = 0;
} else {
if (!c)
c = a[i][l[i] - 1];
else if (c != a[i][l[i] - 1])
ch = 0;
}
}
}
if (!ch) break;
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) --l[i];
}
}
while (1) {
bool ch = 1;
char c = 0;
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
if (r[i] == a[i].size() - 1) {
ch = 0;
} else {
if (!c)
c = a[i][r[i] + 1];
else if (c != a[i][r[i] + 1])
ch = 0;
}
}
}
if (!ch) break;
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) ++r[i];
}
}
s.clear();
t.clear();
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
for (long long j = l[i]; j <= r[i]; ++j) {
s += a[i][j];
t += b[i][j];
}
break;
}
}
long long w = 0;
for (char c : s) w = mod(w * BASE + c);
for (long long i = 0; i < n; ++i) {
if (l[i] <= r[i]) {
for (long long j = 0; j < l[i]; ++j) {
if (w == geth(i, j, j + s.size() - 1)) {
cout << "NO\n";
exit(0);
}
}
} else {
for (long long j = 0; j + s.size() - 1 < (long long)a[i].size(); ++j) {
if (w == geth(i, j, j + s.size() - 1)) {
cout << "NO\n";
exit(0);
}
}
}
}
cout << "YES\n";
cout << s << '\n';
cout << t << '\n';
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define loop(i, a) for (int i = 0; i < (a); ++i)
#define cont(i, a) for (int i = 1; i <= (a); ++i)
#define circ(i, a, b) for (int i = (a); i <= (b); ++i)
#define range(i, a, b, c) for (int i = (a); (c) > 0 ? i <= (b) : i >= (b); i += (c))
#define parse(it, x) for (auto &it : (x))
#define pub push_back
#define pob pop_back
#define emb emplace_back
#define mak make_pair
#define mkt make_tuple
typedef long long ll;
typedef long double lf;
const int Inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
const int maxn = 1 << 18, mxlog = 18;
struct CF1515I {
ll a, w, v;
int id;
bool operator < (const CF1515I &x) const {
return mak(-v, w) < mak(-x.v, x.w);
}
} s[maxn];
int n, q;
struct SegtreeH {
ll ws[maxn << 1], vs[maxn << 1];
void inline add(int a, int x) {
int p = a;
for (a += maxn; a; a >>= 1) {
ws[a] += s[p].w * x;
vs[a] += s[p].v * x;
}
}
ll inline sumw(int l, int r) {
ll res = 0;
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += ws[l++];
if (r & 1) res += ws[--r];
}
return res;
}
int inline find(int l, int r, ll &val, ll &res, int now = 1, int nl = 0, int nr = maxn - 1) {
if (nl > r || nr < l || l > r) return -1;
if (nl >= l && nr <= r && ws[now] <= val) {
val -= ws[now]; res += vs[now];
return -1;
}
if (nl == nr) return nl;
int m = (nl + nr) >> 1;
int v = find(l, r, val, res, now << 1, nl, m);
if (!~v) v = find(l, r, val, res, now << 1 | 1, m + 1, nr);
return v;
}
} s1[mxlog + 1];
struct SegtreeHe {
ll mn[maxn << 1], tg[maxn << 1];
void inline init() { memset(mn, Inf, sizeof(mn)); }
void inline push(int a, ll x) { mn[a] += x; tg[a] += x; }
void inline pd(int now) {
if (tg[now]) {
push(now << 1, tg[now]);
push(now << 1 | 1, tg[now]);
tg[now] = 0;
}
}
void inline pu(int now) { mn[now] = min(mn[now << 1], mn[now << 1 | 1]); }
void inline add(int l, int r, ll x) {
l += maxn; r += maxn + 1;
int cl = l, cr = r;
range(i, mxlog, 1, -1) {
if ((l >> i << i) != l) pd(l >> i);
if ((r >> i << i) != r) pd(r >> i);
}
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) push(l++, x);
if (r & 1) push(--r, x);
}
l = cl; r = cr;
cont(i, mxlog) {
if ((l >> i << i) != l) pu(l >> i);
if ((r >> i << i) != r) pu(r >> i);
}
}
void inline change(int a, ll x) {
a += maxn;
range(i, mxlog, 1, -1) pd(a >> i);
mn[a] = x;
cont(i, mxlog) pu(a >> i);
}
int inline find(int l, int r, ll val, int now = 1, int nl = 0, int nr = maxn - 1) {
if (nl > r || nr < l || l > r) return -1;
if (nl >= l && nr <= r && mn[now] > val) return -1;
if (nl == nr) return nl;
int m = (nl + nr) >> 1; pd(now);
int v = find(l, r, val, now << 1, nl, m);
if (!~v) v = find(l, r, val, now << 1 | 1, m + 1, nr);
return v;
}
} s2[mxlog + 1];
int tp[maxn], dy[maxn];
void inline init(int lg) {
s2[lg].init();
loop(i, n) if (s[i].w < (1 << lg)) s1[lg].add(i, s[i].a);
loop(i, n) {
if (tp[i] != lg || !s[i].a) s2[lg].change(i, INF);
else s2[lg].change(i, s[i].w + s1[lg].sumw(0, i - 1));
}
}
void inline modify(int i, ll x) {
loop(lg, mxlog + 1) if (s[i].w < (1 << lg)) {
s1[lg].add(i, x);
s2[lg].add(i, maxn - 1, x * s[i].w);
}
int lg = tp[i];
if (!s[i].a) s2[lg].change(i, s[i].w + s1[lg].sumw(0, i - 1));
s[i].a += x;
if (!s[i].a) s2[lg].change(i, INF);
}
ll query(ll c) {
ll ans = 0;
int pos = 0;
range(lg, mxlog, 0, -1) if (c >= (1 << lg)) {
ll wc = c - (1 << lg);
int rpos = s2[lg].find(pos, maxn - 1, c + s1[lg].sumw(0, pos - 1));
if (!~rpos) rpos = maxn;
pos = s1[lg].find(pos, rpos - 1, wc, ans);
if (!~pos) pos = rpos;
c = wc + (1 << lg);
if (pos < n) {
ll d = min(s[pos].a, c / s[pos].w);
ans += d * s[pos].v;
c -= d * s[pos++].w;
}
if (pos >= n) break;
}
return ans;
}
int main() {
scanf("%d%d", &n, &q);
loop(i, n) scanf("%lld%lld%lld", &s[i].a, &s[i].w, &s[i].v), s[i].id = i + 1;
sort(s, s + n);
loop(i, n) {
while (s[i].w >= (1 << (tp[i] + 1))) ++tp[i];
dy[s[i].id] = i;
}
loop(i, mxlog + 1) init(i);
while (q--) {
int tp; scanf("%d", &tp);
if (tp <= 2) {
int k, d; scanf("%d%d", &k, &d);
d = dy[d]; if (tp == 2) k = -k;
modify(d, k);
}
else {
ll c; scanf("%lld", &c);
printf("%lld\n", query(c));
}
}
return 0;
}
| 26
|
#include <bits/stdc++.h>
using namespace std;
void preprocess(void) { return; }
template <typename flow_t = int, typename cost_t = int>
struct mcSFlow {
struct Edge {
cost_t c;
flow_t f;
int to, rev;
Edge(int _to, cost_t _c, flow_t _f, int _rev)
: c(_c), f(_f), to(_to), rev(_rev) {}
};
static constexpr cost_t INFCOST = numeric_limits<cost_t>::max() / 2;
cost_t eps;
int N, S, T;
vector<vector<Edge> > G;
vector<unsigned int> isq, cur;
vector<flow_t> ex;
vector<cost_t> h;
mcSFlow(int _N, int _S, int _T) : eps(0), N(_N), S(_S), T(_T), G(_N) {}
void add_edge(int a, int b, cost_t cost, flow_t cap) {
assert(cap >= 0);
assert(a >= 0 && a < N && b >= 0 && b < N);
if (a == b) {
assert(cost >= 0);
return;
}
cost *= N;
eps = max(eps, abs(cost));
G[a].emplace_back(b, cost, cap, G[b].size());
G[b].emplace_back(a, -cost, 0, G[a].size() - 1);
}
void add_flow(Edge &e, flow_t f) {
Edge &back = G[e.to][e.rev];
if (!ex[e.to] && f) hs[h[e.to]].push_back(e.to);
e.f -= f;
ex[e.to] += f;
back.f += f;
ex[back.to] -= f;
}
vector<vector<int> > hs;
vector<int> co;
flow_t max_flow() {
ex.assign(N, 0);
h.assign(N, 0);
hs.resize(2 * N);
co.assign(2 * N, 0);
cur.assign(N, 0);
h[S] = N;
ex[T] = 1;
co[0] = N - 1;
for (auto &e : G[S]) add_flow(e, e.f);
if (hs[0].size())
for (int hi = 0; hi >= 0;) {
int u = hs[hi].back();
hs[hi].pop_back();
while (ex[u] > 0) {
if (cur[u] == G[u].size()) {
h[u] = 1e9;
for (unsigned int i = 0; i < G[u].size(); ++i) {
auto &e = G[u][i];
if (e.f && h[u] > h[e.to] + 1) {
h[u] = h[e.to] + 1, cur[u] = i;
}
}
if (++co[h[u]], !--co[hi] && hi < N)
for (int i = 0; i < N; ++i)
if (hi < h[i] && h[i] < N) {
--co[h[i]];
h[i] = N + 1;
}
hi = h[u];
} else if (G[u][cur[u]].f && h[u] == h[G[u][cur[u]].to] + 1)
add_flow(G[u][cur[u]], min(ex[u], G[u][cur[u]].f));
else
++cur[u];
}
while (hi >= 0 && hs[hi].empty()) --hi;
}
return -ex[S];
}
void push(Edge &e, flow_t amt) {
if (e.f < amt) amt = e.f;
e.f -= amt;
ex[e.to] += amt;
G[e.to][e.rev].f += amt;
ex[G[e.to][e.rev].to] -= amt;
}
void relabel(int vertex) {
cost_t newHeight = -INFCOST;
for (unsigned int i = 0; i < G[vertex].size(); ++i) {
Edge const &e = G[vertex][i];
if (e.f && newHeight < h[e.to] - e.c) {
newHeight = h[e.to] - e.c;
cur[vertex] = i;
}
}
h[vertex] = newHeight - eps;
}
static constexpr int scale = 2;
pair<flow_t, cost_t> minCostMaxFlow() {
cost_t retCost = 0;
for (int i = 0; i < N; ++i)
for (Edge &e : G[i]) retCost += e.c * (e.f);
flow_t retFlow = max_flow();
h.assign(N, 0);
ex.assign(N, 0);
isq.assign(N, 0);
cur.assign(N, 0);
queue<int> q;
for (; eps; eps >>= scale) {
fill(cur.begin(), cur.end(), 0);
for (int i = 0; i < N; ++i)
for (auto &e : G[i])
if (h[i] + e.c - h[e.to] < 0 && e.f) push(e, e.f);
for (int i = 0; i < N; ++i) {
if (ex[i] > 0) {
q.push(i);
isq[i] = 1;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
isq[u] = 0;
while (ex[u] > 0) {
if (cur[u] == G[u].size()) relabel(u);
for (unsigned int &i = cur[u], max_i = (int)G[u].size(); i < max_i;
++i) {
Edge &e = G[u][i];
if (h[u] + e.c - h[e.to] < 0) {
push(e, ex[u]);
if (ex[e.to] > 0 && isq[e.to] == 0) {
q.push(e.to);
isq[e.to] = 1;
}
if (ex[u] == 0) break;
}
}
}
}
if (eps > 1 && eps >> scale == 0) {
eps = 1 << scale;
}
}
for (int i = 0; i < N; ++i) {
for (Edge &e : G[i]) {
retCost -= e.c * (e.f);
}
}
return make_pair(retFlow, retCost / 2 / N);
}
flow_t getFlow(Edge const &e) { return G[e.to][e.rev].f; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
preprocess();
int n, q;
cin >> n >> q;
mcSFlow<int, int> flow(2 * n + 2, 0, 2 * n + 1);
for (auto i = (1); i < n + 1; i++) {
for (auto j = (0); j < n; j++) {
flow.add_edge(0, i, 2 * j + 1, 1);
}
}
for (auto i = (n + 1); i < 2 * n + 1; i++) {
flow.add_edge(i, 2 * n + 1, 0, 1);
}
vector<int> ll(n + 1, 0), rr(n + 1, 1000000007);
for (auto j = (0); j < q; j++) {
int t, l, r, v;
cin >> t >> l >> r >> v;
if (t == 1) {
for (auto i = (l); i < r + 1; i++) ll[i] = max(ll[i], v);
} else {
for (auto i = (l); i < r + 1; i++) rr[i] = min(rr[i], v);
}
}
for (auto i = (1); i < n + 1; i++) {
for (auto j = (1); j < n + 1; j++) {
if (ll[j] <= i && i <= rr[j]) {
flow.add_edge(i, n + j, 0, 1);
}
}
}
auto ans = flow.minCostMaxFlow();
;
if (ans.first != n)
cout << -1 << endl;
else
cout << ans.second << endl;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
bool eq = true;
string pool;
int conc = 0;
string vowel = "aeiou";
for (int i = (int)(0); i < (int)(s.length()); i++) {
bool is_cons = find(vowel.begin(), vowel.end(), s[i]) == vowel.end();
if (not is_cons) {
eq = true;
conc = 0;
pool += s[i];
continue;
}
if (conc >= 2 && not(eq && pool[pool.size() - 1] == s[i])) {
cout << pool << " ";
eq = true;
pool = "";
conc = 0;
}
if (conc >= 1 && pool[pool.size() - 1] != s[i]) {
eq = false;
}
pool += s[i];
conc += 1;
}
cout << pool << endl;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 2000000009;
const double eps = 1e-9;
int main() {
int n;
int a[1005];
scanf("%d", &n);
for (int i = int(0); i <= int(n - 1); i++) scanf("%d", &a[i]);
bool f = true;
int ans = 0;
for (int i = 0; i < n - 1; i++) {
int count = 1;
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j] && a[i] != 0) count++;
}
if (count == 2) ans++;
if (count > 2) f = false;
}
if (f)
printf("%d\n", ans);
else
printf("-1\n");
return EXIT_SUCCESS;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int n = s.length();
bool turn = false;
int count = 0, i;
for (i = 0; i < n; i++) {
if (s[i] == t[i])
continue;
else {
count++;
if (turn == false) {
turn = true;
continue;
} else {
s[i] = t[i];
turn = false;
}
}
}
if (count % 2 == 0) {
cout << s;
cout << endl;
} else {
cout << "impossible";
cout << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
const int INF = (int)(1e9);
const long long INFLL = (long long)(1e18);
const double EPS = 1e-13;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> f(n), s(n), a(n + 1);
for (int i = (0); i < (int)(n); i++) cin >> f[i];
for (int i = (0); i < (int)(n); i++) cin >> s[i];
for (int i = (0); i < (int)(n); i++) a[s[i]] = i;
for (int i = (0); i < (int)(n); i++) f[i] = a[f[i]];
int best = -1, ans = 0;
for (int i = (0); i < (int)(n); i++) {
if (best > f[i]) {
ans = n - i;
break;
}
best = max(best, f[i]);
}
cout << ans << endl;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y;
void gcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (b == 0) {
d = a;
x = 1;
y = 0;
return;
}
gcd(b, a % b, d, y, x);
y -= (a / b) * x;
}
int get(long long x, long long y) {
long long a, b, d, key = x - y;
gcd(n, m, d, a, b);
if ((x - y) % d != 0) return -1;
long long k = m * n / d;
if (x - y == 0) {
a = k / n;
b = k / m;
return a % 2 * 2 + b % 2;
} else {
a *= (x - y) / d;
b *= (x - y) / d;
}
while (a < 0) a += k / n, b -= k / m;
while (a - k / n > 0) a -= k / n, b += k / m;
return a % 2 * 2 + (-b) % 2;
}
int main() {
int v, v2;
scanf("%I64d%I64d%I64d%I64d%d%d", &n, &m, &x, &y, &v, &v2);
if (v2 == 0) {
if (y == m || y == 0)
printf("%d %d\n", v == 1 ? (int)n : 0, (int)y);
else
printf("-1\n");
return 0;
}
if (v == 0) {
if (x == n || x == 0)
printf("%d %d\n", (int)x, v2 == 1 ? (int)m : 0);
else
printf("-1\n");
return 0;
}
if (v2 < 0) y = m - y;
if (v < 0) x = n - x;
int ans = get(x, y);
if (ans == -1) {
printf("-1\n");
return 0;
}
if (v2 < 0) ans = ans ^ 1;
if (v < 0) ans = ans ^ 2;
printf("%d %d\n", ans / 2 * (int)n, ans % 2 * (int)m);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int p = n / (2 * k + 1);
int q = n % (2 * k + 1);
if (p == 0) {
cout << "1\n";
cout << q / 2 + 1 << "\n";
} else if (q == 0) {
cout << p << "\n";
for (int i = 1; i <= p; ++i) {
cout << (k + 1) + (i - 1) * (2 * k + 1) << " ";
}
cout << "\n";
} else if (q <= k) {
cout << p + 1 << "\n";
cout << "1 ";
for (int i = 1; i <= p - 1; ++i) {
cout << 1 + i * (2 * k + 1) << " ";
}
cout << n - (q - 1) << "\n";
} else if (q <= 2 * k) {
cout << p + 1 << "\n";
for (int i = 1; i <= p; ++i) {
cout << (k + 1) + (i - 1) * (2 * k + 1) << " ";
}
cout << n - (q - (k + 1)) << "\n";
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long Set(long long n, long long pos) { return n | (1LL << pos); }
bool Check(long long n, long long pos) { return (bool)(n & (1LL << pos)); }
long long a[105][105];
int main() {
long long cs, ts, i, j, k, x, y, z, q, m, n;
while (scanf("%lld", &n) != EOF) {
memset(a, 0, sizeof(a));
a[1][2] = 1, a[2][1] = 1;
a[3][2] = 1, a[2][3] = 1;
a[1][3] = 1, a[3][1] = 1;
n -= 1;
long long sofar = 3;
while (n) {
sofar++;
for (i = 1; i < sofar; i++) {
x = i - 1;
if (n - x >= 0) {
n -= x;
a[i][sofar] = a[sofar][i] = 1;
} else
break;
}
}
printf("%lld\n", sofar);
for (i = 1; i <= sofar; i++) {
for (j = 1; j <= sofar; j++) {
printf("%lld", a[i][j]);
}
printf("\n");
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
int n, m, x, k, a[MAXN], c[MAXN];
long long ans, b[MAXN];
void add(int x) {
for (; x <= m; x += x & -x) c[x]++;
}
long long ask(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += c[x];
return ans;
}
int main() {
scanf("%d%d%d", &n, &x, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) {
b[++m] = a[i];
if (k == 0)
b[++m] = 1LL * a[i] / x * x + 1;
else {
b[++m] = 1LL * a[i] / x * x - 1LL * (k - 1) * x;
b[++m] = 1LL * a[i] / x * x - 1LL * (k - 1) * x - (x - 1);
}
}
sort(b + 1, b + m + 1);
for (int i = 1; i <= n; i++) {
int L, R;
if (k == 0) {
L = lower_bound(b + 1, b + m + 1, 1LL * a[i] / x * x + 1) - b;
R = lower_bound(b + 1, b + m + 1, a[i]) - b;
} else {
L = lower_bound(b + 1, b + m + 1,
1LL * a[i] / x * x - 1LL * (k - 1) * x - (x - 1)) -
b;
R = lower_bound(b + 1, b + m + 1,
1LL * a[i] / x * x - 1LL * (k - 1) * x) -
b;
}
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
add(pos);
ans += ask(R) - ask(L - 1);
}
memset(c, 0, sizeof(c));
for (int i = n; i >= 1; i--) {
int L, R;
if (k == 0) {
L = lower_bound(b + 1, b + m + 1, 1LL * a[i] / x * x + 1) - b;
R = lower_bound(b + 1, b + m + 1, a[i]) - b;
} else {
L = lower_bound(b + 1, b + m + 1,
1LL * a[i] / x * x - 1LL * (k - 1) * x - (x - 1)) -
b;
R = lower_bound(b + 1, b + m + 1,
1LL * a[i] / x * x - 1LL * (k - 1) * x) -
b;
}
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
ans += ask(R) - ask(L - 1);
add(pos);
}
cout << ans;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long w[100010], sum1[100010], sum2[100010];
int main() {
long long n, l, r, Ql, Qr;
cin >> n >> l >> r >> Ql >> Qr;
for (int i = 0; i < n; i++) cin >> w[i];
sum1[0] = w[n] = 0;
for (int i = 1; i <= n; i++) sum1[i] = sum1[i - 1] + w[i - 1] * l;
sum2[n] = 0;
for (int i = n - 1; i >= 0; i--) sum2[i] = sum2[i + 1] + w[i] * r;
long long ans = 1000000LL * 1000000LL * 1000LL;
for (long long i = 0; i <= n; i++) {
long long now;
if (i <= n - i)
now = sum1[i] + sum2[i] + max(0LL, n - 1 - (2 * min(i, n - i))) * Qr;
else
now = sum1[i] + sum2[i] + max(0LL, n - 1 - (2 * min(i, n - i))) * Ql;
ans = min(ans, now);
}
cout << ans << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
int n;
pair<int, int> p[200005];
int main() {
ios::sync_with_stdio(false);
cin >> n;
int v = 0, sta = 0, more = 0, ma = 2e9, ans = 0, l = 1, r = 0;
for (int i = 1; i <= n; i++) {
int s, t;
cin >> s;
int now;
if (s == 1) {
cin >> now;
v = now;
if (now <= p[r].first) {
continue;
}
while (p[r].first < now && r >= 1) {
r--;
ans++;
}
} else if (s == 2) {
if (more) ans += more, more = 0;
} else if (s == 3) {
cin >> now;
if (now < v) {
ans++;
continue;
}
p[++r] = {now, i};
} else if (s == 4) {
more = 0;
} else if (s == 5) {
ma = 2e9;
r = 0;
} else {
more++;
}
}
cout << ans;
return 0;
}
| 10
|
#include <bits/stdc++.h>
int n, m, c;
int main() {
scanf("%d%d", &n, &m);
c = n * m - 1;
for (int i = 0; i + i < c; i++)
printf("%d %d\n%d %d\n", i / m + 1, i % m + 1, (c - i) / m + 1,
(c - i) % m + 1);
if (!(c & 1)) printf("%d %d\n", n / 2 + 1, m / 2 + 1);
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2332;
int n, tot, A[N], B[N], R[N], T[N];
vector<pair<int, int> > V;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]), R[A[i]] = i;
for (int i = 1; i <= n; i++) scanf("%d", &B[i]), T[B[i]] = i;
for (int i = n; i; i--) {
if (A[i] == B[i]) continue;
for (int j = R[B[i]] + 1; j <= i; j++)
if (T[A[j]] <= R[B[i]]) {
int h = R[B[i]];
swap(A[h], A[j]);
swap(R[A[h]], R[A[j]]);
V.push_back({h, j});
tot += j - h;
}
}
printf("%d\n%d\n", tot, (int)V.size());
for (auto X : V) printf("%d %d\n", X.first, X.second);
return (0);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int N, serverAx, serverAy, tipo;
int x, y, serverBx, serverBy;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d%d%d", &tipo, &x, &y);
if (tipo == 1) {
serverAx += x;
serverAy += y;
} else {
serverBx += x;
serverBy += y;
}
}
if (serverAx >= ((serverAx + serverAy) / 2))
printf("LIVE\n");
else
printf("DEAD\n");
if (serverBx >= ((serverBy + serverBy) / 2))
printf("LIVE\n");
else
printf("DEAD\n");
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios_base :: sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int n; cin >> n;
vector<int> a(n), oc[n + 1];
for(int i = 0; i < n; i ++){
cin >> a[i];
oc[a[i]].push_back(i);
}
int x = 0, y = 0, ans = 0;
for(int i = 0; i < n; i ++){
if(a[i] == x || a[i] == y)
continue;
int n1 = (upper_bound(oc[x].begin(), oc[x].end(), i) - oc[x].begin());
int n2 = (upper_bound(oc[y].begin(), oc[y].end(), i) - oc[y].begin());
if(n1 >= oc[x].size())
n1 = n + 1;
else
n1 = oc[x][n1];
if(n2 >= oc[y].size())
n2 = n + 1;
else
n2 = oc[y][n2];
if(n1 >= n2)
ans ++, x = a[i];
else
ans ++, y = a[i];
}
cout << ans;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const int N = 2e5 + 5;
long long n, m, sti, stj;
char s[1005][1005];
bool vis[1005][1005][5][5], f;
bool inrange(int i, int j) {
if (i < n && i >= 0 && j < m && j >= 0 && s[i][j] != '*') return true;
return false;
}
void dfs(int i, int j, long long turn, long long dir) {
if (!inrange(i, j) || vis[i][j][turn][dir] || turn > 2 || f) return;
vis[i][j][turn][dir] = true;
if (s[i][j] == 'T') {
f = true;
return;
}
if (dir == 1) {
dfs(i, j + 1, turn, dir);
dfs(i, j - 1, turn, dir);
dfs(i, j, turn + 1, 2);
} else {
dfs(i + 1, j, turn, dir);
dfs(i - 1, j, turn, dir);
dfs(i, j, turn + 1, 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> s[i][j];
if (s[i][j] == 'S') sti = i, stj = j;
}
}
dfs(sti, stj, 0, 1);
dfs(sti, stj, 0, 2);
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 8
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.